Initial project import

tools/v/vlib/builtin/js/array.js.v

@@ -0,0 +1,645 @@
+module builtin
+
+import strings
+/// Internal representation of `array` type. It is used to implement slices and to make slices behave correctly
+/// it simply stores reference to original array and to index them properly it does index array relative to `index_start`.
+
+struct array_buffer {
+	arr         JS.Array
+	index_start int
+	len         int
+	cap         int
+	has_slice   bool
+}
+
+fn (mut a array_buffer) make_copy() {
+	if a.index_start != 0 || a.has_slice {
+		mut new_arr := JS.makeEmptyJSArray()
+		for i in 0 .. a.len {
+			#new_arr.push(a.val.get(i))
+
+			mut x := i
+			x = x
+		}
+		new_arr = new_arr
+		#a.val.arr = new_arr
+		#a.val.index_start = new int(0)
+		#a.val.has_slice = new bool(false)
+	}
+}
+
+#array_buffer.prototype.make_copy = function() { return array_buffer_make_copy(this) }
+// TODO(playX): Should this be implemented fully in JS, use generics or just voidptr?
+fn (a array_buffer) get(ix int) voidptr {
+	mut res := unsafe { nil }
+	#res = a.arr[a.index_start.val + ix.val];
+
+	return res
+}
+
+fn (mut a array_buffer) set(ix int, val voidptr) {
+	#a.val.arr[a.val.index_start.valueOf() + ix.valueOf()] = val;
+}
+
+#array_buffer.prototype.get = function(ix) { return array_buffer_get(this,ix);}
+#array_buffer.prototype.set = function(ix,val) { array_buffer_set(this,ix,val); }
+
+struct array {
+pub mut:
+	arr array_buffer
+
+	len int
+	cap int
+}
+
+fn v_sort(mut arr array, comparator fn (voidptr, voidptr) int) {
+	mut need_iter := true
+	for need_iter {
+		need_iter = false
+		for i := 1; i < arr.len; i++ {
+			if comparator(arr[i], arr[i - 1]) != 1 {
+				tmp := arr[i]
+				arr[i] = arr[i - 1]
+				arr[i - 1] = tmp
+				need_iter = true
+			}
+		}
+	}
+}
+
+// trim trims the array length to "index" without modifying the allocated data. If "index" is greater than len nothing will be changed.
+pub fn (mut a array) trim(index int) {
+	if index < a.len {
+		a.len = index
+	}
+}
+
+#function flatIntoArray(target, source, sourceLength, targetIndex, depth) {
+#"use strict";
+#
+#for (var sourceIndex = 0; sourceIndex < sourceLength; ++sourceIndex) {
+#if (sourceIndex in source) {
+#var element = source[sourceIndex];
+#if (depth > 0 && Array.isArray(element))
+#targetIndex = flatIntoArray(target, element, element.length, targetIndex, depth - 1);
+#else {
+#target[targetIndex] = element;
+#++targetIndex;
+#}
+#}
+#}
+#return targetIndex;
+#}
+#function flatArray(target,depth) {
+#var array = target
+#var length = array.length;
+#var depthNum = 1;
+#
+#if (depth !== undefined)
+#depthNum = +depth
+#
+#var result = []
+#
+#flatIntoArray(result, array, length, 0, depthNum);
+#return result;
+#}
+
+@[unsafe]
+pub fn (a array) repeat_to_depth(count int, depth int) array {
+	if count < 0 {
+		panic('array.repeat: count is negative: ${count}')
+	}
+	mut arr := empty_array()
+
+	if a.len > 0 {
+		for _ in 0 .. count {
+			for i in 0 .. a.len {
+				if depth > 0 {
+					// TODO
+				} else {
+					arr.push(a.arr.get(i))
+				}
+			}
+		}
+	}
+	return arr
+}
+
+// last returns the last element of the array.
+pub fn (a array) last() voidptr {
+	mut res := unsafe { nil }
+	#res = a.arr.get(new int(a.len-1));
+
+	return res
+}
+
+fn (a array) get(ix int) voidptr {
+	if ix < 0 || ix >= a.len {
+		return unsafe { nil }
+	}
+	mut result := unsafe { nil }
+	#result = a.arr.get(ix)
+
+	return result
+}
+
+pub fn (a array) repeat(count int) array {
+	unsafe {
+		return a.repeat_to_depth(count, 0)
+	}
+}
+
+#function makeEmptyArray() { return new array(new array_buffer({ arr: [], len: new int(0), index_start: new int(0), cap: new int(0) })); }
+#function makeEmptyJSArray() { return new Array(); }
+
+fn JS.makeEmptyArray() array
+fn JS.makeEmptyJSArray() JS.Array
+fn empty_array() array {
+	return JS.makeEmptyArray()
+}
+
+#function v_clone_for_array_value(value) {
+#if (value instanceof $ref || value instanceof voidptr || typeof value === 'function') return value;
+#return v_clone_value(value);
+#}
+
+fn (a &array) set_len(i int) {
+	#a.arr.arr.length=i
+}
+
+pub fn (mut a array) sort_with_compare(compare voidptr) {
+	#v_sort(a, compare instanceof voidptr ? compare.val : compare)
+}
+
+pub fn (mut a array) sort_with_compare_old(compare voidptr) {
+	#a.val.arr.arr.sort(compare instanceof voidptr ? compare.val : compare)
+}
+
+pub fn (mut a array) sort() {
+	#a.val.arr.arr.sort($sortComparator)
+}
+
+pub fn (a array) index(v string) int {
+	for i in 0 .. a.len {
+		#if (a.arr.get(i).toString() == v.toString())
+
+		{
+			return i
+		}
+	}
+	return -1
+}
+
+pub fn (a array) last_index(v string) int {
+	for i := a.len - 1; i >= 0; i-- {
+		#if (a.arr.get(i).toString() == v.toString())
+
+		{
+			return i
+		}
+	}
+	return -1
+}
+
+pub fn (a array) slice(start int, end int) array {
+	mut result := a
+	#let slice = a.arr.arr.slice(start,end)
+	#result = new array(new array_buffer({arr: a.arr.arr, len: new int(slice.length),cap: new int(slice.length),index_start: new int(start),has_slice: new bool(true)}))
+	#a.arr.has_slice = true
+	//#v_makeSlice(result)
+
+	return result
+}
+
+pub fn (mut a array) insert(i int, val voidptr) {
+	#a.val.arr.make_copy()
+	#a.val.arr.arr.splice(i,0,v_clone_for_array_value(val))
+	#a.val.arr.len.val = a.val.arr.arr.length
+}
+
+pub fn (mut a array) insert_many(i int, val voidptr, size int) {
+	#a.val.arr.make_copy()
+	#a.val.arr.arr.splice(i,0,...val.arr.slice(0,+size).map(v_clone_for_array_value))
+	#a.val.arr.len.val = a.val.arr.arr.length
+}
+
+fn (mut a array) push(val voidptr) {
+	#a.val.arr.make_copy()
+	#if (arguments[2] && arguments[2].valueOf()) {a.val.arr.arr.push(...val.map(v_clone_for_array_value))} else {
+	#a.val.arr.arr.push(v_clone_for_array_value(val))
+	#}
+	#a.val.arr.len.val = a.val.arr.arr.length
+}
+
+fn v_filter(arr array, callback fn (voidptr) bool) array {
+	mut filtered := empty_array()
+
+	for i := 0; i < arr.arr.len; i++ {
+		if callback(arr.arr.get(i)) {
+			filtered.push(arr.arr.get(i))
+		}
+	}
+	return filtered
+}
+
+fn v_map(arr array, callback fn (voidptr) voidptr) array {
+	mut mapped := empty_array()
+
+	for i := 0; i < arr.arr.len; i++ {
+		mapped.push(callback(arr.arr.get(i)))
+	}
+
+	return mapped
+}
+
+struct array_iterator {
+	ix  int
+	end int
+	arr JS.Array
+}
+
+#array_iterator.prototype.next = function () {
+#if (this.ix.val < this.end.val) {
+#this.ix.val++;
+#return {done: false, value: this.arr.arr.get(new int(this.ix.val-1))}
+#} else {
+#return {done: true, value: undefined}
+#}
+#}
+#array_iterator.prototype[Symbol.iterator] = function () { return this; }
+
+#array.prototype[Symbol.iterator] = function () { return new array_iterator({ix: new int(0),end: new int(this.arr.len),arr: this}); }
+#array.prototype.entries = function () { let result = []; for (let key = this.arr.index_start.val;key < this.arr.len.val;key++) { result.push([new int(key), this.arr.get(new int(key))]); } return result[Symbol.iterator](); }
+#array.prototype.map = function(callback) { return v_map(this,callback); }
+#array.prototype.filter = function(callback) { return v_filter(this,callback); }
+#Object.defineProperty(array.prototype,'cap',{ get: function () { return this.len; } })
+#array.prototype.any = function (value) {
+#let val ;if (typeof value == 'function') { val = function (x) { return value(x); } } else { val = function (x) { return vEq(x,value); } }
+#for (let i = 0;i < this.arr.arr.length;i++)
+#if (val(this.arr.get(i)))
+#return true;
+#
+#return false;
+#}
+
+#array.prototype.all = function (value) {
+#let val ;if (typeof value == 'function') { val = function (x) { return value(x); } } else { val = function (x) { return vEq(x,value); } }
+#for (let i = 0;i < this.arr.arr.length;i++)
+#if (!val(this.arr.get(i)))
+#return false;
+#
+#return true;
+#}
+//#Object.defineProperty(array_buffer.prototype,"len", { get: function() {return new int(this.arr.length);}, set: function(l) { this.arr.length = l.valueOf(); } })
+//#Object.defineProperty(array_buffer.prototype,"cap", { get: function() {return new int(this.arr.length);}, set: function(l) { this.arr.length = l.valueOf(); } })
+#
+#
+#function v_makeSlice(array) { Object.defineProperty(array,'len', {get: function() { return this.arr.len; }, set: function(l) { this.arr.len = l; }}) }
+// delete deletes array element at index `i`.
+pub fn (mut a array) delete(i int) {
+	a.delete_many(i, 1)
+}
+
+fn arr_copy(mut dst array, src array, count int) {
+	for i := 0; i < count; i++ {
+		dst.arr.set(i, src.arr.get(i))
+	}
+}
+
+// delete_many deletes `size` elements beginning with index `i`.
+pub fn (mut a array) delete_many(i int, size int) {
+	#a.val.arr.make_copy()
+	#a.val.arr.arr.splice(i.valueOf(),size.valueOf())
+	#a.val.arr.len.val = a.val.arr.arr.length
+}
+
+// prepend prepends one value to the array.
+pub fn (mut a array) prepend(val voidptr) {
+	a.insert(0, val)
+}
+
+// prepend_many prepends another array to this array.
+@[unsafe]
+pub fn (mut a array) prepend_many(val voidptr, size int) {
+	unsafe { a.insert_many(0, val, size) }
+}
+
+pub fn (a array) reverse() array {
+	mut res := empty_array()
+	#res.arr.arr = Array.from(a.arr).reverse()
+
+	return res
+}
+
+pub fn (mut a array) reverse_in_place() {
+	#a.val.arr.arr.reverse()
+}
+
+#array.prototype.$includes = function (elem) { return this.arr.arr.find(function(e) { return vEq(elem,e); }) !== undefined;}
+
+pub fn (mut a array) clear() {
+	#a.val.arr.make_copy()
+	#a.val.arr.arr.length = 0
+	#a.val.arr.len.val = 0
+}
+
+// reduce executes a given reducer function on each element of the array, resulting in a single output value.
+pub fn (a array) reduce(iter fn (int, int) int, accum_start int) int {
+	mut accum_ := accum_start
+	/*#for (let i = 0;i < a.arr.length;i++)  {
+	#accum_ = iter(accum_, a.arr[i])
+	#}*/
+	for i in 0 .. a.len {
+		accum_ = iter(accum_, a.get(i))
+	}
+
+	return accum_
+}
+
+pub fn (mut a array) pop() voidptr {
+	mut res := unsafe { nil }
+	#a.val.arr.make_copy()
+	#res = a.val.arr.arr.pop()
+	#a.val.arr.len.val = a.val.arr.arr.length
+
+	return res
+}
+
+pub fn (a array) first() voidptr {
+	mut res := unsafe { nil }
+	#res = a.arr.get(new int(0))
+
+	return res
+}
+
+#array.prototype.toString = function () {
+#let res = "["
+#for (let i = 0; i < this.arr.arr.length;i++) {
+#res += this.arr.get(i).toString();
+#if (i != this.arr.arr.length-1)
+#res += ', '
+#}
+#res += ']'
+#return res;
+#
+#}
+
+pub fn (a array) contains(key voidptr) bool
+
+// delete_last effectively removes last element of an array.
+pub fn (mut a array) delete_last() {
+	#a.val.arr.arr.pop();
+}
+
+@[unsafe]
+pub fn (a &array) free() {
+}
+
+// todo: once (a []u8) will work rewrite this
+pub fn (a array) bytestr() string {
+	res := ''
+	#for (let i = 0;i < a.arr.len.valueOf();i++) res.str += String.fromCharCode(a.arr.get(new int(i)))
+
+	return res
+}
+
+pub fn (a []string) str() string {
+	mut sb := strings.new_builder(a.len * 3)
+	sb.write_string('[')
+	for i in 0 .. a.len {
+		val := a[i]
+		sb.write_string("'")
+		sb.write_string(val)
+		sb.write_string("'")
+		if i < a.len - 1 {
+			sb.write_string(', ')
+		}
+	}
+	sb.write_string(']')
+	res := sb.str()
+	return res
+}
+
+pub fn (a array) to_js_array() JS.Array {
+	tmp := JS.Array.prototype.constructor()
+	for i in 0 .. a.len {
+		tmp.push(a.arr.get(i))
+	}
+	return tmp
+}
+
+pub fn (a array) to_number_array() JS.Array {
+	tmp := JS.Array.prototype.constructor()
+	for i in 0 .. a.len {
+		elem := a.arr.get(i)
+		_ := elem
+		#tmp.push(Number(elem.valueOf()));
+	}
+	return tmp
+}
+
+// push_many - appends multiple values to the end of the array.
+pub fn (mut a array) push_many(val voidptr, size int) {
+	a.insert_many(a.len, val, size)
+}
+
+type EveryFn = fn (JS.Number, JS.Number) JS.Boolean
+
+type BigEveryFn = fn (JS.BigInt, JS.Number) JS.Boolean
+
+pub interface JS.TypedArray {
+mut:
+	byteLength JS.Number
+	byteOffset JS.Number
+	length     JS.Number
+}
+
+pub interface JS.Uint8Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.Uint16Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.Uint32Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.BigUint64Array {
+	JS.TypedArray
+	at(index JS.Number) JS.BigInt
+	every(JS.BigEveryFn) JS.Boolean
+}
+
+pub interface JS.Int8Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.Int16Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.Int32Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.BigInt64Array {
+	JS.TypedArray
+	at(index JS.Number) JS.BigInt
+	every(JS.BigEveryFn) JS.Boolean
+}
+
+pub interface JS.Float32Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub interface JS.Float64Array {
+	JS.TypedArray
+	at(index JS.Number) JS.Number
+	every(JS.EveryFn) JS.Boolean
+}
+
+pub fn uint8_array(arr []u8) JS.Uint8Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut uint_arr := JS.Uint8Array{}
+	#uint_arr = new Uint8Array(tmp)
+
+	return uint_arr
+}
+
+pub fn uint16_array(arr []u16) JS.Uint16Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut uint_arr := JS.Uint16Array{}
+	#uint_arr = new Uint16Array(tmp)
+
+	return uint_arr
+}
+
+pub fn uint32_array(arr []u32) JS.Uint32Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut uint_arr := JS.Uint32Array{}
+	#uint_arr = new Uint32Array(tmp)
+
+	return uint_arr
+}
+
+pub fn int8_array(arr []i8) JS.Int8Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut int_arr := JS.Int8Array{}
+	#int_arr = new Int8Array(tmp)
+
+	return int_arr
+}
+
+pub fn int16_array(arr []i16) JS.Int16Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut int_arr := JS.Int16Array{}
+	#int_arr = new Int16Array(tmp)
+
+	return int_arr
+}
+
+pub fn int32_array(arr []int) JS.Int32Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut int_arr := JS.Int32Array{}
+	#int_arr = new Int32Array(tmp)
+
+	return int_arr
+}
+
+pub fn int64_array(arr []i64) JS.BigInt64Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut int_arr := JS.BigInt64Array{}
+	#int_arr = new BigInt64Array(tmp)
+
+	return int_arr
+}
+
+pub fn uint64_array(arr []u64) JS.BigUint64Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut int_arr := JS.BigUint64Array{}
+	#int_arr = new BigUint64Array(tmp)
+
+	return int_arr
+}
+
+pub fn float32_array(arr []f32) JS.Float32Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut float_arr := JS.Float32Array{}
+	#float_arr = new Float32Array(tmp)
+
+	return float_arr
+}
+
+pub fn float64_array(arr []f64) JS.Float64Array {
+	#let tmp = new Array();
+
+	for elem in arr {
+		_ := elem
+		#tmp.push(elem.val)
+	}
+	mut float_arr := JS.Float64Array{}
+	#float_arr = new Float64Array(tmp)
+
+	return float_arr
+}