@platforma-sdk/workflow-tengo 5.3.3 → 5.3.4

package/dist/tengo/lib/pt.util.lib.tengo

@@ -95,18 +95,6 @@ validateParamsForFrameFromColumnBundle := func(params) {
     ll.assert(len(params.columns) > 0, "At least one column is required")
 }
 
-unique := func(list) {
-    uniqueMap := {}
-    for _, item in list {
-        uniqueMap[item] = item
-    }
-    uniqueList := []
-    for _, item in uniqueMap {
-        uniqueList = append(uniqueList, item)
-    }
-    return uniqueList
-}
-
 makeFrameSpecs := func(params) {
 	axes := []
     for entry in params.axes {
@@ -121,7 +109,7 @@ makeFrameSpecs := func(params) {
             spec.annotations = entry.spec.annotations
         }
         if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
-            spec.parentAxes = unique(entry.spec.parentAxes)
+            spec.parentAxes = slices.sortUnique(entry.spec.parentAxes)
         }
         axes = append(axes, spec)
     }
@@ -140,7 +128,7 @@ makeFrameSpecs := func(params) {
             spec.annotations = entry.spec.annotations
         }
         if !is_undefined(entry.spec.parentAxes) && len(entry.spec.parentAxes) > 0 {
-            spec.parentAxes = unique(entry.spec.parentAxes)
+            spec.parentAxes = slices.sortUnique(entry.spec.parentAxes)
         }
         columns[entry.column] = spec
     }
@@ -183,10 +171,238 @@ makeFrameColumnRef := func(frameName, columnId) {
 	})
 }
 
+_AXIS_FILTER_SCHEMA := {
+
+	`axisIndex`: `number`,
+
+	`constant`: [`or`, `number`, `string`]
+}
+
+validateAxisFilters := func(axisFilter) {
+	validation.assertType(axisFilter, [_AXIS_FILTER_SCHEMA])
+}
+
+
+_JOIN_ENTRY_SCHEMA := undefined
+
+_JOIN_LEAF_SCHEMA := func(js, _, _) {
+	return validation.checkJson(js, _JOIN_ENTRY_SCHEMA)
+}
+_JOIN_SUBTREE_SCHEMA := func(js, _, _) {
+	return validation.checkJson(js, [_JOIN_ENTRY_SCHEMA])
+}
+
+_JOIN_ENTRY_SCHEMA = [`or`,
+    {
+
+		`type`: `string,regex=column`,
+
+		`columnId`: `string`
+	},
+    {
+
+        `type`: `string,regex=slicedColumn`,
+
+		`columnId`: `string`,
+
+        `newId`: `string`,
+
+        `axisFilters`: [_AXIS_FILTER_SCHEMA]
+    },
+    {
+
+        `type`: `string,regex=artificialColumn`,
+
+		`columnId`: `string`,
+
+        `newId`: `string`,
+
+        `axesIndices`: [`number`]
+    },
+    {
+
+        `type`: `string,regex=inlineColumn`,
+
+        `newId`: `string`,
+
+        `spec`: spec.P_COLUMN_STRICT_SPEC_SCHEMA,
+
+        `dataInfo`: {
+
+            `type`: `string,regex=Json`,
+
+            `keyLength`: `number`,
+
+            `data`: {
+                any: [`or`, `null`, `number`, `string`]
+            }
+        }
+    },
+	{
+
+		`type`: `string,regex=inner`,
+
+		`entries`: _JOIN_SUBTREE_SCHEMA
+	},
+	{
+
+		`type`: `string,regex=full`,
+
+		`entries`: _JOIN_SUBTREE_SCHEMA
+	},
+	{
+
+		`type`: `string,regex=outer`,
+
+		`primary`: _JOIN_LEAF_SCHEMA,
+
+
+		`secondary`: _JOIN_SUBTREE_SCHEMA
+	}]
+
+
+_PREDICATE_SCHEMA := undefined
+
+_PREDICATE_LEAF_SCHEMA := func(js, _, _) {
+	return validation.checkJson(js, _PREDICATE_SCHEMA)
+}
+_PREDICATE_SUBTREE_SCHEMA := func(js, _, _) {
+	return validation.checkJson(js, [_PREDICATE_SCHEMA])
+}
+_PREDICATE_SCHEMA = [`or`,
+    {
+
+		`operator`: `string,regex=IsNA`
+	},
+    {
+
+		`operator`: `string,regex=Equal|Less|LessOrEqual|Greater|GreaterOrEqual`,
+
+        `reference`: [`or`, `number`, `string`]
+	},
+    {
+
+		`operator`: `string,regex=InSet`,
+
+        `values`: [`or`, [`number`], [`string`]]
+    },
+    {
+
+		`operator`: `string,regex=IEqual`,
+
+        `reference`: `string`
+	},
+    {
+
+		`operator`: `string,regex=StringContains|StringIContains`,
+
+        `substring`: `string`
+	},
+    {
+
+		`operator`: `string,regex=Matches`,
+
+        `regex`: `string`
+	},
+    {
+
+		`operator`: `string,regex=StringContainsFuzzy|StringIContainsFuzzy`,
+
+        `reference`: `string`,
+
+        `maxEdits`: `number`,
+
+        `wildcard,?`: `string`,
+
+        `substitutionsOnly,?`: `bool`
+	},
+    {
+
+		`operator`: `string,regex=Not`,
+
+        `operand`: _PREDICATE_LEAF_SCHEMA
+    },
+    {
+
+		`operator`: `string,regex=And|Or`,
+
+        `operands`: [_PREDICATE_SUBTREE_SCHEMA]
+    }]
+
+_P_TABLE_COLUMN_ID_SCHEMA := [`or`,
+    {
+
+        `type`: `string,regex=column`,
+
+        `id`: `string`
+    },
+    {
+
+        `type`: `string,regex=axis`,
+
+        `axisId`: {
+            `name`: `string`,
+            `type`: `string,regex=Int|Long|String`,
+            `domain,?`: { any: `string` }
+        }
+    }]
+
+_FILTER_SCHEMA := {
+
+    `column`: _P_TABLE_COLUMN_ID_SCHEMA,
+
+    `predicate`: _PREDICATE_SCHEMA
+}
+
+
+_JOIN_REQUEST_SCHEMA := {
+    `__options__,closed`: true,
+
+    `src`: _JOIN_ENTRY_SCHEMA,
+
+    `filters`: [_FILTER_SCHEMA]
+}
+
+_renameJoinEntry := func(entry, rename) {
+    if entry.type == "column" || entry.type == "slicedColumn" || entry.type == "artificialColumn" {
+        entry.columnId = rename[entry.columnId]
+    } else if entry.type == "inner" || entry.type == "full" {
+        entry.entries = slices.map(entry.entries, func(entry) {
+            return _renameJoinEntry(entry, rename)
+        })
+    } else if entry.type == "outer" {
+        entry.primary = _renameJoinEntry(entry.primary, rename)
+        entry.secondary = slices.map(entry.secondary, func(entry) {
+            return _renameJoinEntry(entry, rename)
+        })
+    }
+    return entry
+}
+
+_renameJoinFilter := func(filter, rename) {
+    if filter.column.type == "column" {
+        filter.column.id = rename[filter.column.id]
+    }
+    return filter
+}
+
+renameJoinColumns := func(request, rename) {
+    validation.assertType(request, _JOIN_REQUEST_SCHEMA)
+    validation.assertType(rename, {any: `string`})
+    return {
+        src: _renameJoinEntry(request.src, rename),
+        filters: slices.map(request.filters, func(filter) {
+            return _renameJoinFilter(filter, rename)
+        })
+    }
+}
+
 export ll.toStrict({
     validateParamsForSaveFrameDirect: validateParamsForSaveFrameDirect,
 	validateParamsForFrameFromColumnBundle: validateParamsForFrameFromColumnBundle,
     makeFrameSpecs: makeFrameSpecs,
     makeWriteFrameStep: makeWriteFrameStep,
-    makeFrameColumnRef: makeFrameColumnRef
+    makeFrameColumnRef: makeFrameColumnRef,
+    renameJoinColumns: renameJoinColumns,
+    validateAxisFilters: validateAxisFilters
 })

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

@@ -349,6 +349,24 @@ normalize := func(s) {
 	return copy(s)
 }
 
+
+
+
+
+
+
+sortUnique := func(list) {
+    uniqueMap := {}
+    for _, item in list {
+        uniqueMap[item] = item
+    }
+    uniqueList := []
+    for _, item in uniqueMap {
+        uniqueList = append(uniqueList, item)
+    }
+    return quickSortInPlace(uniqueList)
+}
+
 export ll.toStrict({
 	length: length,
 	safeAppend: safeAppend,
@@ -367,5 +385,6 @@ export ll.toStrict({
 	sortByFn: sortByFn,
 	fromSet: fromSet,
 	slice: slice,
-	normalize: normalize
+	normalize: normalize,
+	sortUnique: sortUnique
 })

package/dist/tengo/lib/smart.lib.tengo

@@ -522,7 +522,6 @@ resource = func(r) {
 
 
 
-
 		metaInputs: func() {
 			if self._metaInputs == undefined {
 				info := self.info()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.3.3",
+  "version": "5.3.4",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.7",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.23",
-    "@platforma-open/milaboratories.software-ptabler": "1.12.4",
+    "@platforma-open/milaboratories.software-ptabler": "1.12.5",
     "@platforma-open/milaboratories.software-ptexter": "1.1.1"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.3.0"
+    "@platforma-sdk/tengo-builder": "2.3.1"
   },
   "scripts": {
     "type-check": "pl-tengo check",