@platforma-sdk/workflow-tengo 3.0.2 → 3.1.0

package/dist/tengo/lib/pframes.spec.lib.tengo

@@ -6,6 +6,8 @@
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+slices := import("@platforma-sdk/workflow-tengo:slices")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 json := import("json")
 
@@ -33,6 +35,12 @@ P_COLUMN_SPEC_SCHEMA := {
 	`axesSpec,?`: [ P_AXIS_SPEC_SCHEMA ]
 }
 
+P_OBJECT_SPEC_SCHEMA := ["or", P_COLUMN_SPEC_SCHEMA, {
+	`kind`: `string`,
+	`annotations,?`: { any: `string` }
+}]
+
+
 KIND_P_COLUMN := "PColumn"
 
 
@@ -251,9 +259,219 @@ makeTrace := func(input, ...steps) {
 	})
 }
 
+
+
+
+
+
+
+
+createSpecDistiller := func(specs) {
+
+
+	domainsValues := {}
+
+	addDomainValue := func(name, domainName, domainValue) {
+		if is_undefined(domainsValues[name]) {
+			domainsValues[name] = {}
+		}
+
+		if is_undefined(domainsValues[name][domainName]) {
+			domainsValues[name][domainName] = {}
+		}
+
+		domainsValues[name][domainName][domainValue] = true
+	}
+
+
+	for _, spec in specs {
+
+		columnName := spec.name
+		if !is_undefined(spec.domain) {
+			for domainName, domainValue in spec.domain {
+				addDomainValue(columnName, domainName, domainValue)
+			}
+		}
+
+
+		if !is_undefined(spec.axesSpec) {
+			for _, axis in spec.axesSpec {
+				axisName := axis.name
+				if !is_undefined(axis.domain) {
+					for domainName, domainValue in axis.domain {
+						addDomainValue(axisName, domainName, domainValue)
+					}
+				}
+			}
+		}
+	}
+
+
+	discriminativeDomains := {}
+	for name, domains in domainsValues {
+		for domainName, valueSet in domains {
+			if len(valueSet) > 1 {
+				if is_undefined(discriminativeDomains[name]) {
+					discriminativeDomains[name] = {}
+				}
+				discriminativeDomains[name][domainName] = true
+			}
+		}
+	}
+
+
+	filterDomain := func(domain, entityName) {
+		if is_undefined(domain) {
+			return undefined
+		}
+
+		filteredDomain := undefined
+
+		if !is_undefined(discriminativeDomains[entityName]) {
+			for domainName, domainValue in domain {
+				if sets.hasElement(discriminativeDomains[entityName], domainName) {
+					if is_undefined(filteredDomain) {
+						filteredDomain = {}
+					}
+					filteredDomain[domainName] = domainValue
+				}
+			}
+		}
+
+		return filteredDomain
+	}
+
+
+	distillEntity := func(entity, entityName) {
+		result := maps.clone(entity)
+
+		delete(result, "annotations")
+
+
+		filteredDomain := filterDomain(result.domain, entityName)
+		if !is_undefined(filteredDomain) {
+			result.domain = filteredDomain
+		} else if !is_undefined(result.domain) {
+			delete(result, "domain")
+		}
+
+		return result
+	}
+
+	result := undefined
+	result = ll.toStrict({
+
+
+
+
+
+
+		getDiscriminativeDomains: func(name) {
+			return slices.fromSet(discriminativeDomains[name])
+		},
+
+
+
+
+
+
+
+		getDiscriminativeDomainsSet: func(name) {
+			return discriminativeDomains[name]
+		},
+
+
+
+
+
+
+
+		distill: func(spec) {
+			result := distillEntity(spec, spec.name)
+
+
+			if !is_undefined(result.axesSpec) {
+				for i, axis in result.axesSpec {
+					result.axesSpec[i] = distillEntity(axis, axis.name)
+				}
+			}
+
+			return result
+		}
+	})
+
+	return result
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+prepareAxisFilters := func(rules, spec) {
+	axisFilters := []
+	filteredIndices := {}
+
+	for _, rule in rules {
+		if len(rule) != 2 {
+			ll.panic("Invalid filtering rule format: %v", rule)
+		}
+
+		axisIdentifier := rule[0]
+		value := rule[1]
+
+		axisIdx := axisIdentifier
+		if is_string(axisIdentifier) {
+			axisIdx = -1
+			for idx, axis in spec.axesSpec {
+				if axis.name == axisIdentifier {
+					axisIdx = idx
+					break
+				}
+			}
+
+			if axisIdx == -1 {
+				ll.panic("Cannot find axis with name '%v' in column spec %v", axisIdentifier, spec)
+			}
+		}
+
+		if !is_int(axisIdx) {
+			ll.panic("Axis identifier must be a number or a string that can be resolved to an index: %v", axisIdentifier)
+		}
+
+		valueStr := string(value)
+		axisFilters = append(axisFilters, [axisIdx, valueStr])
+		filteredIndices[axisIdx] = true
+	}
+
+	transformedSpec := maps.clone(spec)
+	newAxesSpec := []
+	for idx, axis in spec.axesSpec {
+		if !filteredIndices[idx] {
+			newAxesSpec = append(newAxesSpec, maps.clone(axis))
+		}
+	}
+	transformedSpec.axesSpec = newAxesSpec
+
+	return {
+		axisFilters: axisFilters,
+		columnSpec: transformedSpec
+	}
+}
+
 export ll.toStrict({
 	P_AXIS_SPEC_SCHEMA: P_AXIS_SPEC_SCHEMA,
 	P_COLUMN_SPEC_SCHEMA: P_COLUMN_SPEC_SCHEMA,
+	P_OBJECT_SPEC_SCHEMA: P_OBJECT_SPEC_SCHEMA,
 
 	KIND_P_COLUMN: KIND_P_COLUMN,
 
@@ -269,5 +487,10 @@ export ll.toStrict({
 	matchAxis: matchAxis,
 	matchAxes: matchAxes,
 
-	makeTrace: makeTrace
+	makeTrace: makeTrace,
+
+	createSpecDistiller: createSpecDistiller,
+
+	prepareAxisFilters: prepareAxisFilters
 })
+

package/dist/tengo/lib/pframes.xsv-import-file.lib.tengo

@@ -10,6 +10,9 @@ constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 transposeXsvSw := assets.importSoftware("@platforma-open/milaboratories.software-small-binaries:table-converter")
 pfconvSw := assets.importSoftware("@milaboratories/software-pframes-conv:main")
 
+
+importDirTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.import-dir")
+
 renderOps := func(defaults, ...ops) {
 	o := { }
 
@@ -109,9 +112,6 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
 	}
 
 
-	importDirTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.import-dir")
-
-
 	pureSpec := util.purifySpec(spec)
 
 

package/dist/tengo/lib/pframes.xsv.lib.tengo

@@ -5,12 +5,15 @@
 validation := import("@platforma-sdk/workflow-tengo:validation")
 constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 objects := import("@platforma-sdk/workflow-tengo:objects")
+smart := import("@platforma-sdk/workflow-tengo:smart")
 render := import("@platforma-sdk/workflow-tengo:render")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 util := import("@platforma-sdk/workflow-tengo:pframes.util")
+pBuilder := import("@platforma-sdk/workflow-tengo:pframes.builder")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 xsvIF := import("@platforma-sdk/workflow-tengo:pframes.xsv-import-file")
+text := import("text")
 
 importXsvIfNullTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-import-if-not-null")
 
@@ -180,6 +183,67 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 
 	return result
 }
+
+isFlatPfMap := func(pf) {
+	if !is_map(pf) {
+		return false
+	}
+
+	for key, _ in pf {
+		if !text.has_suffix(key, ".spec") && !text.has_suffix(key, ".data") {
+			return false
+		}
+	}
+
+	return true
+}
+
+isStructuredPfMap := func(pf) {
+	if !is_map(pf) {
+		return false
+	}
+
+	for _, value in pf {
+		if !is_map(value) {
+			return false
+		}
+
+		for k, _ in value {
+			if k != "spec" && k != "data" {
+				return false
+			}
+		}
+
+		if is_undefined(value.spec) || is_undefined(value.data) {
+			return false
+		}
+	}
+
+	return true
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -200,16 +264,27 @@ exportFrame := func(pf, xsvType, params, ...ops) {
 	if is_array(pf) {
 
 
-		pfm := {}
+		pfBuilder := pBuilder.pFrameBuilder()
 		i := 0
 		for col in pf {
 			ll.assert(!is_undefined(col.spec), "expected array of {spec, data} maps as a list of columns, but spec is undefined for: ", col)
 			ll.assert(!is_undefined(col.data), "expected array of {spec, data} maps as a list of columns, but data is undefined for: ", col)
-			pfm["" + i + ".spec"] = col.spec
-			pfm["" + i + ".data"] = col.data
+			pfBuilder.add(string(i), col.spec, col.data)
 			i = i + 1
 		}
-		pf = pfm
+		pf = pfBuilder.build()
+	} else if isStructuredPfMap(pf) {
+		pfBuilder := pBuilder.pFrameBuilder()
+		for key, value in pf {
+			pfBuilder.add(key, value.spec, value.data)
+		}
+		pf = pfBuilder.build()
+	} else if smart.isResource(pf) {
+		if !pf.checkResourceType(constants.RTYPE_P_FRAME) {
+			ll.panic("Unexpected resource type: %s", pf.info().Type.Name)
+		}
+	} else if !isFlatPfMap(pf) && !smart.isReference(pf) {
+		ll.panic("Unexpected p-frame format: %s", pf)
 	}
 
 	r := render.create(exportPfTpl, {

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

@@ -5,6 +5,7 @@
 
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
+slices := import("@platforma-sdk/workflow-tengo:slices")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 
 
@@ -32,6 +33,7 @@ toSlice := func(set) {
 	for v, _ in set {
 		sl = append(sl, v)
 	}
+	slices.quickSortInPlace(sl)
 	return sl
 }
 

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

@@ -292,8 +292,11 @@ sortByFn := func(notSortedSlice, fn) {
 
 
 fromSet := func(set) {
+	if is_undefined(set) {
+		return []
+	}
 	slice := enum.map(set, func(k, _) { return k })
-	return sortByFn(slice, func(elem) { return elem })
+	return quickSortInPlace(slice)
 }
 
 

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

@@ -1189,8 +1189,16 @@ structBuilder = func(resourceType, ...data) {
 
 
 
-_mapBuilder := func(isEph) {
-	builder := isEph ? ephemeralBuilder(constants.RTYPE_MAP_EPH) : structBuilder(constants.RTYPE_MAP)
+
+_mapBuilder := func(isEph, ...resourceType) {
+	mapType := undefined
+	if len(resourceType) > 0 {
+		mapType = resourceType[0]
+	} else {
+		mapType = isEph ? constants.RTYPE_MAP_EPH : constants.RTYPE_MAP
+	}
+
+	builder := isEph ? ephemeralBuilder(mapType) : structBuilder(mapType)
 
 	builder.lockOutputs()
 
@@ -1259,12 +1267,22 @@ _mapBuilder := func(isEph) {
 	return self
 }
 
-mapBuilder = func() {
-	return _mapBuilder(false)
+
+
+
+
+
+mapBuilder = func(...resourceType) {
+	return _mapBuilder(false, resourceType...)
 }
 
-ephemeralMapBuilder = func() {
-	return _mapBuilder(true)
+
+
+
+
+
+ephemeralMapBuilder = func(...resourceType) {
+	return _mapBuilder(true, resourceType...)
 }
 
 ephemeralBuilder = func(resourceType, ...data) {