@platforma-sdk/workflow-tengo 2.14.0 → 2.15.1

package/dist/tengo/lib/slices.lib.tengo

@@ -1,13 +1,13 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 enum := import("enum")
 
-/**
- * Returns length of the collection even if it's nil.
- * It's a one of rare differences of Tengo and Go.
- *
- * @param slice: []any | undefined - a slice
- * @return: length: int
- */
+
+
+
+
+
+
+
 length := func(slice) {
 	if is_undefined(slice) {
 		return 0
@@ -15,16 +15,16 @@ length := func(slice) {
 	return len(slice)
 }
 
-/**
- * Returns a slice of the array, but you can give negative from and to,
- * in which case it slices from the end like in Python.
- * Example: slice([1, 2, 3], 0, -1) == [1, 2]
- *
- * @param array: []any - a slice
- * @param from: number - an index we starts from
- * @param to: number - an index the slice will end
- * @return slice: []any - a sliced array.
- */
+
+
+
+
+
+
+
+
+
+
 slice := func(array, from, to) {
 	len := length(array)
 	if from < 0 {
@@ -37,14 +37,14 @@ slice := func(array, from, to) {
 	return array[from:to]
 }
 
-/**
- * Appends slices safely even some of them are nil.
- * It's one of rare differences of Tengo and Go.
- *
- * @param slice: []any - a slice
- * @param toAppend: ...any - elements we'll append to the slice
- * @return new slice: []any - the same slice but with appended elements.
- */
+
+
+
+
+
+
+
+
 safeAppend := func(slice, ...toAppend) {
 	if is_undefined(slice) {
 		slice = []
@@ -56,13 +56,13 @@ safeAppend := func(slice, ...toAppend) {
 	return append(slice, toAppend...)
 }
 
-/**
- * Returns an index of an element in the slice or -1 if it wasn't found.
- *
- * @param silce: []any
- * @param element: any
- * @return index: int - index of the element or -1
- */
+
+
+
+
+
+
+
 findElement := func(slice, element) {
 	for i, elem in slice {
 		if elem == element {
@@ -73,35 +73,35 @@ findElement := func(slice, element) {
 	return -1
 }
 
-/**
- * Returns a boolean of whether an element is in a slice.
- *
- * @param slice: []any
- * @param element: any - an element the function searches for.
- * @return found: bool
- */
+
+
+
+
+
+
+
 hasElement := func(slice, element) {
 	return findElement(slice, element) != -1
 }
 
-/**
- * Removes an element from the slice
- *
- * @param slice: []any
- * @param i: int - an index of the element to remove.
- * @return nothing
- */
+
+
+
+
+
+
+
 removeElement := func(slice, i) {
 	return safeAppend(slice[:i], slice[i+1:]...)
 }
 
-/**
- * Returns a new slice with elements for which a predicate returned true.
- *
- * @param slice: []any
- * @param predicateFn: func(elem): bool - a function that gets an element and returns a truthy or falsy value.
- * @return new slice: []any - a slice with matched elements.
- */
+
+
+
+
+
+
+
 filter := func(slice, predicateFn) {
 	newS := []
 	for _, elem in slice {
@@ -113,13 +113,13 @@ filter := func(slice, predicateFn) {
 	return newS
 }
 
-/**
- * Transforms each element of the slice to a new one and returns a new slice
- *
- * @param slice: []any
- * @param fn: func(elem): new elem - a function that gets an element and returns a transformed element.
- * @return new slice: []any - a new slice with transformed elements.
- */
+
+
+
+
+
+
+
 map := func(slice, fn) {
 	newS := []
 	for _, elem in slice {
@@ -129,16 +129,16 @@ map := func(slice, fn) {
 	return newS
 }
 
-/**
- * Returns the result of applying fn to the first 2 items in the slice, then
- * applying fn to that result and the 3rd item, etc.
- * If coll has only 1 item, it is returned and fn is not called.
- *
- * @param slice: []any
- * @param fn: func(any, element): new result.
- * a function that gets a result got so far and an element and returns a new result.
- * @return final result: any - the final result
- */
+
+
+
+
+
+
+
+
+
+
 reduce := func(slice, fn, ...init) {
 	result := undefined
 	for i, elem in slice {
@@ -152,7 +152,7 @@ reduce := func(slice, fn, ...init) {
 	return result
 }
 
-/** Returns true if the function applied to every element returns true. */
+
 every := func(slice, fn) {
 	for _, elem in slice {
 		if !fn(elem) {
@@ -162,11 +162,11 @@ every := func(slice, fn) {
 	return true
 }
 
-//
-// Simple quick-sort implementations:
-//   - with user-provided ordering
-//   - and with native sorting
-//
+
+
+
+
+
 
 _quickSortFn := func(arr, left, right, less) {
 	if is_undefined(arr) || len(arr) <= 1 || left < 0 || left >= len(arr) || right < 0 || right >= len(arr) || left >= right {
@@ -210,65 +210,65 @@ _quickSort := func(arr, left, right) {
 	return arr
 }
 
-/**
- * Sorts slice in-place, using native ordering.
- *
- * @param s: []any - a slice of elements of any comparable type
- * @return s: []any the same slice after sorting
- *
- */
+
+
+
+
+
+
+
 quickSortInPlace := func(s) {
 	_quickSort(s, 0, len(s)-1)
 	return s
 }
 
-/**
- * Copy the slice and returtn sorted slice according to native ordering.
- *
- * @param s: []any - a slice of elements of any comparable type
- * @return s: []any sorted slice
- *
- */
+
+
+
+
+
+
+
 quickSort := func(s) {
 	s = copy(s)
 	_quickSort(s, 0, len(s)-1)
 	return s
 }
 
-/**
- * Sorts slice in-place, using provided ordering function.
- *
- * @param s: []any - a slice of elements of any comparable type
- * @param less: func(a, b): boolean - define ordering, must return true, if a < b
- * @return s: []any the same slice after sorting
- */
+
+
+
+
+
+
+
 quickSortInPlaceFn := func(s, less) {
 	_quickSortFn(s, 0, len(s)-1, less)
 	return s
 }
 
-/**
- * Copy the slice and returtn sorted slice according to using provided ordering function.
- *
- * @param s: []any - a slice of elements of any comparable type
- * @param less: func(a, b): boolean - define ordering, must return true, if a < b
- * @return s: []any sorted slice
- *
- */
+
+
+
+
+
+
+
+
 quickSortFn := func(s, less) {
 	s = copy(s)
 	_quickSortFn(s, 0, len(s)-1, less)
 	return s
 }
 
-/**
- * Creates a copy of a slice and sorts it using a stable bubble sort.
- *
- * @param notSortedSlice: []any - a slice of elements of any type.
- * @param fn: func(elem): int - a function that transforms an element to a key.
- * @return sorted slice: []any
- *
- */
+
+
+
+
+
+
+
+
 sortByFn := func(notSortedSlice, fn) {
 	s := copy(notSortedSlice)
 
@@ -285,24 +285,24 @@ sortByFn := func(notSortedSlice, fn) {
 	return s
 }
 
-/**
- * Creates a slice from a set of elements
- *
- * @param set: map[element]any - a set
- * @return slice: []element - a slice of elements from the set, sorted by an element.
- */
+
+
+
+
+
+
 fromSet := func(set) {
 	slice := enum.map(set, func(k, _) { return k })
 	return sortByFn(slice, func(elem) { return elem })
 }
 
-/**
- * Normalizes a slice by ensuring it is never undefined.
- * Returns an empty slice if input is undefined, otherwise returns the input slice unchanged.
- *
- * @param s: any[]|undefined - Input slice that may be undefined
- * @returns any[] - Normalized slice, never undefined
- */
+
+
+
+
+
+
+
 normalize := func(s) {
 	if is_undefined(s) {
 		return []