@milaboratories/milaboratories.monetization-test.model 1.0.32 → 1.0.34

package/.turbo/turbo-build.log

@@ -1,14 +1,14 @@
  WARN  Issue while reading "/home/runner/_work/platforma/platforma/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @milaboratories/milaboratories.monetization-test.model@1.0.32 build /home/runner/_work/platforma/platforma/etc/blocks/monetization-test/model
+> @milaboratories/milaboratories.monetization-test.model@1.0.34 build /home/runner/_work/platforma/platforma/etc/blocks/monetization-test/model
 > ts-builder build --target block-model && block-tools build-model
 
 Building block-model project...
 ↳ rollup -c /configs/rollup.block-model.config.js
 
 ./src/index.ts → dist, dist...
-created dist, dist in 5.3s
+created dist, dist in 3.2s
 
 ./src/index.ts → dist...
-created dist in 6s
+created dist in 4.3s
 Build completed successfully

package/.turbo/turbo-type-check.log

@@ -1,6 +1,6 @@
  WARN  Issue while reading "/home/runner/_work/platforma/platforma/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @milaboratories/milaboratories.monetization-test.model@1.0.32 type-check /home/runner/_work/platforma/platforma/etc/blocks/monetization-test/model
+> @milaboratories/milaboratories.monetization-test.model@1.0.34 type-check /home/runner/_work/platforma/platforma/etc/blocks/monetization-test/model
 > ts-builder types --target block-model
 
 ↳ tsc --noEmit --project ./tsconfig.json

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @milaboratories/milaboratories.monetization-test.model
 
+## 1.0.34
+
+### Patch Changes
+
+- Updated dependencies [5deb79a]
+  - @platforma-sdk/model@1.47.5
+
+## 1.0.33
+
+### Patch Changes
+
+- Updated dependencies [a81ce44]
+  - @platforma-sdk/model@1.46.0
+
 ## 1.0.32
 
 ### Patch Changes

package/dist/bundle.js

@@ -4538,6 +4538,31 @@
         }
     }
 
+    /**
+     * Just for convenience, usually it is an Error with name 'AbortError'
+     */
+    function stringifyValue(value) {
+        if (typeof value === 'string') {
+            return `String value was thrown: ${value}`;
+        }
+        if (value && typeof value === 'object') {
+            try {
+                return `Plain object was thrown: ${JSON.stringify(value)}`;
+            }
+            catch (jsonError) {
+                const errorMessage = jsonError instanceof Error ? jsonError.message : String(jsonError);
+                return `Non-serializable object was thrown (JSON.stringify failed: ${errorMessage}): ${String(value)}`;
+            }
+        }
+        return String(`Non-Error value (${typeof value}) was thrown: ${value}`);
+    }
+    function ensureError(value) {
+        if (value instanceof Error) {
+            return value;
+        }
+        return new Error(stringifyValue(value));
+    }
+
     function getDefaultExportFromCjs (x) {
     	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
     }
@@ -4603,6 +4628,30 @@
     function readMetadata(metadata, key) {
         return metadata?.[key];
     }
+    function readMetadataJsonOrThrow(metadata, metadataJson, key, methodNameInError = 'readMetadataJsonOrThrow') {
+        const json = readMetadata(metadata, key);
+        if (json === undefined)
+            return undefined;
+        const schema = metadataJson[key];
+        try {
+            const value = JSON.parse(json);
+            return schema.parse(value);
+        }
+        catch (error) {
+            throw new Error(`${methodNameInError} failed, `
+                + `key: ${String(key)}, `
+                + `value: ${json}, `
+                + `error: ${ensureError(error)}`);
+        }
+    }
+    function readMetadataJson(metadata, metadataJson, key) {
+        try {
+            return readMetadataJsonOrThrow(metadata, metadataJson, key);
+        }
+        catch {
+            return undefined; // treat invalid values as unset
+        }
+    }
     /// Well-known annotations
     const Annotation = {
         DiscreteValues: 'pl7.app/discreteValues',
@@ -4640,7 +4689,7 @@
         Trace: 'pl7.app/trace',
     };
     const ValueTypeSchema = z.enum(['Int', 'Long', 'Float', 'Double', 'String']);
-    ({
+    const AnnotationJson = {
         [Annotation.DiscreteValues]: z.array(z.string()).or(z.array(z.number())),
         [Annotation.Graph.Axis.HighCardinality]: z.boolean(),
         [Annotation.Graph.Axis.LowerLimit]: z.number(),
@@ -4667,14 +4716,156 @@
         [Annotation.Sequence.IsAnnotation]: z.boolean(),
         [Annotation.Table.OrderPriority]: z.number(),
         [Annotation.Trace]: z.record(z.string(), z.unknown()),
-    });
+    };
     /// Helper function for reading plain annotation values
     function readAnnotation(spec, key) {
         return readMetadata(spec?.annotations, key);
     }
+    /// Helper function for reading json-encoded annotation values, returns undefined on JSON parsing error
+    function readAnnotationJson(spec, key) {
+        return readMetadataJson(spec?.annotations, AnnotationJson, key);
+    }
+    function isLinkerColumn(column) {
+        return !!readAnnotationJson(column, Annotation.IsLinkerColumn);
+    }
+    function makeAxisTree(axis) {
+        return { axis, children: [] };
+    }
+    /** Build tree by axis parents annotations */
+    function getAxesTree(rootAxis) {
+        const root = makeAxisTree(rootAxis);
+        let nodesQ = [root];
+        while (nodesQ.length) {
+            const nextNodes = [];
+            for (const node of nodesQ) {
+                node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+                nextNodes.push(...node.children);
+            }
+            nodesQ = nextNodes;
+        }
+        return root;
+    }
+    /** Get array of axisSpecs from axisTree */
+    function getArrayFromAxisTree(tree) {
+        const res = [tree.axis];
+        let nodesQ = [tree];
+        while (nodesQ.length) {
+            const nextNodes = [];
+            for (const node of nodesQ) {
+                for (const parent of node.children) {
+                    res.push(parent.axis);
+                    nextNodes.push(parent);
+                }
+            }
+            nodesQ = nextNodes;
+        }
+        return res;
+    }
+    function canonicalizeAxisWithParents(axis) {
+        return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+    }
+    function normalizingAxesComparator(axis1, axis2) {
+        if (axis1.name !== axis2.name) {
+            return axis1.name < axis2.name ? 1 : -1;
+        }
+        if (axis1.type !== axis2.type) {
+            return axis1.type < axis2.type ? 1 : -1;
+        }
+        const domain1 = canonicalizeJson(axis1.domain ?? {});
+        const domain2 = canonicalizeJson(axis2.domain ?? {});
+        if (domain1 !== domain2) {
+            return domain1 < domain2 ? 1 : -1;
+        }
+        const parents1 = canonicalizeAxisWithParents(axis1);
+        const parents2 = canonicalizeAxisWithParents(axis2);
+        if (parents1 !== parents2) {
+            return parents1 < parents2 ? 1 : -1;
+        }
+        const annotation1 = canonicalizeJson(axis1.annotations ?? {});
+        const annotation2 = canonicalizeJson(axis2.annotations ?? {});
+        if (annotation1 !== annotation2) {
+            return annotation1 < annotation2 ? 1 : -1;
+        }
+        return 0;
+    }
+    function parseParentsFromAnnotations(axis) {
+        const parentsList = readAnnotationJson(axis, Annotation.Parents);
+        if (parentsList === undefined) {
+            return [];
+        }
+        return parentsList;
+    }
+    function sortParentsDeep(axisSpec) {
+        axisSpec.parentAxesSpec.forEach(sortParentsDeep);
+        axisSpec.parentAxesSpec.sort(normalizingAxesComparator);
+    }
+    function hasCycleOfParents(axisSpec) {
+        const root = makeAxisTree(axisSpec);
+        let nodesQ = [root];
+        const ancestors = new Set(canonicalizeJson(getAxisId(axisSpec)));
+        while (nodesQ.length) {
+            const nextNodes = [];
+            const levelIds = new Set();
+            for (const node of nodesQ) {
+                node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+                for (const child of node.children) {
+                    const childId = canonicalizeJson(getAxisId(child.axis));
+                    if (!levelIds.has(childId)) {
+                        nextNodes.push(child);
+                        levelIds.add(childId);
+                        if (ancestors.has(childId)) {
+                            return true;
+                        }
+                        ancestors.add(childId);
+                    }
+                }
+            }
+            nodesQ = nextNodes;
+        }
+        return false;
+    }
+    /** Create list of normalized axisSpec (parents are in array of specs, not indexes) */
+    function getNormalizedAxesList(axes) {
+        if (!axes.length) {
+            return [];
+        }
+        const modifiedAxes = axes.map((axis) => {
+            const { parentAxes: _, ...copiedRest } = axis;
+            return { ...copiedRest, annotations: { ...copiedRest.annotations }, parentAxesSpec: [] };
+        });
+        axes.forEach((axis, idx) => {
+            const modifiedAxis = modifiedAxes[idx];
+            if (axis.parentAxes) { // if we have parents by indexes then take from the list
+                modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx) => modifiedAxes[idx]);
+            }
+            else { // else try to parse from annotation name
+                const parents = parseParentsFromAnnotations(axis).map((name) => modifiedAxes.find((axis) => axis.name === name));
+                modifiedAxis.parentAxesSpec = parents.some((p) => p === undefined) ? [] : parents;
+                delete modifiedAxis.annotations?.[Annotation.Parents];
+            }
+        });
+        if (modifiedAxes.some(hasCycleOfParents)) { // Axes list is broken
+            modifiedAxes.forEach((axis) => {
+                axis.parentAxesSpec = [];
+            });
+        }
+        else {
+            modifiedAxes.forEach((axis) => {
+                sortParentsDeep(axis);
+            });
+        }
+        return modifiedAxes;
+    }
     /// Well-known column names
     const PColumnName = {
         Label: 'pl7.app/label'};
+    /** Get column id and spec from a column */
+    function getColumnIdAndSpec(column) {
+        return {
+            columnId: column.id,
+            spec: column.spec,
+        };
+    }
     /** Extracts axis ids from axis spec */
     function getAxisId(spec) {
         const { type, name, domain } = spec;
@@ -5161,6 +5352,232 @@
         return canonicalize(result);
     }
 
+    class LinkerMap {
+        /** Graph of linkers connected by axes (single or grouped by parents) */
+        data;
+        constructor(linkerMap) {
+            this.data = linkerMap;
+        }
+        get keys() {
+            return this.data.keys();
+        }
+        get keyAxesIds() {
+            return [...this.data.keys()].map(parseJson);
+        }
+        static fromColumns(columns) {
+            const result = new Map();
+            for (const linker of columns.filter((l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn))) {
+                const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec)); // split input axes into groups by parent links from annotation
+                if (groups.length !== 2) {
+                    continue; // not a valid linker column
+                }
+                const [left, right] = groups;
+                // In case of group:
+                // A - C
+                //  \_ B _ D
+                // E/
+                // put 2 variants as keys:
+                // A - C
+                //  \_ B _ D
+                // and
+                // E - B - D
+                const leftKeyVariants = LinkerMap.getAxesRoots(left).map((axis) => {
+                    const axes = getArrayFromAxisTree(getAxesTree(axis));
+                    const key = canonicalizeJson(axes.map(getAxisId));
+                    return [key, axes];
+                });
+                const rightKeyVariants = LinkerMap.getAxesRoots(right).map((axis) => {
+                    const axes = getArrayFromAxisTree(getAxesTree(axis));
+                    const key = canonicalizeJson(axes.map(getAxisId));
+                    return [key, axes];
+                });
+                for (const [keyLeft, spec] of leftKeyVariants) {
+                    if (!result.has(keyLeft)) {
+                        result.set(keyLeft, { keyAxesSpec: spec, linkWith: new Map() });
+                    }
+                }
+                for (const [keyRight, spec] of rightKeyVariants) {
+                    if (!result.has(keyRight)) {
+                        result.set(keyRight, { keyAxesSpec: spec, linkWith: new Map() });
+                    }
+                }
+                for (const [keyLeft] of leftKeyVariants) {
+                    for (const [keyRight] of rightKeyVariants) {
+                        result.get(keyLeft)?.linkWith.set(keyRight, linker);
+                        result.get(keyRight)?.linkWith.set(keyLeft, linker);
+                    }
+                }
+            }
+            return new this(result);
+        }
+        /** Get all available nodes of linker graphs if start from sourceAxesKeys */
+        searchAvailableAxesKeys(sourceAxesKeys) {
+            const startKeys = new Set(sourceAxesKeys);
+            const allAvailableKeys = new Set();
+            let nextKeys = sourceAxesKeys;
+            while (nextKeys.length) {
+                const next = [];
+                for (const key of nextKeys) {
+                    const node = this.data.get(key);
+                    if (!node)
+                        continue;
+                    for (const availableKey of node.linkWith.keys()) {
+                        if (!allAvailableKeys.has(availableKey) && !startKeys.has(availableKey)) {
+                            next.push(availableKey);
+                            allAvailableKeys.add(availableKey);
+                        }
+                    }
+                }
+                nextKeys = next;
+            }
+            return allAvailableKeys;
+        }
+        /** Get all linker columns that are necessary to reach endKey from startKey */
+        searchLinkerPath(startKey, endKey) {
+            const previous = {};
+            let nextIds = new Set([startKey]);
+            const visited = new Set([startKey]);
+            while (nextIds.size) {
+                const next = new Set();
+                for (const nextId of nextIds) {
+                    const node = this.data.get(nextId);
+                    if (!node)
+                        continue;
+                    for (const availableId of node.linkWith.keys()) {
+                        previous[availableId] = nextId;
+                        if (availableId === endKey) {
+                            const ids = [];
+                            let current = endKey;
+                            while (previous[current] !== startKey) {
+                                ids.push(current);
+                                current = previous[current];
+                            }
+                            ids.push(current);
+                            return ids.map((id) => this.data.get(id).linkWith.get(previous[id]));
+                        }
+                        else if (!visited.has(availableId)) {
+                            next.add(availableId);
+                            visited.add(availableId);
+                        }
+                    }
+                }
+                nextIds = next;
+            }
+            return [];
+        }
+        getLinkerColumnsForAxes({ from: sourceAxes, to: targetAxes, throwWhenNoLinkExists = true, }) {
+            // start keys - all possible keys in linker map using sourceAxes (for example, all axes of block's columns or all axes of columns in data-inputs)
+            const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+            return Array.from(new Map(LinkerMap.getAxesRoots(targetAxes)
+                .map(LinkerMap.getLinkerKeyFromAxisSpec) // target keys contain all axes to be linked; if some of target axes has parents they must be in the key
+                .flatMap((targetKey) => {
+                const linkers = startKeys
+                    .map((startKey) => this.searchLinkerPath(startKey, targetKey))
+                    .reduce((shortestPath, path) => (shortestPath.length && shortestPath.length < path.length) || !path.length ? shortestPath : path, [])
+                    .map((linker) => [linker.columnId, linker]);
+                if (!linkers.length && throwWhenNoLinkExists) {
+                    throw Error(`Unable to find linker column for ${targetKey}`);
+                }
+                return linkers;
+            })).values());
+        }
+        /** Get list of axisSpecs from keys of linker columns map  */
+        getAxesListFromKeysList(keys) {
+            return Array.from(new Map(keys.flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
+                .map((axis) => [canonicalizeJson(getAxisId(axis)), axis])).values());
+        }
+        /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
+        getNonLinkableAxes(sourceAxes, targetAxes) {
+            const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+            // target keys contain all axes to be linked; if some of target axes has parents they must be in the key
+            const targetKeys = targetAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+            const axes = Array.from(new Map(targetAxes
+                .filter((_targetAxis, idx) => {
+                const targetKey = targetKeys[idx];
+                return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);
+            })
+                .flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [canonicalizeJson(getAxisId(axis)), axis]))).values());
+            return axes;
+        }
+        /** Get all axes that can be connected to sourceAxes by linkers */
+        getReachableByLinkersAxesFromAxesNormalized(sourceAxes, matchAxisIdFn) {
+            let startKeys = [];
+            if (matchAxisIdFn) {
+                const sourceAxisIdsGrouped = sourceAxes.map((axis) => getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+                for (const sourceAxisIdsGroup of sourceAxisIdsGrouped) {
+                    const matched = this.keyAxesIds.find((keyIds) => keyIds.every((linkerKeyAxisId) => sourceAxisIdsGroup.find((sourceAxisId) => matchAxisIdFn(linkerKeyAxisId, sourceAxisId))));
+                    if (matched) {
+                        startKeys.push(canonicalizeJson(matched));
+                    }
+                }
+            }
+            else {
+                startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+            }
+            const availableKeys = this.searchAvailableAxesKeys(startKeys);
+            return this.getAxesListFromKeysList([...availableKeys]);
+        }
+        getReachableByLinkersAxesFromAxes(sourceAxes, matchAxisIdFn) {
+            return this.getReachableByLinkersAxesFromAxesNormalized(getNormalizedAxesList(sourceAxes), matchAxisIdFn);
+        }
+        static getLinkerKeyFromAxisSpec(axis) {
+            return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+        }
+        /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.
+           There are no order inside every group. */
+        static getAxesGroups(axesSpec) {
+            switch (axesSpec.length) {
+                case 0: return [];
+                case 1: return [[axesSpec[0]]];
+            }
+            const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
+            const axisParentsIdxs = axesSpec.map((spec) => new Set(spec.parentAxesSpec
+                .map((spec) => canonicalizeJson(getAxisId(spec)))
+                .map((el) => {
+                const idx = axisKeys.indexOf(el);
+                if (idx === -1) {
+                    throw new Error(`malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`);
+                }
+                return idx;
+            })));
+            const allIdxs = [...axesSpec.keys()];
+            const groups = []; // groups of axis indexes
+            const usedIdxs = new Set();
+            let nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+            while (nextFreeEl !== undefined) {
+                const currentGroup = [nextFreeEl];
+                usedIdxs.add(nextFreeEl);
+                let nextElsOfCurrentGroup = [nextFreeEl];
+                while (nextElsOfCurrentGroup.length) {
+                    const next = new Set();
+                    for (const groupIdx of nextElsOfCurrentGroup) {
+                        const groupElementParents = axisParentsIdxs[groupIdx];
+                        allIdxs.forEach((idx) => {
+                            if (idx === groupIdx || usedIdxs.has(idx)) {
+                                return;
+                            }
+                            const parents = axisParentsIdxs[idx];
+                            if (parents.has(groupIdx) || groupElementParents.has(idx)) {
+                                currentGroup.push(idx);
+                                next.add(idx);
+                                usedIdxs.add(idx);
+                            }
+                        });
+                    }
+                    nextElsOfCurrentGroup = [...next];
+                }
+                groups.push([...currentGroup]);
+                nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+            }
+            return groups.map((group) => group.map((idx) => axesSpec[idx]));
+        }
+        /** Get all axes that are not parents of any other axis */
+        static getAxesRoots(axes) {
+            const parentsSet = new Set(axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))));
+            return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));
+        }
+    }
+
     /** Characters in string representation */
     const PlIdLength = 24; // = 15 bytes * 8 bits / 5 bits per char in base32
     z
@@ -6170,7 +6587,7 @@
             return undefined;
         }
         getUniversalEntries(predicateOrSelectors, opts) {
-            const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude } = opts ?? {};
+            const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude, enrichByLinkers = false } = opts ?? {};
             const labelOps = {
                 ...(overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false ? { includeNativeLabel: true } : {}),
                 ...(rawLabelOps ?? {}),
@@ -6343,6 +6760,29 @@
                     label: label,
                 });
             }
+            const ids = new Set(result.map((entry) => entry.id));
+            if (enrichByLinkers && anchorCtx) {
+                const linkers = result.filter((entry) => isLinkerColumn(entry.spec));
+                if (linkers.length === 0) {
+                    return result;
+                }
+                const anchorAxes = Object.values(anchorCtx.anchors).flatMap((anchor) => anchor.axesSpec);
+                const linkerMap = LinkerMap.fromColumns(linkers.map(getColumnIdAndSpec));
+                // loose way of matching
+                function matchAxisIdFn(linkerKeyId, sourceAxisId) {
+                    return matchAxisId(linkerKeyId, sourceAxisId) || matchAxisId(sourceAxisId, linkerKeyId);
+                }
+                // search all axes that can be reached by linkers from anchor axes; anchor axes are not in this list;
+                const availableByLinkersAxes = linkerMap.getReachableByLinkersAxesFromAxes(anchorAxes, matchAxisIdFn);
+                // search all columns that includes at least one of additional axes;
+                const availableByLinkersColumns = this.getUniversalEntries((spec) => !isLinkerColumn(spec) && spec.axesSpec.some((columnAxisSpec) => {
+                    const columnAxisId = getAxisId(columnAxisSpec);
+                    return availableByLinkersAxes.some((axis) => matchAxisIdFn(getAxisId(axis), columnAxisId));
+                }), { anchorCtx, labelOps, dontWaitAllData, overrideLabelAnnotation, exclude });
+                if (availableByLinkersColumns) {
+                    result.push(...availableByLinkersColumns.filter((entry) => !ids.has(entry.id)));
+                }
+            }
             return result;
         }
         getColumns(predicateOrSelectors, opts) {
@@ -6918,7 +7358,7 @@
         }
     }
 
-    var version = "1.45.45";
+    var version = "1.47.5";
 
     const PlatformaSDKVersion = version;