@milaboratories/milaboratories.ui-examples.model 1.2.46 → 1.3.1

package/.turbo/turbo-build.log

@@ -1,16 +1,16 @@
  WARN  Issue while reading "/home/runner/_work/platforma/platforma/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @milaboratories/milaboratories.ui-examples.model@1.2.46 build /home/runner/_work/platforma/platforma/etc/blocks/ui-examples/model
+> @milaboratories/milaboratories.ui-examples.model@1.3.1 build /home/runner/_work/platforma/platforma/etc/blocks/ui-examples/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 8.4s
 
 ./src/index.ts → dist...
 (!) Circular dependency
 ../../../../sdk/model/dist/components/PFrameForGraphs.js -> ../../../../sdk/model/dist/components/PlDataTable.js -> ../../../../sdk/model/dist/components/PFrameForGraphs.js
-created dist in 2.8s
+created dist in 6.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.ui-examples.model@1.2.46 type-check /home/runner/_work/platforma/platforma/etc/blocks/ui-examples/model
+> @milaboratories/milaboratories.ui-examples.model@1.3.1 type-check /home/runner/_work/platforma/platforma/etc/blocks/ui-examples/model
 > ts-builder types --target block-model
 
 ↳ tsc --noEmit --project ./tsconfig.json

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @milaboratories/milaboratories.ui-examples.model
 
+## 1.3.1
+
+### Patch Changes
+
+- Updated dependencies [64cee78]
+  - @platforma-sdk/model@1.45.17
+
+## 1.3.0
+
+### Minor Changes
+
+- 3ef2381: Generelazation filters and annotations
+
+### Patch Changes
+
+- Updated dependencies [3ef2381]
+  - @platforma-sdk/model@1.45.0
+
 ## 1.2.46
 
 ### Patch Changes

package/dist/bundle.js

@@ -4392,6 +4392,36 @@
             }
         }
     }
+    /**
+     * @param dataInfo - The source DataInfo object
+     * @param cb - Callback, function that have access to every blob to visit them all
+     * @returns Nothing
+     */
+    function visitDataInfo(dataInfo, cb) {
+        switch (dataInfo.type) {
+            case 'Json':
+                // Json type doesn't contain blobs, so return as is
+                break;
+            case 'JsonPartitioned': {
+                // Visit each blob in parts
+                Object.values(dataInfo.parts).forEach(cb);
+                break;
+            }
+            case 'BinaryPartitioned': {
+                // Visit each index and values blob in parts
+                Object.values(dataInfo.parts).forEach((chunk) => {
+                    cb(chunk.index);
+                    cb(chunk.values);
+                });
+                break;
+            }
+            case 'ParquetPartitioned': {
+                // Visit each blob in parts
+                Object.values(dataInfo.parts).forEach(cb);
+                break;
+            }
+        }
+    }
     /**
      * Type guard function that checks if the given value is a valid DataInfoEntries.
      *
@@ -5528,6 +5558,89 @@
     const StagingAccessorName = 'staging';
     const MainAccessorName = 'main';
 
+    function filterDataInfoEntries(dataInfoEntries, axisFilters) {
+        // Sort filters by axis index in descending order to safely remove elements from arrays
+        const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
+        // Check for invalid filter axes
+        const { type } = dataInfoEntries;
+        switch (type) {
+            case 'Json': {
+                const { keyLength } = dataInfoEntries;
+                for (const [axisIdx] of axisFilters)
+                    if (axisIdx >= keyLength)
+                        throw new Error(`Can't filter on non-data axis ${axisIdx}. Must be >= ${keyLength}`);
+                break;
+            }
+            case 'JsonPartitioned':
+            case 'BinaryPartitioned':
+            case 'ParquetPartitioned': {
+                const { partitionKeyLength } = dataInfoEntries;
+                for (const [axisIdx] of axisFilters)
+                    if (axisIdx >= partitionKeyLength)
+                        throw new Error(`Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`);
+                break;
+            }
+            default:
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                throw new Error(`Unsupported data info type: ${type}`);
+        }
+        const keyMatchesFilters = (key) => {
+            for (const [axisIdx, axisValue] of sortedFilters)
+                if (key[axisIdx] !== axisValue)
+                    return false;
+            return true;
+        };
+        const removeFilteredAxes = (key) => {
+            const newKey = [...key];
+            // Remove axes in descending order to maintain correct indices
+            for (const [axisIdx] of sortedFilters)
+                newKey.splice(axisIdx, 1);
+            return newKey;
+        };
+        switch (dataInfoEntries.type) {
+            case 'Json': return {
+                type: 'Json',
+                keyLength: dataInfoEntries.keyLength - axisFilters.length,
+                data: dataInfoEntries.data
+                    .filter((entry) => keyMatchesFilters(entry.key))
+                    .map((entry) => ({
+                    key: removeFilteredAxes(entry.key),
+                    value: entry.value,
+                })),
+            };
+            case 'JsonPartitioned': return {
+                type: 'JsonPartitioned',
+                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                parts: dataInfoEntries.parts
+                    .filter((entry) => keyMatchesFilters(entry.key))
+                    .map((entry) => ({
+                    key: removeFilteredAxes(entry.key),
+                    value: entry.value,
+                })),
+            };
+            case 'BinaryPartitioned': return {
+                type: 'BinaryPartitioned',
+                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                parts: dataInfoEntries.parts
+                    .filter((entry) => keyMatchesFilters(entry.key))
+                    .map((entry) => ({
+                    key: removeFilteredAxes(entry.key),
+                    value: entry.value,
+                })),
+            };
+            case 'ParquetPartitioned': return {
+                type: 'ParquetPartitioned',
+                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                parts: dataInfoEntries.parts
+                    .filter((entry) => keyMatchesFilters(entry.key))
+                    .map((entry) => ({
+                    key: removeFilteredAxes(entry.key),
+                    value: entry.value,
+                })),
+            };
+        }
+    }
+
     const TraceEntry = z.object({
         type: z.string(),
         importance: z.number().optional(),
@@ -6011,88 +6124,24 @@
             return parsePColumnData(acc);
         throw new Error(`Unexpected input type: ${typeof acc}`);
     }
-
-    function filterDataInfoEntries(dataInfoEntries, axisFilters) {
-        // Sort filters by axis index in descending order to safely remove elements from arrays
-        const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
-        // Check for invalid filter axes
-        const { type } = dataInfoEntries;
-        switch (type) {
-            case 'Json': {
-                const { keyLength } = dataInfoEntries;
-                for (const [axisIdx] of axisFilters)
-                    if (axisIdx >= keyLength)
-                        throw new Error(`Can't filter on non-data axis ${axisIdx}. Must be >= ${keyLength}`);
-                break;
-            }
-            case 'JsonPartitioned':
-            case 'BinaryPartitioned':
-            case 'ParquetPartitioned': {
-                const { partitionKeyLength } = dataInfoEntries;
-                for (const [axisIdx] of axisFilters)
-                    if (axisIdx >= partitionKeyLength)
-                        throw new Error(`Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`);
-                break;
-            }
-            default:
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                throw new Error(`Unsupported data info type: ${type}`);
+    function isPColumnReady(c) {
+        const isValues = (d) => Array.isArray(d);
+        const isAccessor = (d) => d instanceof TreeNodeAccessor;
+        let ready = true;
+        if (isAccessor(c.data)) {
+            ready &&= c.data.getIsReadyOrError();
         }
-        const keyMatchesFilters = (key) => {
-            for (const [axisIdx, axisValue] of sortedFilters)
-                if (key[axisIdx] !== axisValue)
-                    return false;
-            return true;
-        };
-        const removeFilteredAxes = (key) => {
-            const newKey = [...key];
-            // Remove axes in descending order to maintain correct indices
-            for (const [axisIdx] of sortedFilters)
-                newKey.splice(axisIdx, 1);
-            return newKey;
-        };
-        switch (dataInfoEntries.type) {
-            case 'Json': return {
-                type: 'Json',
-                keyLength: dataInfoEntries.keyLength - axisFilters.length,
-                data: dataInfoEntries.data
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'JsonPartitioned': return {
-                type: 'JsonPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'BinaryPartitioned': return {
-                type: 'BinaryPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'ParquetPartitioned': return {
-                type: 'ParquetPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
+        else if (isDataInfo(c.data)) {
+            visitDataInfo(c.data, (v) => ready &&= v.getIsReadyOrError());
+        }
+        else if (!isValues(c.data)) {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            throw Error(`unsupported column data type: ${c.data}`);
         }
+        return ready;
+    }
+    function allPColumnsReady(columns) {
+        return columns.every(isPColumnReady);
     }
 
     function isPColumnValues(value) {
@@ -6898,6 +6947,8 @@
         // TODO remove all non-PColumn fields
         createPFrame(def) {
             this.verifyInlineAndExplicitColumnsSupport(def);
+            if (!allPColumnsReady(def))
+                return undefined;
             return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
         }
         createPTable(def) {
@@ -6916,7 +6967,10 @@
             else {
                 rawDef = this.patchPTableDef(def);
             }
-            this.verifyInlineAndExplicitColumnsSupport(extractAllColumns(rawDef.src));
+            const columns = extractAllColumns(rawDef.src);
+            this.verifyInlineAndExplicitColumnsSupport(columns);
+            if (!allPColumnsReady(columns))
+                return undefined;
             return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
         }
         /** @deprecated scheduled for removal from SDK */
@@ -6937,7 +6991,7 @@
         }
     }
 
-    var version = "1.44.14";
+    var version = "1.45.17";
 
     const PlatformaSDKVersion = version;
 
@@ -7236,41 +7290,6 @@
         }
         return labelColumns;
     }
-    /** Check if all columns are computed */
-    function allColumnsComputed(columns) {
-        const isValues = (d) => Array.isArray(d);
-        const isAccessor = (d) => d instanceof TreeNodeAccessor;
-        const isDataInfo = (d) => typeof d === 'object' && 'type' in d;
-        return columns
-            .map((c) => c.data)
-            .every((d) => {
-            if (isValues(d)) {
-                return true;
-            }
-            else if (isAccessor(d)) {
-                return d.getIsReadyOrError();
-            }
-            else if (isDataInfo(d)) {
-                const type = d.type;
-                switch (type) {
-                    case 'Json':
-                        return true;
-                    case 'JsonPartitioned':
-                        return Object.values(d.parts).every((p) => p.getIsReadyOrError());
-                    case 'BinaryPartitioned':
-                        return Object.values(d.parts)
-                            .every((p) => p.index.getIsReadyOrError() && p.values.getIsReadyOrError());
-                    case 'ParquetPartitioned':
-                        return Object.values(d.parts)
-                            .every((p) => p.getIsReadyOrError());
-                }
-            }
-            else {
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                throw Error(`unsupported column data type: ${d}`);
-            }
-        });
-    }
     function createPTableDef(params) {
         let coreColumns = params.columns;
         const secondaryColumns = [];
@@ -7360,6 +7379,8 @@
             coreColumnPredicate: ops?.coreColumnPredicate,
         });
         const fullHandle = ctx.createPTable(fullDef);
+        if (!fullHandle)
+            return undefined;
         const hiddenColumns = new Set((() => {
             const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
             if (hiddenColIds)
@@ -7381,7 +7402,7 @@
         const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
         const visibleLabelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
         // if at least one column is not yet computed, we can't show the table
-        if (!allColumnsComputed([...visibleColumns, ...visibleLabelColumns]))
+        if (!allPColumnsReady([...visibleColumns, ...visibleLabelColumns]))
             return undefined;
         const visibleDef = createPTableDef({
             columns: visibleColumns,
@@ -7393,6 +7414,8 @@
             coreColumnPredicate,
         });
         const visibleHandle = ctx.createPTable(visibleDef);
+        if (!visibleHandle)
+            return undefined;
         return {
             sourceId: tableStateNormalized.pTableParams.sourceId,
             fullTableHandle: fullHandle,
@@ -7757,6 +7780,7 @@
             { type: 'link', href: '/typography', label: 'Typography' },
             { type: 'link', href: '/ag-grid-vue', label: 'AgGridVue' },
             { type: 'link', href: '/ag-grid-vue-with-builder', label: 'AgGridVue with builder' },
+            { type: 'link', href: '/pl-annotations', label: 'PlAnnotations' },
             { type: 'link', href: '/pl-ag-data-table-v2', label: 'PlAgDataTableV2' },
             { type: 'link', href: '/pl-splash-page', label: 'PlSplashPage' },
             { type: 'link', href: '/pl-file-input-page', label: 'PlFileInputPage' },