@platforma-sdk/workflow-tengo 2.8.1 → 2.8.3

package/dist/tengo/lib/render.lib.tengo

@@ -1,6 +1,5 @@
-/*
- * Create renderer objects to render templates from the code
- */
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
@@ -8,94 +7,84 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 tplutil := import("@platforma-sdk/workflow-tengo:tpl.util")
 constants := import("@platforma-sdk/workflow-tengo:constants")
 oop := import("@platforma-sdk/workflow-tengo:oop")
-validation := import("@platforma-sdk/workflow-tengo:validation")
 tx := import("tx")
 times := import("times")
 
 
 _SUBSCRIPTION_FIELD := "subscription"
 
-/**
- * Creates a render template resource.
- *
- * @param tpl: template resource (see assets.importTemplate())
- * @param isEph: whether template is ephemeral
- * @param inputs: a map of inputs to be passed to the template
- * @return renderer: a smart resource with additional output("name") method
- */
+
+
+
+
+
+
+
 createUniversal := func(tpl, isEph, inputs) {
 
-	// build renderer resource
-	rbuilder := undefined
-	if isEph {
-		rbuilder = smart.ephemeralBuilder(constants.RTYPE_RENDER_EPH_TEMPLATE)
-	}  else {
-		rbuilder = smart.structBuilder(constants.RTYPE_RENDER_TEMPLATE)
-	}
-
-	if isEph {
-		// create internal subscription field
-		rbuilder.createField(_SUBSCRIPTION_FIELD, "OTW")
-	}
-
-	// template input
-	rbuilder.createInputField(tplutil.TEMPLATE_FIELD).set(tpl)
-
-	// inputs input
-	inputsMap := isEph ? smart.ephemeralMapBuilder() : smart.mapBuilder()
-	for name, value in inputs {
-		inputsMap.add(name, value)
-	}
-
-	rbuilder.createInputField(tplutil.INPUTS_MAP_FIELD).set(inputsMap.build())
-	// build
-	renderer := rbuilder.lockInputsAndBuild()
-
-	self := undefined
-	self = ll.toStrict(oop.inherit(renderer, {
-
-		/**
-		 * Returns an output field with a given name
-		 */
-		output: func(name, ...cache) {
-			ll.assert(len(cache) == 0 || is_int(cache[0]), "cache should be a number (use 'times' tengo library), got: %v", cache)
-			out := renderer.getFutureOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name, isEph)
-			if len(cache) > 0 && cache[0] > 0 {
-				cache = cache[0]
-				tx.cacheSetToField(out.id, cache)
-			}
-
-			return out
-		}
-	}))
-
-	return self
+rbuilder := undefined
+if isEph {
+rbuilder = smart.ephemeralBuilder(constants.RTYPE_RENDER_EPH_TEMPLATE)
+}  else {
+rbuilder = smart.structBuilder(constants.RTYPE_RENDER_TEMPLATE)
+}
+
+if isEph {
+rbuilder.createField(_SUBSCRIPTION_FIELD, "OTW")
+}
+
+rbuilder.createInputField(tplutil.TEMPLATE_FIELD).set(tpl)
+
+inputsMap := isEph ? smart.ephemeralMapBuilder() : smart.mapBuilder()
+for name, value in inputs {
+inputsMap.add(name, value)
+}
+
+rbuilder.createInputField(tplutil.INPUTS_MAP_FIELD).set(inputsMap.build())
+renderer := rbuilder.lockInputsAndBuild()
+
+self := undefined
+self = ll.toStrict(oop.inherit(renderer, {
+
+
+
+output: func(name, ...cache) {
+ll.assert(len(cache) == 0 || is_int(cache[0]), "cache should be a number (use 'times' tengo library), got: %v", cache)
+out := renderer.getFutureOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name, isEph)
+if len(cache) > 0 && cache[0] > 0 {
+cache = cache[0]
+tx.cacheSetToField(out.id, cache)
 }
 
-/**
- * Creates a render template resource.
- *
- * @param tpl: template resource (see assets.importTemplate())
- * @param inputs: a map of inputs to be passed to the template
- * @return renderer: a smart resource with additional output("name") method
- */
+return out
+}
+}))
+
+return self
+}
+
+
+
+
+
+
+
 create := func(tpl, inputs) {
-	return createUniversal(tpl, false, inputs)
+return createUniversal(tpl, false, inputs)
 }
 
-/**
- * Creates ephemeral render template resource.
- *
- * @param tpl: template resource (see assets.importTemplate())
- * @param inputs: a map of inputs to be passed to the template
- * @return renderer: a smart resource with additional output("name") method
- */
+
+
+
+
+
+
 createEphemeral := func(tpl, inputs) {
-	return createUniversal(tpl, true, inputs)
+return createUniversal(tpl, true, inputs)
 }
 
 export ll.toStrict({
-	createUniversal: createUniversal,
-	create: create,
-	createEphemeral: createEphemeral
+createUniversal: createUniversal,
+create: create,
+createEphemeral: createEphemeral
 })

package/dist/tengo/lib/sets.lib.tengo

@@ -1,93 +1,86 @@
-/**
- * Functions for working with sets of elements,
- * in Tengo they are just maps with truthy values.
- * Keys of the map can be only either strings or numbers.
- */
+
+
+
+
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 
-/**
- * Turns a slice to a set of values.
- *
- * @param slice: slice<string|number>
- * @return result: set<string|number>
- */
+
+
+
+
+
 fromSlice := func(slice) {
-	set := {}
-	for _, elem in slice {
-		set[elem] = true
-	}
-	return set
+set := {}
+for _, elem in slice {
+set[elem] = true
+}
+return set
 }
 
-/**
- * Convert given set to slice
- *
- * @param set: set - a set of values to be converted to slice
- * @return slice: []<string|number>
- */
+
+
+
+
+
 toSlice := func(set) {
-	sl := []
-	for v, _ in set {
-		sl = append(sl, v)
-	}
-	return sl
+sl := []
+for v, _ in set {
+sl = append(sl, v)
 }
+return sl
+}
+
+
+
+
+
+
 
-/**
- * Checks if a set has an element.
- *
- * @param set a set of any elements
- * @param element any
- * @return found: bool
- */
 hasElement := func(set, element) {
-	return !is_undefined(set[element])
+return !is_undefined(set[element])
 }
 
-/**
- * Adds elements to the set.
- *
- * @param set a set
- * @param elements a slice of elements
- * @return: result: set<string|number> - a changed old set with all old and new elements.
- */
+
+
+
+
+
+
 add := func(set, ...elements) {
-	for _, elem in elements {
-		set[elem] = true
-	}
+for _, elem in elements {
+set[elem] = true
+}
 
-	return set
+return set
 }
 
-/**
- * Returns a set of key of the map.
- *
- * @param map a map
- * @return result: set<string|number>
- */
+
+
+
+
+
 fromMapKeys := func(map) {
-	keys := maps.getKeys(map)
-	return fromSlice(keys)
+keys := maps.getKeys(map)
+return fromSlice(keys)
 }
 
-/**
- * Transforms all keys of the map with a function and returns a new map with these keys.
- *
- * @param set: set
- * @param fn: func(elem): newElem - a function that gets an element and returns a new element.
- * @return new set: map[newElem]any - a transformed set
- */
+
+
+
+
+
+
 map := func(set, fn) {
-	return maps.mapKeys(set, fn)
+return maps.mapKeys(set, fn)
 }
 
 export ll.toStrict({
-	fromSlice: fromSlice,
-	toSlice: toSlice,
-	hasElement: hasElement,
-	add: add,
-	fromMapKeys: fromMapKeys,
-	map: map
+fromSlice: fromSlice,
+toSlice: toSlice,
+hasElement: hasElement,
+add: add,
+fromMapKeys: fromMapKeys,
+map: map
 })

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

@@ -1,202 +1,191 @@
 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
-	}
-	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.
- */
+if is_undefined(slice) {
+return 0
+}
+return len(slice)
+}
+
+
+
+
+
+
+
+
+
+
 slice := func(array, from, to) {
-	len := length(array)
-	if from < 0 {
-		from = len + from
-	}
-	if to < 0 {
-		to = len + 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.
- */
+len := length(array)
+if from < 0 {
+from = len + from
+}
+if to < 0 {
+to = len + to
+}
+
+return array[from:to]
+}
+
+
+
+
+
+
+
+
 safeAppend := func(slice, ...toAppend) {
-	if is_undefined(slice) {
-		slice = []
-	}
-	if length(toAppend) == 0 {
-		return slice // slice is of any length here.
-	}
-
-	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
- */
+if is_undefined(slice) {
+slice = []
+}
+if length(toAppend) == 0 {
+return slice // slice is of any length here.
+}
+
+return append(slice, toAppend...)
+}
+
+
+
+
+
+
+
 findElement := func(slice, element) {
-	for i, elem in slice {
-		if elem == element {
-			return i
-		}
-	}
-
-	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
- */
+for i, elem in slice {
+if elem == element {
+return i
+}
+}
+
+return -1
+}
+
+
+
+
+
+
+
 hasElement := func(slice, element) {
-	return findElement(slice, element) != -1
+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:]...)
+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 {
-		if predicateFn(elem) {
-			newS = append(newS, elem)
-		}
-	}
-
-	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.
- */
+newS := []
+for _, elem in slice {
+if predicateFn(elem) {
+newS = append(newS, elem)
+}
+}
+
+return newS
+}
+
+
+
+
+
+
+
 map := func(slice, fn) {
-	newS := []
-	for _, elem in slice {
-		newS = append(newS, fn(elem))
-	}
-
-	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
- */
+newS := []
+for _, elem in slice {
+newS = append(newS, fn(elem))
+}
+
+return newS
+}
+
+
+
+
+
+
+
+
+
+
 reduce := func(slice, fn) {
-	result := undefined
-	for i, elem in slice {
-		if i == 0 {
-			result = elem
-		} else {
-			result = fn(result, elem)
-		}
-	}
-
-	return result
-}
-
-/**
- * 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
- *
- */
+result := undefined
+for i, elem in slice {
+if i == 0 {
+result = elem
+} else {
+result = fn(result, elem)
+}
+}
+
+return result
+}
+
+
+
+
+
+
+
+
 sortByFn := func(notSortedSlice, fn) {
-	s := copy(notSortedSlice)
-
-	for i := 0; i < length(s) - 1; i++ {
-		for j := i+1; j < length(s); j++ {
-			if fn(s[i]) > fn(s[j]) {
-				tmp := s[i]
-				s[i] = s[j]
-				s[j] = tmp
-			}
-		}
-	}
-
-	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.
- */
+s := copy(notSortedSlice)
+
+for i := 0; i < length(s) - 1; i++ {
+for j := i+1; j < length(s); j++ {
+if fn(s[i]) > fn(s[j]) {
+tmp := s[i]
+s[i] = s[j]
+s[j] = tmp
+}
+}
+}
+
+return s
+}
+
+
+
+
+
+
 fromSet := func(set) {
-	slice := enum.map(set, func(k, _) { return k })
-	return sortByFn(slice, func(elem) { return elem })
+slice := enum.map(set, func(k, _) { return k })
+return sortByFn(slice, func(elem) { return elem })
 }
 
 export ll.toStrict({
-	length: length,
-	safeAppend: safeAppend,
-	findElement: findElement,
-	hasElement: hasElement,
-	removeElement: removeElement,
-	filter: filter,
-	map: map,
-	reduce: reduce,
-	sortByFn: sortByFn,
-	fromSet: fromSet,
-	slice: slice
+length: length,
+safeAppend: safeAppend,
+findElement: findElement,
+hasElement: hasElement,
+removeElement: removeElement,
+filter: filter,
+map: map,
+reduce: reduce,
+sortByFn: sortByFn,
+fromSet: fromSet,
+slice: slice
 })