@platforma-open/milaboratories.clonotype-clustering.model 2.14.0 → 2.14.1

package/.turbo/turbo-build.log

@@ -1,14 +1,16 @@
  WARN  Issue while reading "/home/runner/work/clonotype-clustering/clonotype-clustering/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.clonotype-clustering.model@2.14.0 build /home/runner/work/clonotype-clustering/clonotype-clustering/model
+> @platforma-open/milaboratories.clonotype-clustering.model@2.14.1 build /home/runner/work/clonotype-clustering/clonotype-clustering/model
 > ts-builder build --target block-model && block-tools build-model
 
 Building block-model project...
 ↳ rollup -c /home/runner/work/clonotype-clustering/clonotype-clustering/node_modules/.pnpm/@milaboratories+ts-builder@1.2.1_@microsoft+api-extractor@7.55.2_@types+node@24.5.2__@types+n_6gqrcohg6rrrhu5lui6bcpwgfa/node_modules/@milaboratories/ts-builder/dist/configs/rollup.block-model.config.js
 
 ./src/index.ts → dist, dist...
-created dist, dist in 3s
+created dist, dist in 2.5s
 
 ./src/index.ts → dist...
-created dist in 3.4s
+(!) Circular dependency
+../node_modules/.pnpm/@platforma-sdk+model@1.49.0/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js -> ../node_modules/.pnpm/@platforma-sdk+model@1.49.0/node_modules/@platforma-sdk/model/dist/pframe_utils/columns.js -> ../node_modules/.pnpm/@platforma-sdk+model@1.49.0/node_modules/@platforma-sdk/model/dist/components/PFrameForGraphs.js
+created dist in 3.2s
 Build completed successfully

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
  WARN  Issue while reading "/home/runner/work/clonotype-clustering/clonotype-clustering/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.clonotype-clustering.model@2.14.0 lint /home/runner/work/clonotype-clustering/clonotype-clustering/model
+> @platforma-open/milaboratories.clonotype-clustering.model@2.14.1 lint /home/runner/work/clonotype-clustering/clonotype-clustering/model
 > eslint .
 

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

@@ -1,6 +1,6 @@
  WARN  Issue while reading "/home/runner/work/clonotype-clustering/clonotype-clustering/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.clonotype-clustering.model@2.14.0 type-check /home/runner/work/clonotype-clustering/clonotype-clustering/model
+> @platforma-open/milaboratories.clonotype-clustering.model@2.14.1 type-check /home/runner/work/clonotype-clustering/clonotype-clustering/model
 > ts-builder types --target block-model
 
 ↳ tsc --noEmit --project ./tsconfig.json --customConditions ,

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @platforma-open/milaboratories.clonotype-clustering.model
 
+## 2.14.1
+
+### Patch Changes
+
+- fdec994: Use BLOSUM Alignment score by default
+
 ## 2.14.0
 
 ### Minor Changes

package/dist/bundle.js

@@ -7373,7 +7373,7 @@
         }
     }
 
-    var version = "1.48.4";
+    var version = "1.49.0";
 
     const PlatformaSDKVersion = version;
 
@@ -7393,52 +7393,52 @@
      * to call {@link done()} at the end of configuration. Value returned by this builder must be
      * exported as constant with name "platforma" from the "config" module. */
     class BlockModel {
-        _renderingMode;
-        _initialArgs;
-        _initialUiState;
-        _outputs;
-        _inputsValid;
-        _sections;
-        _title;
-        _enrichmentTargets;
-        _featureFlags;
-        constructor(_renderingMode, _initialArgs, _initialUiState, _outputs, _inputsValid, _sections, _title, _enrichmentTargets, _featureFlags) {
-            this._renderingMode = _renderingMode;
-            this._initialArgs = _initialArgs;
-            this._initialUiState = _initialUiState;
-            this._outputs = _outputs;
-            this._inputsValid = _inputsValid;
-            this._sections = _sections;
-            this._title = _title;
-            this._enrichmentTargets = _enrichmentTargets;
-            this._featureFlags = _featureFlags;
-        }
-        static INITIAL_BLOCK_FEATURE_FLAGS = {
-            supportsLazyState: true,
-            requiresUIAPIVersion: 1,
-            requiresModelAPIVersion: 1,
-        };
+        config;
+        constructor(config) {
+            this.config = config;
+        }
+        static get INITIAL_BLOCK_FEATURE_FLAGS() {
+            return {
+                supportsLazyState: true,
+                requiresUIAPIVersion: 1,
+                requiresModelAPIVersion: 1,
+            };
+        }
         static create(renderingMode = 'Heavy') {
-            return new BlockModel(renderingMode, undefined, {}, {}, getImmediate(true), getImmediate([]), undefined, undefined, { ...BlockModel.INITIAL_BLOCK_FEATURE_FLAGS });
+            return new BlockModel({
+                renderingMode,
+                initialUiState: {},
+                outputs: {},
+                inputsValid: getImmediate(true),
+                sections: getImmediate([]),
+                featureFlags: BlockModel.INITIAL_BLOCK_FEATURE_FLAGS,
+            });
         }
         output(key, cfgOrRf, flags = {}) {
             if (typeof cfgOrRf === 'function') {
                 const handle = `output#${key}`;
                 tryRegisterCallback(handle, () => cfgOrRf(new RenderCtx()));
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, {
-                    ...this._outputs,
-                    [key]: {
-                        __renderLambda: true,
-                        handle,
-                        ...flags,
+                return new BlockModel({
+                    ...this.config,
+                    outputs: {
+                        ...this.config.outputs,
+                        [key]: {
+                            __renderLambda: true,
+                            handle,
+                            ...flags,
+                        },
                     },
-                }, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+                });
+            }
+            else {
+                return new BlockModel({
+                    ...this.config,
+                    outputs: {
+                        ...this.config.outputs,
+                        [key]: cfgOrRf,
+                    },
+                });
             }
-            else
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, {
-                    ...this._outputs,
-                    [key]: cfgOrRf,
-                }, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
         }
         /** Shortcut for {@link output} with retentive flag set to true. */
         retentiveOutput(key, rf) {
@@ -7447,13 +7447,20 @@
         argsValid(cfgOrRf) {
             if (typeof cfgOrRf === 'function') {
                 tryRegisterCallback('inputsValid', () => cfgOrRf(new RenderCtx()));
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, {
-                    __renderLambda: true,
-                    handle: 'inputsValid',
-                }, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+                return new BlockModel({
+                    ...this.config,
+                    inputsValid: {
+                        __renderLambda: true,
+                        handle: 'inputsValid',
+                    },
+                });
+            }
+            else {
+                return new BlockModel({
+                    ...this.config,
+                    inputsValid: cfgOrRf,
+                });
             }
-            else
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, cfgOrRf, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
         }
         sections(arrOrCfgOrRf) {
             if (Array.isArray(arrOrCfgOrRf)) {
@@ -7461,34 +7468,82 @@
             }
             else if (typeof arrOrCfgOrRf === 'function') {
                 tryRegisterCallback('sections', () => arrOrCfgOrRf(new RenderCtx()));
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, { __renderLambda: true, handle: 'sections' }, this._title, this._enrichmentTargets, this._featureFlags);
+                return new BlockModel({
+                    ...this.config,
+                    sections: {
+                        __renderLambda: true,
+                        handle: 'sections',
+                    },
+                });
+            }
+            else {
+                return new BlockModel({
+                    ...this.config,
+                    sections: arrOrCfgOrRf,
+                });
             }
-            else
-                return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, arrOrCfgOrRf, this._title, this._enrichmentTargets, this._featureFlags);
         }
         /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
         title(rf) {
             tryRegisterCallback('title', () => rf(new RenderCtx()));
-            return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, { __renderLambda: true, handle: 'title' }, this._enrichmentTargets, this._featureFlags);
+            return new BlockModel({
+                ...this.config,
+                title: {
+                    __renderLambda: true,
+                    handle: 'title',
+                },
+            });
+        }
+        subtitle(rf) {
+            tryRegisterCallback('subtitle', () => rf(new RenderCtx()));
+            return new BlockModel({
+                ...this.config,
+                subtitle: {
+                    __renderLambda: true,
+                    handle: 'subtitle',
+                },
+            });
+        }
+        tags(rf) {
+            tryRegisterCallback('tags', () => rf(new RenderCtx()));
+            return new BlockModel({
+                ...this.config,
+                tags: {
+                    __renderLambda: true,
+                    handle: 'tags',
+                },
+            });
         }
         /**
          * Sets initial args for the block, this value must be specified.
          * @deprecated use {@link withArgs}
          * */
         initialArgs(value) {
-            return new BlockModel(this._renderingMode, value, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+            return this.withArgs(value);
         }
         /** Sets initial args for the block, this value must be specified. */
-        withArgs(initialValue) {
-            return new BlockModel(this._renderingMode, initialValue, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+        withArgs(initialArgs) {
+            return new BlockModel({
+                ...this.config,
+                initialArgs,
+            });
         }
         /** Defines type and sets initial value for block UiState. */
-        withUiState(initialValue) {
-            return new BlockModel(this._renderingMode, this._initialArgs, initialValue, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+        withUiState(initialUiState) {
+            return new BlockModel({
+                ...this.config,
+                initialUiState,
+            });
         }
         /** Sets or overrides feature flags for the block. */
         withFeatureFlags(flags) {
-            return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, { ...this._featureFlags, ...flags });
+            return new BlockModel({
+                ...this.config,
+                featureFlags: {
+                    ...this.config.featureFlags,
+                    ...flags,
+                },
+            });
         }
         /**
          * Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.
@@ -7496,43 +7551,50 @@
          */
         enriches(lambda) {
             tryRegisterCallback('enrichmentTargets', lambda);
-            return new BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, { __renderLambda: true, handle: 'enrichmentTargets' }, this._featureFlags);
+            return new BlockModel({
+                ...this.config,
+                enrichmentTargets: {
+                    __renderLambda: true,
+                    handle: 'enrichmentTargets',
+                },
+            });
         }
         /** Renders all provided block settings into a pre-configured platforma API
          * instance, that can be used in frontend to interact with block state, and
          * other features provided by the platforma to the block. */
-        done(apiVersion) {
-            const requiresUIAPIVersion = apiVersion ?? 1;
+        done(apiVersion = 1) {
             return this.withFeatureFlags({
-                ...this._featureFlags,
-                requiresUIAPIVersion,
-            })._done(requiresUIAPIVersion);
+                ...this.config.featureFlags,
+                requiresUIAPIVersion: apiVersion,
+            }).#done();
         }
-        _done(apiVersion) {
-            if (this._initialArgs === undefined)
+        #done() {
+            if (this.config.initialArgs === undefined)
                 throw new Error('Initial arguments not set.');
             const config = {
                 v3: {
                     sdkVersion: PlatformaSDKVersion,
-                    renderingMode: this._renderingMode,
-                    initialArgs: this._initialArgs,
-                    initialUiState: this._initialUiState,
-                    inputsValid: this._inputsValid,
-                    sections: this._sections,
-                    title: this._title,
-                    outputs: this._outputs,
-                    enrichmentTargets: this._enrichmentTargets,
-                    featureFlags: this._featureFlags,
+                    renderingMode: this.config.renderingMode,
+                    initialArgs: this.config.initialArgs,
+                    initialUiState: this.config.initialUiState,
+                    inputsValid: this.config.inputsValid,
+                    sections: this.config.sections,
+                    title: this.config.title,
+                    subtitle: this.config.subtitle,
+                    tags: this.config.tags,
+                    outputs: this.config.outputs,
+                    enrichmentTargets: this.config.enrichmentTargets,
+                    featureFlags: this.config.featureFlags,
                 },
                 // fields below are added to allow previous desktop versions read generated configs
                 sdkVersion: PlatformaSDKVersion,
-                renderingMode: this._renderingMode,
-                initialArgs: this._initialArgs,
-                inputsValid: downgradeCfgOrLambda(this._inputsValid),
-                sections: downgradeCfgOrLambda(this._sections),
-                outputs: Object.fromEntries(Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)])),
+                renderingMode: this.config.renderingMode,
+                initialArgs: this.config.initialArgs,
+                inputsValid: downgradeCfgOrLambda(this.config.inputsValid),
+                sections: downgradeCfgOrLambda(this.config.sections),
+                outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)])),
             };
-            globalThis.platformaApiVersion = apiVersion;
+            globalThis.platformaApiVersion = this.config.featureFlags.requiresUIAPIVersion;
             if (!isInUI())
                 // we are in the configuration rendering routine, not in actual UI
                 return { config };
@@ -7542,6 +7604,75 @@
         }
     }
 
+    function getAllRelatedColumns(ctx, predicate) {
+        // if current block doesn't produce own columns then use all columns from result pool
+        const columns = new PColumnCollection();
+        columns.addColumnProvider(ctx.resultPool);
+        const allColumns = columns.getUniversalEntries(predicate, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
+        const allAxes = new Map(allColumns
+            .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
+            .map((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return [canonicalizeJson(axisId), axisSpec];
+        }));
+        // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
+        const extendedColumns = enrichCompatible(allAxes, allColumns);
+        return extendedColumns;
+    }
+    function getRelatedColumns(ctx, { columns: rootColumns, predicate }) {
+        // if current block has its own columns then take from result pool only compatible with them
+        const columns = new PColumnCollection();
+        columns.addColumnProvider(ctx.resultPool);
+        columns.addColumns(rootColumns);
+        // all possible axes from block columns
+        const blockAxes = new Map();
+        // axes from block columns and compatible result pool columns
+        const allAxes = new Map();
+        for (const c of rootColumns) {
+            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+                const aid = getAxisId(spec);
+                blockAxes.set(canonicalizeJson(aid), spec);
+                allAxes.set(canonicalizeJson(aid), spec);
+            }
+        }
+        // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
+        const linkerColumns = columns.getUniversalEntries((spec) => predicate(spec) && isLinkerColumn(spec)) ?? [];
+        const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
+        // all possible axes from connected linkers
+        for (const item of availableWithLinkersAxes) {
+            blockAxes.set(...item);
+            allAxes.set(...item);
+        }
+        const blockAxesArr = Array.from(blockAxes.values());
+        // all compatible with block columns but without label columns
+        let compatibleWithoutLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+        // extend axes set for label columns request
+        for (const c of compatibleWithoutLabels) {
+            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+                const aid = getAxisId(spec);
+                allAxes.set(canonicalizeJson(aid), spec);
+            }
+        }
+        const allAxesArr = Array.from(allAxes.values());
+        // extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
+        compatibleWithoutLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.every((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+        // label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
+        const compatibleLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
+        const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
+        // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
+        const extendedColumns = enrichCompatible(blockAxes, compatible);
+        return extendedColumns;
+    }
+
     /** Create id for column copy with added keys in axes domains */
     const colId = (id, domains) => {
         let wid = id.toString();
@@ -7678,70 +7809,9 @@
         const suitableSpec = (spec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
         // if current block doesn't produce own columns then use all columns from result pool
         if (!blockColumns) {
-            const columns = new PColumnCollection();
-            columns.addColumnProvider(ctx.resultPool);
-            const allColumns = columns.getUniversalEntries(suitableSpec, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
-            const allAxes = new Map(allColumns
-                .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
-                .map((axisSpec) => {
-                const axisId = getAxisId(axisSpec);
-                return [canonicalizeJson(axisId), axisSpec];
-            }));
-            // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
-            const extendedColumns = enrichCompatible(allAxes, allColumns);
-            return ctx.createPFrame(extendedColumns);
-        }
-        // if current block has its own columns then take from result pool only compatible with them
-        const columns = new PColumnCollection();
-        columns.addColumnProvider(ctx.resultPool);
-        columns.addColumns(blockColumns);
-        // all possible axes from block columns
-        const blockAxes = new Map();
-        // axes from block columns and compatible result pool columns
-        const allAxes = new Map();
-        for (const c of blockColumns) {
-            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
-                const aid = getAxisId(spec);
-                blockAxes.set(canonicalizeJson(aid), spec);
-                allAxes.set(canonicalizeJson(aid), spec);
-            }
-        }
-        // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
-        const linkerColumns = columns.getUniversalEntries((spec) => suitableSpec(spec) && isLinkerColumn(spec)) ?? [];
-        const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
-        // all possible axes from connected linkers
-        for (const item of availableWithLinkersAxes) {
-            blockAxes.set(...item);
-            allAxes.set(...item);
-        }
-        const blockAxesArr = Array.from(blockAxes.values());
-        // all compatible with block columns but without label columns
-        let compatibleWithoutLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.some((axisSpec) => {
-            const axisId = getAxisId(axisSpec);
-            return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
-        // extend axes set for label columns request
-        for (const c of compatibleWithoutLabels) {
-            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
-                const aid = getAxisId(spec);
-                allAxes.set(canonicalizeJson(aid), spec);
-            }
+            return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));
         }
-        const allAxesArr = Array.from(allAxes.values());
-        // extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
-        compatibleWithoutLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.every((axisSpec) => {
-            const axisId = getAxisId(axisSpec);
-            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
-        // label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
-        const compatibleLabels = (columns.getUniversalEntries((spec) => suitableSpec(spec) && spec.axesSpec.some((axisSpec) => {
-            const axisId = getAxisId(axisSpec);
-            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
-        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
-        const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
-        // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
-        const extendedColumns = enrichCompatible(blockAxes, compatible);
-        return ctx.createPFrame(extendedColumns);
+        return ctx.createPFrame(getRelatedColumns(ctx, { columns: blockColumns, predicate: suitableSpec }));
     }
 
     function makeDefaultPTableParams() {
@@ -8083,7 +8153,7 @@
         identity: 0.8,
         sequenceType: 'aminoacid',
         sequencesRef: [],
-        similarityType: 'sequence-identity',
+        similarityType: 'alignment-score',
         coverageThreshold: 0.8, // default value matching MMseqs2 default
         coverageMode: 0, // default to coverage of query and target
         trimStart: 0, // default to no trimming from start