@cratis/scene.engine 4.22.1 → 4.24.0

package/dist/cjs/structure/ApplicationStructureIndex.js

@@ -0,0 +1,139 @@
+'use strict';
+
+var StructureDiagnosticCode = require('./StructureDiagnosticCode.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Answers the questions navigation, toolbar and template applicability ask of an {@link ApplicationStructure}:
+ * does this module, feature or slice exist, which feature comes first in a module, and what kind of slice is it.
+ * Pure and read-only; when ids are duplicated the first declaration wins and {@link diagnostics} reports the rest.
+ *
+ * The C# engine (`ApplicationStructureIndex`) answers the same questions the same way; both are asserted
+ * against `application-structure-fixtures.json`.
+ */ class ApplicationStructureIndex {
+    structure;
+    modules = new Map();
+    features = new Map();
+    slices = new Map();
+    featuresByName = new Map();
+    /** The problems found while indexing, in declaration order. */ diagnostics = [];
+    /**
+     * Initializes a new instance of the {@link ApplicationStructureIndex} class.
+     * @param structure The application structure to index.
+     */ constructor(structure){
+        this.structure = structure;
+        const seen = new Map();
+        const names = new Map();
+        for (const module of structure.modules){
+            const qualified = module.id;
+            if (!this.claim(seen, qualified, 'module')) continue;
+            this.modules.set(qualified, module);
+            this.reportAmbiguousName(names, 'module', module.name, qualified);
+            this.indexContainer(qualified, module.features, module.slices ?? []);
+        }
+    }
+    /**
+     * Finds a module by its id.
+     * @param moduleId The module id, for example `sales`.
+     * @returns The module, or undefined when there is none.
+     */ findModule(moduleId) {
+        return this.modules.get(moduleId);
+    }
+    /**
+     * Finds a feature by its qualified id.
+     * @param qualifiedId The dotted id from the module down, for example `sales.orders` or `sales.orders.returns`.
+     * @returns The feature, or undefined when there is none.
+     */ findFeature(qualifiedId) {
+        return this.features.get(qualifiedId);
+    }
+    /**
+     * Gets the first feature of a module - the one a navigation target that names only the module goes to.
+     * @param moduleId The module id.
+     * @returns The module's first top-level feature, or undefined when the module is unknown or has no features.
+     */ firstFeature(moduleId) {
+        return this.findModule(moduleId)?.features[0];
+    }
+    /**
+     * Gets the qualified id of the first feature of a module.
+     * @param moduleId The module id.
+     * @returns The qualified id, or undefined when the module is unknown or has no features.
+     */ firstFeatureId(moduleId) {
+        const feature = this.firstFeature(moduleId);
+        return feature ? `${moduleId}.${feature.id}` : undefined;
+    }
+    /**
+     * Finds a slice by its qualified id.
+     * @param qualifiedId The dotted id from the module down, for example `sales.orders.PlaceOrder`.
+     * @returns The slice, or undefined when there is none.
+     */ findSlice(qualifiedId) {
+        return this.slices.get(qualifiedId);
+    }
+    /**
+     * Gets what kind a slice is.
+     * @param sliceId The slice's qualified id.
+     * @returns The kind, or undefined when there is no such slice.
+     */ kindOf(sliceId) {
+        return this.findSlice(sliceId)?.kind;
+    }
+    /**
+     * Finds every feature that has a given display name, in every module, so a caller can tell when a bare name is ambiguous.
+     * @param name The display name, compared without regard to case.
+     * @returns The qualified ids of the features with that name, in declaration order.
+     */ findFeaturesByName(name) {
+        return [
+            ...this.featuresByName.get(name.toLowerCase()) ?? []
+        ];
+    }
+    indexContainer(path, features, slices) {
+        const seen = new Map();
+        const featureNames = new Map();
+        const sliceNames = new Map();
+        for (const feature of features){
+            const qualified = `${path}.${feature.id}`;
+            if (!this.claim(seen, qualified, 'feature')) continue;
+            this.features.set(qualified, feature);
+            const key = feature.name.toLowerCase();
+            const byName = this.featuresByName.get(key) ?? [];
+            byName.push(qualified);
+            this.featuresByName.set(key, byName);
+            this.reportAmbiguousName(featureNames, 'feature', feature.name, qualified);
+            this.indexContainer(qualified, feature.features, feature.slices);
+        }
+        for (const slice of slices){
+            const qualified = `${path}.${slice.id}`;
+            if (!this.claim(seen, qualified, 'slice')) continue;
+            this.slices.set(qualified, slice);
+            this.reportAmbiguousName(sliceNames, 'slice', slice.name, qualified);
+        }
+    }
+    claim(seen, qualified, kind) {
+        const first = seen.get(qualified);
+        if (first === undefined) {
+            seen.set(qualified, kind);
+            return true;
+        }
+        this.diagnostics.push({
+            code: StructureDiagnosticCode.StructureDiagnosticCode.StructureDuplicateId,
+            message: `Id '${qualified}' is declared more than once; the first ${first} wins.`,
+            id: qualified
+        });
+        return false;
+    }
+    reportAmbiguousName(names, kind, name, qualified) {
+        const key = name.toLowerCase();
+        const first = names.get(key);
+        if (first !== undefined) {
+            this.diagnostics.push({
+                code: StructureDiagnosticCode.StructureDiagnosticCode.StructureAmbiguousName,
+                message: `The ${kind} name '${name}' is used by both '${first}' and '${qualified}'.`,
+                id: qualified
+            });
+            return;
+        }
+        names.set(key, qualified);
+    }
+}
+
+exports.ApplicationStructureIndex = ApplicationStructureIndex;
+//# sourceMappingURL=ApplicationStructureIndex.js.map

package/dist/cjs/structure/ApplicationStructureIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationStructureIndex.js","sources":["../../../structure/ApplicationStructureIndex.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ApplicationStructure, FeatureNode, ModuleNode, SliceKind, SliceNode } from '@cratis/scene.model';\nimport { StructureDiagnostic } from './StructureDiagnostic';\nimport { StructureDiagnosticCode } from './StructureDiagnosticCode';\n\n/**\n * Answers the questions navigation, toolbar and template applicability ask of an {@link ApplicationStructure}:\n * does this module, feature or slice exist, which feature comes first in a module, and what kind of slice is it.\n * Pure and read-only; when ids are duplicated the first declaration wins and {@link diagnostics} reports the rest.\n *\n * The C# engine (`ApplicationStructureIndex`) answers the same questions the same way; both are asserted\n * against `application-structure-fixtures.json`.\n */\nexport class ApplicationStructureIndex {\n    private readonly modules = new Map<string, ModuleNode>();\n    private readonly features = new Map<string, FeatureNode>();\n    private readonly slices = new Map<string, SliceNode>();\n    private readonly featuresByName = new Map<string, string[]>();\n\n    /** The problems found while indexing, in declaration order. */\n    readonly diagnostics: StructureDiagnostic[] = [];\n\n    /**\n     * Initializes a new instance of the {@link ApplicationStructureIndex} class.\n     * @param structure The application structure to index.\n     */\n    constructor(readonly structure: ApplicationStructure) {\n        const seen = new Map<string, string>();\n        const names = new Map<string, string>();\n\n        for (const module of structure.modules) {\n            const qualified = module.id;\n            if (!this.claim(seen, qualified, 'module')) continue;\n\n            this.modules.set(qualified, module);\n            this.reportAmbiguousName(names, 'module', module.name, qualified);\n            this.indexContainer(qualified, module.features, module.slices ?? []);\n        }\n    }\n\n    /**\n     * Finds a module by its id.\n     * @param moduleId The module id, for example `sales`.\n     * @returns The module, or undefined when there is none.\n     */\n    findModule(moduleId: string): ModuleNode | undefined {\n        return this.modules.get(moduleId);\n    }\n\n    /**\n     * Finds a feature by its qualified id.\n     * @param qualifiedId The dotted id from the module down, for example `sales.orders` or `sales.orders.returns`.\n     * @returns The feature, or undefined when there is none.\n     */\n    findFeature(qualifiedId: string): FeatureNode | undefined {\n        return this.features.get(qualifiedId);\n    }\n\n    /**\n     * Gets the first feature of a module - the one a navigation target that names only the module goes to.\n     * @param moduleId The module id.\n     * @returns The module's first top-level feature, or undefined when the module is unknown or has no features.\n     */\n    firstFeature(moduleId: string): FeatureNode | undefined {\n        return this.findModule(moduleId)?.features[0];\n    }\n\n    /**\n     * Gets the qualified id of the first feature of a module.\n     * @param moduleId The module id.\n     * @returns The qualified id, or undefined when the module is unknown or has no features.\n     */\n    firstFeatureId(moduleId: string): string | undefined {\n        const feature = this.firstFeature(moduleId);\n        return feature ? `${moduleId}.${feature.id}` : undefined;\n    }\n\n    /**\n     * Finds a slice by its qualified id.\n     * @param qualifiedId The dotted id from the module down, for example `sales.orders.PlaceOrder`.\n     * @returns The slice, or undefined when there is none.\n     */\n    findSlice(qualifiedId: string): SliceNode | undefined {\n        return this.slices.get(qualifiedId);\n    }\n\n    /**\n     * Gets what kind a slice is.\n     * @param sliceId The slice's qualified id.\n     * @returns The kind, or undefined when there is no such slice.\n     */\n    kindOf(sliceId: string): SliceKind | undefined {\n        return this.findSlice(sliceId)?.kind;\n    }\n\n    /**\n     * Finds every feature that has a given display name, in every module, so a caller can tell when a bare name is ambiguous.\n     * @param name The display name, compared without regard to case.\n     * @returns The qualified ids of the features with that name, in declaration order.\n     */\n    findFeaturesByName(name: string): string[] {\n        return [...(this.featuresByName.get(name.toLowerCase()) ?? [])];\n    }\n\n    private indexContainer(path: string, features: FeatureNode[], slices: SliceNode[]): void {\n        const seen = new Map<string, string>();\n        const featureNames = new Map<string, string>();\n        const sliceNames = new Map<string, string>();\n\n        for (const feature of features) {\n            const qualified = `${path}.${feature.id}`;\n            if (!this.claim(seen, qualified, 'feature')) continue;\n\n            this.features.set(qualified, feature);\n            const key = feature.name.toLowerCase();\n            const byName = this.featuresByName.get(key) ?? [];\n            byName.push(qualified);\n            this.featuresByName.set(key, byName);\n            this.reportAmbiguousName(featureNames, 'feature', feature.name, qualified);\n            this.indexContainer(qualified, feature.features, feature.slices);\n        }\n\n        for (const slice of slices) {\n            const qualified = `${path}.${slice.id}`;\n            if (!this.claim(seen, qualified, 'slice')) continue;\n\n            this.slices.set(qualified, slice);\n            this.reportAmbiguousName(sliceNames, 'slice', slice.name, qualified);\n        }\n    }\n\n    private claim(seen: Map<string, string>, qualified: string, kind: string): boolean {\n        const first = seen.get(qualified);\n        if (first === undefined) {\n            seen.set(qualified, kind);\n            return true;\n        }\n\n        this.diagnostics.push({\n            code: StructureDiagnosticCode.StructureDuplicateId,\n            message: `Id '${qualified}' is declared more than once; the first ${first} wins.`,\n            id: qualified,\n        });\n        return false;\n    }\n\n    private reportAmbiguousName(names: Map<string, string>, kind: string, name: string, qualified: string): void {\n        const key = name.toLowerCase();\n        const first = names.get(key);\n        if (first !== undefined) {\n            this.diagnostics.push({\n                code: StructureDiagnosticCode.StructureAmbiguousName,\n                message: `The ${kind} name '${name}' is used by both '${first}' and '${qualified}'.`,\n                id: qualified,\n            });\n            return;\n        }\n\n        names.set(key, qualified);\n    }\n}\n"],"names":["ApplicationStructureIndex","modules","Map","features","slices","featuresByName","diagnostics","structure","seen","names","module","qualified","id","claim","set","reportAmbiguousName","name","indexContainer","findModule","moduleId","get","findFeature","qualifiedId","firstFeature","firstFeatureId","feature","undefined","findSlice","kindOf","sliceId","kind","findFeaturesByName","toLowerCase","path","featureNames","sliceNames","key","byName","push","slice","first","code","StructureDiagnosticCode","StructureDuplicateId","message","StructureAmbiguousName"],"mappings":"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"}

package/dist/cjs/structure/StructureDiagnosticCode.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * What is wrong with an application structure. The values are shared with the C# engine so both report
+ * the same code for the same structure.
+ */ var StructureDiagnosticCode = /*#__PURE__*/ function(StructureDiagnosticCode) {
+    /** Two siblings share one id, so their qualified id does not identify a single node. */ StructureDiagnosticCode["StructureDuplicateId"] = "structureDuplicateId";
+    /** Two siblings with different ids share one display name, so a picker or a name lookup cannot tell them apart. */ StructureDiagnosticCode["StructureAmbiguousName"] = "structureAmbiguousName";
+    return StructureDiagnosticCode;
+}({});
+
+exports.StructureDiagnosticCode = StructureDiagnosticCode;
+//# sourceMappingURL=StructureDiagnosticCode.js.map

package/dist/cjs/structure/StructureDiagnosticCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructureDiagnosticCode.js","sources":["../../../structure/StructureDiagnosticCode.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * What is wrong with an application structure. The values are shared with the C# engine so both report\n * the same code for the same structure.\n */\nexport enum StructureDiagnosticCode {\n    /** Two siblings share one id, so their qualified id does not identify a single node. */\n    StructureDuplicateId = 'structureDuplicateId',\n\n    /** Two siblings with different ids share one display name, so a picker or a name lookup cannot tell them apart. */\n    StructureAmbiguousName = 'structureAmbiguousName',\n}\n"],"names":["StructureDiagnosticCode"],"mappings":";;AAAA;AACA;AAEA;;;IAIO,IAAKA,uBAAAA,iBAAAA,SAAAA,uBAAAA,EAAAA;6FAC8E,uBAAA,CAAA,sBAAA,CAAA,GAAA,sBAAA;wHAG2B,uBAAA,CAAA,wBAAA,CAAA,GAAA,wBAAA;AAJzGA,IAAAA,OAAAA,uBAAAA;AAMX,CAAA,CAAA,EAAA;;"}

package/dist/esm/descriptors/componentBadge.d.ts

@@ -0,0 +1,3 @@
+import { ComponentDescriptor } from '@cratis/scene.model';
+export declare function componentBadge(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'badge'>): string;
+//# sourceMappingURL=componentBadge.d.ts.map

package/dist/esm/descriptors/componentBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentBadge.d.ts","sourceRoot":"","sources":["../../../descriptors/componentBadge.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAY1D,wBAAgB,cAAc,CAAC,UAAU,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,aAAa,GAAG,OAAO,CAAC,GAAG,MAAM,CAiBnH"}

package/dist/esm/descriptors/componentBadge.js

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+const vowels = 'aeiou';
+/**
+ * The two-letter badge a component picker draws for a component that has no icon to show.
+ *
+ * An explicit `badge` wins (trimmed to two letters). Otherwise a name of several words (`Card grid`, `Stat card`) takes the
+ * initials of its first two words (`Cg`, `Sc`); a single word takes its first letter and the first consonant after it
+ * (`Button` -> `Bt`, `List` -> `Ls`), or its second letter when it has none. A camel-cased name is read as words
+ * (`dataTable` -> `Data table`). The first letter is upper case, the second lower case.
+ */ function componentBadge(descriptor) {
+    const explicit = descriptor.badge?.trim();
+    if (explicit) return capitalize(explicit.slice(0, 2));
+    const name = descriptor.displayName?.trim() || bareName(descriptor.component);
+    const words = name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[^A-Za-z0-9]+/).filter((word)=>word.length > 0);
+    if (words.length === 0) return '??';
+    if (words.length > 1) return capitalize(words[0][0] + words[1][0]);
+    const word = words[0];
+    if (word.length === 1) return word.toUpperCase();
+    const consonant = [
+        ...word.slice(1)
+    ].find((letter)=>/[a-z]/i.test(letter) && !vowels.includes(letter.toLowerCase()));
+    return capitalize(word[0] + (consonant ?? word[1]));
+}
+function bareName(component) {
+    return component.slice(component.lastIndexOf(':') + 1);
+}
+function capitalize(letters) {
+    return letters.charAt(0).toUpperCase() + letters.slice(1).toLowerCase();
+}
+
+export { componentBadge };
+//# sourceMappingURL=componentBadge.js.map

package/dist/esm/descriptors/componentBadge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentBadge.js","sources":["../../../descriptors/componentBadge.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ComponentDescriptor } from '@cratis/scene.model';\n\nconst vowels = 'aeiou';\n\n/**\n * The two-letter badge a component picker draws for a component that has no icon to show.\n *\n * An explicit `badge` wins (trimmed to two letters). Otherwise a name of several words (`Card grid`, `Stat card`) takes the\n * initials of its first two words (`Cg`, `Sc`); a single word takes its first letter and the first consonant after it\n * (`Button` -> `Bt`, `List` -> `Ls`), or its second letter when it has none. A camel-cased name is read as words\n * (`dataTable` -> `Data table`). The first letter is upper case, the second lower case.\n */\nexport function componentBadge(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'badge'>): string {\n    const explicit = descriptor.badge?.trim();\n    if (explicit) return capitalize(explicit.slice(0, 2));\n\n    const name = descriptor.displayName?.trim() || bareName(descriptor.component);\n    const words = name\n        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')\n        .split(/[^A-Za-z0-9]+/)\n        .filter(word => word.length > 0);\n\n    if (words.length === 0) return '??';\n    if (words.length > 1) return capitalize(words[0][0] + words[1][0]);\n\n    const word = words[0];\n    if (word.length === 1) return word.toUpperCase();\n    const consonant = [...word.slice(1)].find(letter => /[a-z]/i.test(letter) && !vowels.includes(letter.toLowerCase()));\n    return capitalize(word[0] + (consonant ?? word[1]));\n}\n\nfunction bareName(component: string): string {\n    return component.slice(component.lastIndexOf(':') + 1);\n}\n\nfunction capitalize(letters: string): string {\n    return letters.charAt(0).toUpperCase() + letters.slice(1).toLowerCase();\n}\n"],"names":["vowels","componentBadge","descriptor","explicit","badge","trim","capitalize","slice","name","displayName","bareName","component","words","replace","split","filter","word","length","toUpperCase","consonant","find","letter","test","includes","toLowerCase","lastIndexOf","letters","charAt"],"mappings":"AAAA;AACA;AAIA,MAAMA,MAAAA,GAAS,OAAA;AAEf;;;;;;;IAQO,SAASC,cAAAA,CAAeC,UAA4E,EAAA;IACvG,MAAMC,QAAAA,GAAWD,UAAAA,CAAWE,KAAK,EAAEC,IAAAA,EAAAA;AACnC,IAAA,IAAIF,UAAU,OAAOG,UAAAA,CAAWH,QAAAA,CAASI,KAAK,CAAC,CAAA,EAAG,CAAA,CAAA,CAAA;AAElD,IAAA,MAAMC,OAAON,UAAAA,CAAWO,WAAW,EAAEJ,IAAAA,EAAAA,IAAUK,QAAAA,CAASR,WAAWS,SAAS,CAAA;AAC5E,IAAA,MAAMC,KAAAA,GAAQJ,IAAAA,CACTK,OAAO,CAAC,sBAAsB,OAAA,CAAA,CAC9BC,KAAK,CAAC,eAAA,CAAA,CACNC,MAAM,CAACC,CAAAA,IAAAA,GAAQA,IAAAA,CAAKC,MAAM,GAAG,CAAA,CAAA;AAElC,IAAA,IAAIL,KAAAA,CAAMK,MAAM,KAAK,CAAA,EAAG,OAAO,IAAA;AAC/B,IAAA,IAAIL,MAAMK,MAAM,GAAG,CAAA,EAAG,OAAOX,WAAWM,KAAK,CAAC,CAAA,CAAE,CAAC,EAAE,GAAGA,KAAK,CAAC,CAAA,CAAE,CAAC,CAAA,CAAE,CAAA;IAEjE,MAAMI,IAAAA,GAAOJ,KAAK,CAAC,CAAA,CAAE;AACrB,IAAA,IAAII,KAAKC,MAAM,KAAK,CAAA,EAAG,OAAOD,KAAKE,WAAW,EAAA;AAC9C,IAAA,MAAMC,SAAAA,GAAY;AAAIH,QAAAA,GAAAA,IAAAA,CAAKT,KAAK,CAAC,CAAA;AAAG,KAAA,CAACa,IAAI,CAACC,CAAAA,MAAAA,GAAU,QAAA,CAASC,IAAI,CAACD,MAAAA,CAAAA,IAAW,CAACrB,MAAAA,CAAOuB,QAAQ,CAACF,OAAOG,WAAW,EAAA,CAAA,CAAA;IAChH,OAAOlB,UAAAA,CAAWU,IAAI,CAAC,CAAA,CAAE,IAAIG,SAAAA,IAAaH,IAAI,CAAC,CAAA,CAAE,CAAD,CAAA;AACpD;AAEA,SAASN,SAASC,SAAiB,EAAA;AAC/B,IAAA,OAAOA,UAAUJ,KAAK,CAACI,SAAAA,CAAUc,WAAW,CAAC,GAAA,CAAA,GAAO,CAAA,CAAA;AACxD;AAEA,SAASnB,WAAWoB,OAAe,EAAA;IAC/B,OAAOA,OAAAA,CAAQC,MAAM,CAAC,CAAA,CAAA,CAAGT,WAAW,KAAKQ,OAAAA,CAAQnB,KAAK,CAAC,CAAA,CAAA,CAAGiB,WAAW,EAAA;AACzE;;"}

package/dist/esm/descriptors/index.d.ts

@@ -0,0 +1,5 @@
+export * from './validateComponentDescriptors';
+export * from './componentBadge';
+export * from './matchComponentQuery';
+export * from './rankFrequentlyUsedComponents';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/descriptors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../descriptors/index.ts"],"names":[],"mappings":"AAGA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}

package/dist/esm/descriptors/index.js

@@ -0,0 +1,5 @@
+export * from './validateComponentDescriptors';
+export * from './componentBadge';
+export * from './matchComponentQuery';
+export * from './rankFrequentlyUsedComponents';
+//# sourceMappingURL=index.js.map

package/dist/esm/descriptors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../descriptors/index.ts"],"names":[],"mappings":"AAGA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC"}

package/dist/esm/descriptors/matchComponentQuery.d.ts

@@ -0,0 +1,9 @@
+import { ComponentDescriptor } from '@cratis/scene.model';
+export interface ComponentQueryMatch {
+    matched: boolean;
+    via?: 'name' | 'category' | 'keyword';
+    ranges: [number, number][];
+    keyword?: string;
+}
+export declare function matchComponentQuery(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'category' | 'keywords'>, query: string): ComponentQueryMatch;
+//# sourceMappingURL=matchComponentQuery.d.ts.map

package/dist/esm/descriptors/matchComponentQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchComponentQuery.d.ts","sourceRoot":"","sources":["../../../descriptors/matchComponentQuery.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAK1D,MAAM,WAAW,mBAAmB;IAEhC,OAAO,EAAE,OAAO,CAAC;IAGjB,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IAGtC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAG3B,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAWD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,GAAG,aAAa,GAAG,UAAU,GAAG,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAcpK"}

package/dist/esm/descriptors/matchComponentQuery.js

@@ -0,0 +1,54 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Decides whether a component is shown for the text typed in a picker's filter, and why.
+ *
+ * Matching is case-insensitive. The display name (or, when the descriptor has none, the bare component name) and the keywords match by
+ * substring. The category matches by the start of one of its words - `nav` finds every Navigation component, while `ta` does not find
+ * everything under `Data display`, which a substring match on the category would. A component is shown when any of the three
+ * match; it reports the first of name, category, keyword that did, so the picker highlights the name and shows a hint only when a
+ * keyword alone brought the component in. An empty filter matches everything and highlights nothing.
+ */ function matchComponentQuery(descriptor, query) {
+    const needle = query.trim().toLowerCase();
+    if (needle.length === 0) return {
+        matched: true,
+        ranges: []
+    };
+    const name = descriptor.displayName ?? descriptor.component.slice(descriptor.component.lastIndexOf(':') + 1);
+    const ranges = occurrencesOf(name.toLowerCase(), needle);
+    if (ranges.length > 0) return {
+        matched: true,
+        via: 'name',
+        ranges
+    };
+    if (descriptor.category !== undefined && descriptor.category.toLowerCase().split(/\s+/).some((word)=>word.startsWith(needle))) {
+        return {
+            matched: true,
+            via: 'category',
+            ranges: []
+        };
+    }
+    const keyword = (descriptor.keywords ?? []).find((candidate)=>candidate.toLowerCase().includes(needle));
+    return keyword === undefined ? {
+        matched: false,
+        ranges: []
+    } : {
+        matched: true,
+        via: 'keyword',
+        ranges: [],
+        keyword
+    };
+}
+function occurrencesOf(text, needle) {
+    const found = [];
+    for(let at = text.indexOf(needle); at >= 0; at = text.indexOf(needle, at + needle.length)){
+        found.push([
+            at,
+            at + needle.length
+        ]);
+    }
+    return found;
+}
+
+export { matchComponentQuery };
+//# sourceMappingURL=matchComponentQuery.js.map

package/dist/esm/descriptors/matchComponentQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchComponentQuery.js","sources":["../../../descriptors/matchComponentQuery.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ComponentDescriptor } from '@cratis/scene.model';\n\n/**\n * How a component answers a picker's filter text (spec PICK2).\n */\nexport interface ComponentQueryMatch {\n    /** The component is shown for this filter. */\n    matched: boolean;\n\n    /** What matched, strongest first: the display name, the category, or one of the keywords. Absent when nothing matched. */\n    via?: 'name' | 'category' | 'keyword';\n\n    /** The `[start, end)` ranges of the display name to highlight. Empty unless the name matched. */\n    ranges: [number, number][];\n\n    /** The keyword the component matched through. Present only when `via` is `keyword`: the picker shows it as a hint. */\n    keyword?: string;\n}\n\n/**\n * Decides whether a component is shown for the text typed in a picker's filter, and why.\n *\n * Matching is case-insensitive. The display name (or, when the descriptor has none, the bare component name) and the keywords match by\n * substring. The category matches by the start of one of its words - `nav` finds every Navigation component, while `ta` does not find\n * everything under `Data display`, which a substring match on the category would. A component is shown when any of the three\n * match; it reports the first of name, category, keyword that did, so the picker highlights the name and shows a hint only when a\n * keyword alone brought the component in. An empty filter matches everything and highlights nothing.\n */\nexport function matchComponentQuery(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'category' | 'keywords'>, query: string): ComponentQueryMatch {\n    const needle = query.trim().toLowerCase();\n    if (needle.length === 0) return { matched: true, ranges: [] };\n\n    const name = descriptor.displayName ?? descriptor.component.slice(descriptor.component.lastIndexOf(':') + 1);\n    const ranges = occurrencesOf(name.toLowerCase(), needle);\n    if (ranges.length > 0) return { matched: true, via: 'name', ranges };\n\n    if (descriptor.category !== undefined && descriptor.category.toLowerCase().split(/\\s+/).some(word => word.startsWith(needle))) {\n        return { matched: true, via: 'category', ranges: [] };\n    }\n\n    const keyword = (descriptor.keywords ?? []).find(candidate => candidate.toLowerCase().includes(needle));\n    return keyword === undefined ? { matched: false, ranges: [] } : { matched: true, via: 'keyword', ranges: [], keyword };\n}\n\nfunction occurrencesOf(text: string, needle: string): [number, number][] {\n    const found: [number, number][] = [];\n    for (let at = text.indexOf(needle); at >= 0; at = text.indexOf(needle, at + needle.length)) {\n        found.push([at, at + needle.length]);\n    }\n\n    return found;\n}\n"],"names":["matchComponentQuery","descriptor","query","needle","trim","toLowerCase","length","matched","ranges","name","displayName","component","slice","lastIndexOf","occurrencesOf","via","category","undefined","split","some","word","startsWith","keyword","keywords","find","candidate","includes","text","found","at","indexOf","push"],"mappings":"AAAA;AACA;AAqBA;;;;;;;;AAQC,IACM,SAASA,mBAAAA,CAAoBC,UAA4F,EAAEC,KAAa,EAAA;AAC3I,IAAA,MAAMC,MAAAA,GAASD,KAAAA,CAAME,IAAI,EAAA,CAAGC,WAAW,EAAA;AACvC,IAAA,IAAIF,MAAAA,CAAOG,MAAM,KAAK,CAAA,EAAG,OAAO;QAAEC,OAAAA,EAAS,IAAA;AAAMC,QAAAA,MAAAA,EAAQ;AAAG,KAAA;AAE5D,IAAA,MAAMC,IAAAA,GAAOR,UAAAA,CAAWS,WAAW,IAAIT,WAAWU,SAAS,CAACC,KAAK,CAACX,UAAAA,CAAWU,SAAS,CAACE,WAAW,CAAC,GAAA,CAAA,GAAO,CAAA,CAAA;AAC1G,IAAA,MAAML,MAAAA,GAASM,aAAAA,CAAcL,IAAAA,CAAKJ,WAAW,EAAA,EAAIF,MAAAA,CAAAA;AACjD,IAAA,IAAIK,MAAAA,CAAOF,MAAM,GAAG,CAAA,EAAG,OAAO;QAAEC,OAAAA,EAAS,IAAA;QAAMQ,GAAAA,EAAK,MAAA;AAAQP,QAAAA;AAAO,KAAA;AAEnE,IAAA,IAAIP,WAAWe,QAAQ,KAAKC,aAAahB,UAAAA,CAAWe,QAAQ,CAACX,WAAW,EAAA,CAAGa,KAAK,CAAC,KAAA,CAAA,CAAOC,IAAI,CAACC,CAAAA,OAAQA,IAAAA,CAAKC,UAAU,CAAClB,MAAAA,CAAAA,CAAAA,EAAU;QAC3H,OAAO;YAAEI,OAAAA,EAAS,IAAA;YAAMQ,GAAAA,EAAK,UAAA;AAAYP,YAAAA,MAAAA,EAAQ;AAAG,SAAA;AACxD,IAAA;AAEA,IAAA,MAAMc,UAAU,CAACrB,UAAAA,CAAWsB,QAAQ,IAAI,EAAC,EAAGC,IAAI,CAACC,CAAAA,SAAAA,GAAaA,UAAUpB,WAAW,EAAA,CAAGqB,QAAQ,CAACvB,MAAAA,CAAAA,CAAAA;AAC/F,IAAA,OAAOmB,YAAYL,SAAAA,GAAY;QAAEV,OAAAA,EAAS,KAAA;AAAOC,QAAAA,MAAAA,EAAQ;KAAG,GAAI;QAAED,OAAAA,EAAS,IAAA;QAAMQ,GAAAA,EAAK,SAAA;AAAWP,QAAAA,MAAAA,EAAQ,EAAE;AAAEc,QAAAA;AAAQ,KAAA;AACzH;AAEA,SAASR,aAAAA,CAAca,IAAY,EAAExB,MAAc,EAAA;AAC/C,IAAA,MAAMyB,QAA4B,EAAE;AACpC,IAAA,IAAK,IAAIC,EAAAA,GAAKF,IAAAA,CAAKG,OAAO,CAAC3B,SAAS0B,EAAAA,IAAM,CAAA,EAAGA,EAAAA,GAAKF,IAAAA,CAAKG,OAAO,CAAC3B,MAAAA,EAAQ0B,EAAAA,GAAK1B,MAAAA,CAAOG,MAAM,CAAA,CAAG;AACxFsB,QAAAA,KAAAA,CAAMG,IAAI,CAAC;AAACF,YAAAA,EAAAA;AAAIA,YAAAA,EAAAA,GAAK1B,OAAOG;AAAO,SAAA,CAAA;AACvC,IAAA;IAEA,OAAOsB,KAAAA;AACX;;"}

package/dist/esm/descriptors/rankFrequentlyUsedComponents.d.ts

@@ -0,0 +1,7 @@
+export interface ComponentUsage {
+    count: number;
+    last: number;
+}
+export declare const frequentlyUsedLimit = 6;
+export declare function rankFrequentlyUsedComponents(usage: Readonly<Record<string, ComponentUsage>>, limit?: number): string[];
+//# sourceMappingURL=rankFrequentlyUsedComponents.d.ts.map

package/dist/esm/descriptors/rankFrequentlyUsedComponents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rankFrequentlyUsedComponents.d.ts","sourceRoot":"","sources":["../../../descriptors/rankFrequentlyUsedComponents.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,cAAc;IAE3B,KAAK,EAAE,MAAM,CAAC;IAGd,IAAI,EAAE,MAAM,CAAC;CAChB;AAGD,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAOrC,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,KAAK,GAAE,MAA4B,GAAG,MAAM,EAAE,CAM3I"}

package/dist/esm/descriptors/rankFrequentlyUsedComponents.js

@@ -0,0 +1,15 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * How often and how recently one component was added to a canvas.
+ */ /** The number of components the "Frequently used" group lists (spec PICK3). */ const frequentlyUsedLimit = 6;
+/**
+ * The components the "Frequently used" group lists: at most `limit` (6 by default), the most used first, ties broken by the most
+ * recent use, and any remaining tie by the component name so the order is stable. Components never used, or whose count is not a
+ * positive number, are not listed, so a picker hides the group when this is empty.
+ */ function rankFrequentlyUsedComponents(usage, limit = frequentlyUsedLimit) {
+    return Object.entries(usage).filter(([, entry])=>Number.isFinite(entry.count) && entry.count > 0).sort(([leftName, left], [rightName, right])=>right.count - left.count || right.last - left.last || leftName.localeCompare(rightName)).slice(0, Math.max(0, limit)).map(([name])=>name);
+}
+
+export { frequentlyUsedLimit, rankFrequentlyUsedComponents };
+//# sourceMappingURL=rankFrequentlyUsedComponents.js.map

package/dist/esm/descriptors/rankFrequentlyUsedComponents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rankFrequentlyUsedComponents.js","sources":["../../../descriptors/rankFrequentlyUsedComponents.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * How often and how recently one component was added to a canvas.\n */\nexport interface ComponentUsage {\n    /** How many times the component was added. */\n    count: number;\n\n    /** When it was last added, in milliseconds since the epoch. */\n    last: number;\n}\n\n/** The number of components the \"Frequently used\" group lists (spec PICK3). */\nexport const frequentlyUsedLimit = 6;\n\n/**\n * The components the \"Frequently used\" group lists: at most `limit` (6 by default), the most used first, ties broken by the most\n * recent use, and any remaining tie by the component name so the order is stable. Components never used, or whose count is not a\n * positive number, are not listed, so a picker hides the group when this is empty.\n */\nexport function rankFrequentlyUsedComponents(usage: Readonly<Record<string, ComponentUsage>>, limit: number = frequentlyUsedLimit): string[] {\n    return Object.entries(usage)\n        .filter(([, entry]) => Number.isFinite(entry.count) && entry.count > 0)\n        .sort(([leftName, left], [rightName, right]) => right.count - left.count || right.last - left.last || leftName.localeCompare(rightName))\n        .slice(0, Math.max(0, limit))\n        .map(([name]) => name);\n}\n"],"names":["frequentlyUsedLimit","rankFrequentlyUsedComponents","usage","limit","Object","entries","filter","entry","Number","isFinite","count","sort","leftName","left","rightName","right","last","localeCompare","slice","Math","max","map","name"],"mappings":"AAAA;AACA;AAEA;;AAEC,oFAUM,MAAMA,sBAAsB;AAEnC;;;;AAIC,IACM,SAASC,4BAAAA,CAA6BC,KAA+C,EAAEC,QAAgBH,mBAAmB,EAAA;AAC7H,IAAA,OAAOI,MAAAA,CAAOC,OAAO,CAACH,KAAAA,CAAAA,CACjBI,MAAM,CAAC,CAAC,GAAGC,KAAAA,CAAM,GAAKC,MAAAA,CAAOC,QAAQ,CAACF,KAAAA,CAAMG,KAAK,CAAA,IAAKH,KAAAA,CAAMG,KAAK,GAAG,CAAA,CAAA,CACpEC,IAAI,CAAC,CAAC,CAACC,QAAAA,EAAUC,IAAAA,CAAK,EAAE,CAACC,SAAAA,EAAWC,KAAAA,CAAM,GAAKA,KAAAA,CAAML,KAAK,GAAGG,IAAAA,CAAKH,KAAK,IAAIK,KAAAA,CAAMC,IAAI,GAAGH,IAAAA,CAAKG,IAAI,IAAIJ,QAAAA,CAASK,aAAa,CAACH,SAAAA,CAAAA,CAAAA,CAC5HI,KAAK,CAAC,CAAA,EAAGC,IAAAA,CAAKC,GAAG,CAAC,CAAA,EAAGjB,KAAAA,CAAAA,CAAAA,CACrBkB,GAAG,CAAC,CAAC,CAACC,IAAAA,CAAK,GAAKA,IAAAA,CAAAA;AACzB;;"}

package/dist/esm/descriptors/validateComponentDescriptors.d.ts

@@ -0,0 +1,3 @@
+import { ComponentDescriptor, SceneDiagnostic } from '@cratis/scene.model';
+export declare function validateComponentDescriptors(descriptors: readonly ComponentDescriptor[], registered?: readonly string[], knownCategories?: readonly string[]): SceneDiagnostic[];
+//# sourceMappingURL=validateComponentDescriptors.d.ts.map

package/dist/esm/descriptors/validateComponentDescriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateComponentDescriptors.d.ts","sourceRoot":"","sources":["../../../descriptors/validateComponentDescriptors.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,mBAAmB,EACnB,eAAe,EAClB,MAAM,qBAAqB,CAAC;AAgB7B,wBAAgB,4BAA4B,CACxC,WAAW,EAAE,SAAS,mBAAmB,EAAE,EAC3C,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,EAC9B,eAAe,GAAE,SAAS,MAAM,EAAwB,GACzD,eAAe,EAAE,CA8BnB"}

package/dist/esm/descriptors/validateComponentDescriptors.js

@@ -0,0 +1,114 @@
+import { componentCategories, DiagnosticSeverity, DiagnosticCode, PropertyValueType, PropertyEditorKind } from '@cratis/scene.model';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Checks the component metadata a package ships - what a picker and a designer read without loading a component.
+ *
+ * - **CMP1** `componentCategoryMissing` (error): a registered component has no descriptor, or its descriptor declares no category.
+ * - `componentCategoryUnknown` (warning): the category is not one of the model's; a package may add its own, so this is a
+ *   nudge towards the shared vocabulary, not a refusal.
+ * - `componentDesignModeInvalid` (error): the design-mode descriptor names an items or collection path that is not a `Collection`
+ *   property of the component, or repeats an action id.
+ * - `propertyEditorOptionsInvalid` (error): an editor's parameters cannot work - a `reference` editor that does not say what it
+ *   references, a step that is not positive, an empty list of slice kinds.
+ *
+ * `registered` is the bare or package-qualified names of the components the package registers; when given, each must be described.
+ * The result is in a stable order: registered components first (in the order given), then each descriptor's findings in its own order.
+ */ function validateComponentDescriptors(descriptors, registered, knownCategories = componentCategories) {
+    const diagnostics = [];
+    const described = new Map(descriptors.map((descriptor)=>[
+            descriptor.component,
+            descriptor
+        ]));
+    for (const component of registered ?? []){
+        if (!described.has(component)) {
+            diagnostics.push(missingCategory(component, `'${component}' is registered but has no descriptor, so it declares no category`));
+        }
+    }
+    for (const descriptor of descriptors){
+        const { component } = descriptor;
+        if (descriptor.category === undefined || descriptor.category.trim().length === 0) {
+            diagnostics.push(missingCategory(component, `'${component}' declares no category`));
+        } else if (!knownCategories.includes(descriptor.category)) {
+            diagnostics.push({
+                code: DiagnosticCode.ComponentCategoryUnknown,
+                severity: DiagnosticSeverity.Warning,
+                component,
+                message: `'${component}' declares the category '${descriptor.category}', which is not one of ${knownCategories.join(', ')}`
+            });
+        }
+        if (descriptor.designMode) {
+            diagnostics.push(...validateDesignMode(descriptor, descriptor.designMode));
+        }
+        diagnostics.push(...validateEditorOptions(component, descriptor.properties, ''));
+    }
+    return diagnostics;
+}
+function missingCategory(component, message) {
+    return {
+        code: DiagnosticCode.ComponentCategoryMissing,
+        severity: DiagnosticSeverity.Error,
+        component,
+        message
+    };
+}
+function invalidDesignMode(component, message) {
+    return {
+        code: DiagnosticCode.ComponentDesignModeInvalid,
+        severity: DiagnosticSeverity.Error,
+        component,
+        message
+    };
+}
+function validateDesignMode(descriptor, designMode) {
+    const { component } = descriptor;
+    const diagnostics = [];
+    const collections = new Set(descriptor.properties.filter((property)=>property.valueType === PropertyValueType.Collection).map((property)=>property.path));
+    if (designMode.itemsPath !== undefined && !collections.has(designMode.itemsPath)) {
+        diagnostics.push(invalidDesignMode(component, `'${component}' names '${designMode.itemsPath}' as its design-mode items, which is not one of its Collection properties`));
+    }
+    const seenAdd = new Set();
+    for (const action of designMode.addActions){
+        if (seenAdd.has(action.id)) diagnostics.push(invalidDesignMode(component, `'${component}' declares the design-mode add action '${action.id}' more than once`));
+        seenAdd.add(action.id);
+        if (action.collectionPath !== undefined && !collections.has(action.collectionPath)) {
+            diagnostics.push(invalidDesignMode(component, `the design-mode add action '${action.id}' of '${component}' adds to '${action.collectionPath}', which is not one of its Collection properties`));
+        }
+    }
+    const seenItem = new Set();
+    for (const action of designMode.itemToolbar){
+        if (seenItem.has(action.id)) diagnostics.push(invalidDesignMode(component, `'${component}' declares the design-mode item action '${action.id}' more than once`));
+        seenItem.add(action.id);
+    }
+    return diagnostics;
+}
+function validateEditorOptions(component, properties, parent) {
+    const diagnostics = [];
+    const invalid = (path, message)=>({
+            code: DiagnosticCode.PropertyEditorOptionsInvalid,
+            severity: DiagnosticSeverity.Error,
+            component,
+            path,
+            message: `'${component}' property '${path}' ${message}`
+        });
+    for (const property of properties){
+        const path = `${parent}${property.path}`;
+        const options = property.editorOptions;
+        if (property.editorKind === PropertyEditorKind.Reference && !options?.reference?.target) {
+            diagnostics.push(invalid(path, "uses the 'reference' editor without saying what it references (editorOptions.reference.target)"));
+        }
+        if (options?.step !== undefined && !(options.step > 0)) {
+            diagnostics.push(invalid(path, 'declares a step that is not greater than zero'));
+        }
+        if (options?.kinds !== undefined && options.kinds.length === 0) {
+            diagnostics.push(invalid(path, 'declares an empty list of kinds, which would offer nothing'));
+        }
+        if (property.item) diagnostics.push(...validateEditorOptions(component, property.item.properties, `${path}[].`));
+        if (property.properties) diagnostics.push(...validateEditorOptions(component, property.properties, `${path}.`));
+    }
+    return diagnostics;
+}
+
+export { validateComponentDescriptors };
+//# sourceMappingURL=validateComponentDescriptors.js.map

package/dist/esm/descriptors/validateComponentDescriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateComponentDescriptors.js","sources":["../../../descriptors/validateComponentDescriptors.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport {\n    ComponentDescriptor, ComponentDesignModeDescriptor, DiagnosticCode, DiagnosticSeverity, PropertyDescriptor, PropertyEditorKind, PropertyValueType,\n    SceneDiagnostic, componentCategories,\n} from '@cratis/scene.model';\n\n/**\n * Checks the component metadata a package ships - what a picker and a designer read without loading a component.\n *\n * - **CMP1** `componentCategoryMissing` (error): a registered component has no descriptor, or its descriptor declares no category.\n * - `componentCategoryUnknown` (warning): the category is not one of the model's; a package may add its own, so this is a\n *   nudge towards the shared vocabulary, not a refusal.\n * - `componentDesignModeInvalid` (error): the design-mode descriptor names an items or collection path that is not a `Collection`\n *   property of the component, or repeats an action id.\n * - `propertyEditorOptionsInvalid` (error): an editor's parameters cannot work - a `reference` editor that does not say what it\n *   references, a step that is not positive, an empty list of slice kinds.\n *\n * `registered` is the bare or package-qualified names of the components the package registers; when given, each must be described.\n * The result is in a stable order: registered components first (in the order given), then each descriptor's findings in its own order.\n */\nexport function validateComponentDescriptors(\n    descriptors: readonly ComponentDescriptor[],\n    registered?: readonly string[],\n    knownCategories: readonly string[] = componentCategories\n): SceneDiagnostic[] {\n    const diagnostics: SceneDiagnostic[] = [];\n    const described = new Map(descriptors.map(descriptor => [descriptor.component, descriptor]));\n\n    for (const component of registered ?? []) {\n        if (!described.has(component)) {\n            diagnostics.push(missingCategory(component, `'${component}' is registered but has no descriptor, so it declares no category`));\n        }\n    }\n\n    for (const descriptor of descriptors) {\n        const { component } = descriptor;\n\n        if (descriptor.category === undefined || descriptor.category.trim().length === 0) {\n            diagnostics.push(missingCategory(component, `'${component}' declares no category`));\n        } else if (!knownCategories.includes(descriptor.category)) {\n            diagnostics.push({\n                code: DiagnosticCode.ComponentCategoryUnknown, severity: DiagnosticSeverity.Warning, component,\n                message: `'${component}' declares the category '${descriptor.category}', which is not one of ${knownCategories.join(', ')}`,\n            });\n        }\n\n        if (descriptor.designMode) {\n            diagnostics.push(...validateDesignMode(descriptor, descriptor.designMode));\n        }\n\n        diagnostics.push(...validateEditorOptions(component, descriptor.properties, ''));\n    }\n\n    return diagnostics;\n}\n\nfunction missingCategory(component: string, message: string): SceneDiagnostic {\n    return { code: DiagnosticCode.ComponentCategoryMissing, severity: DiagnosticSeverity.Error, component, message };\n}\n\nfunction invalidDesignMode(component: string, message: string): SceneDiagnostic {\n    return { code: DiagnosticCode.ComponentDesignModeInvalid, severity: DiagnosticSeverity.Error, component, message };\n}\n\nfunction validateDesignMode(descriptor: ComponentDescriptor, designMode: ComponentDesignModeDescriptor): SceneDiagnostic[] {\n    const { component } = descriptor;\n    const diagnostics: SceneDiagnostic[] = [];\n    const collections = new Set(descriptor.properties.filter(property => property.valueType === PropertyValueType.Collection).map(property => property.path));\n\n    if (designMode.itemsPath !== undefined && !collections.has(designMode.itemsPath)) {\n        diagnostics.push(invalidDesignMode(component, `'${component}' names '${designMode.itemsPath}' as its design-mode items, which is not one of its Collection properties`));\n    }\n\n    const seenAdd = new Set<string>();\n    for (const action of designMode.addActions) {\n        if (seenAdd.has(action.id)) diagnostics.push(invalidDesignMode(component, `'${component}' declares the design-mode add action '${action.id}' more than once`));\n        seenAdd.add(action.id);\n\n        if (action.collectionPath !== undefined && !collections.has(action.collectionPath)) {\n            diagnostics.push(invalidDesignMode(component, `the design-mode add action '${action.id}' of '${component}' adds to '${action.collectionPath}', which is not one of its Collection properties`));\n        }\n    }\n\n    const seenItem = new Set<string>();\n    for (const action of designMode.itemToolbar) {\n        if (seenItem.has(action.id)) diagnostics.push(invalidDesignMode(component, `'${component}' declares the design-mode item action '${action.id}' more than once`));\n        seenItem.add(action.id);\n    }\n\n    return diagnostics;\n}\n\nfunction validateEditorOptions(component: string, properties: readonly PropertyDescriptor[], parent: string): SceneDiagnostic[] {\n    const diagnostics: SceneDiagnostic[] = [];\n    const invalid = (path: string, message: string): SceneDiagnostic => ({\n        code: DiagnosticCode.PropertyEditorOptionsInvalid, severity: DiagnosticSeverity.Error, component, path, message: `'${component}' property '${path}' ${message}`,\n    });\n\n    for (const property of properties) {\n        const path = `${parent}${property.path}`;\n        const options = property.editorOptions;\n\n        if (property.editorKind === PropertyEditorKind.Reference && !options?.reference?.target) {\n            diagnostics.push(invalid(path, \"uses the 'reference' editor without saying what it references (editorOptions.reference.target)\"));\n        }\n\n        if (options?.step !== undefined && !(options.step > 0)) {\n            diagnostics.push(invalid(path, 'declares a step that is not greater than zero'));\n        }\n\n        if (options?.kinds !== undefined && options.kinds.length === 0) {\n            diagnostics.push(invalid(path, 'declares an empty list of kinds, which would offer nothing'));\n        }\n\n        if (property.item) diagnostics.push(...validateEditorOptions(component, property.item.properties, `${path}[].`));\n        if (property.properties) diagnostics.push(...validateEditorOptions(component, property.properties, `${path}.`));\n    }\n\n    return diagnostics;\n}\n"],"names":["validateComponentDescriptors","descriptors","registered","knownCategories","componentCategories","diagnostics","described","Map","map","descriptor","component","has","push","missingCategory","category","undefined","trim","length","includes","code","DiagnosticCode","ComponentCategoryUnknown","severity","DiagnosticSeverity","Warning","message","join","designMode","validateDesignMode","validateEditorOptions","properties","ComponentCategoryMissing","Error","invalidDesignMode","ComponentDesignModeInvalid","collections","Set","filter","property","valueType","PropertyValueType","Collection","path","itemsPath","seenAdd","action","addActions","id","add","collectionPath","seenItem","itemToolbar","parent","invalid","PropertyEditorOptionsInvalid","options","editorOptions","editorKind","PropertyEditorKind","Reference","reference","target","step","kinds","item"],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -16,6 +16,7 @@ export * from './panelKind';
 export * from './flowNodeKind';
 export * from './ComponentResolution';
 export * from './icons';
+export * from './descriptors';
 export * from './resolveComponentName';
 export * from './computeSizeClass';
 export * from './evaluateFlowArrangement';
@@ -39,4 +40,5 @@ export * from './resolveStrings';
 export * from './navigation';
 export * from './validateNavigationDestinations';
 export * from './editing';
+export * from './structure';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,kCAAkC,CAAC;AACjD,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,kCAAkC,CAAC;AACjD,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/esm/index.js

@@ -25,6 +25,10 @@ export { resolveIconLibraries } from './icons/resolveIconLibraries.js';
 export { referencesOfEntry } from './icons/EffectiveIconEntry.js';
 export { EffectiveIconCatalog } from './icons/EffectiveIconCatalog.js';
 export { analyzeIconImpact } from './icons/analyzeIconImpact.js';
+export { validateComponentDescriptors } from './descriptors/validateComponentDescriptors.js';
+export { componentBadge } from './descriptors/componentBadge.js';
+export { matchComponentQuery } from './descriptors/matchComponentQuery.js';
+export { frequentlyUsedLimit, rankFrequentlyUsedComponents } from './descriptors/rankFrequentlyUsedComponents.js';
 export { corePackage, effectivePackages, resolveComponentName } from './resolveComponentName.js';
 export { computeSizeClass, defaultHeightBreakpoint, defaultWidthBreakpoint } from './computeSizeClass.js';
 export { evaluateFlowArrangement } from './evaluateFlowArrangement.js';
@@ -69,4 +73,6 @@ export { applyEdit } from './editing/applyEdit.js';
 export { iconProblem, iconProblemsOfItems, iconProblemsOfProperty } from './editing/iconDiagnostics.js';
 export { diagnoseIcons } from './editing/diagnoseIcons.js';
 export { collectIconUsages } from './editing/collectIconUsages.js';
+export { StructureDiagnosticCode } from './structure/StructureDiagnosticCode.js';
+export { ApplicationStructureIndex } from './structure/ApplicationStructureIndex.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/structure/ApplicationStructureIndex.d.ts

@@ -0,0 +1,22 @@
+import { ApplicationStructure, FeatureNode, ModuleNode, SliceKind, SliceNode } from '@cratis/scene.model';
+import { StructureDiagnostic } from './StructureDiagnostic';
+export declare class ApplicationStructureIndex {
+    readonly structure: ApplicationStructure;
+    private readonly modules;
+    private readonly features;
+    private readonly slices;
+    private readonly featuresByName;
+    readonly diagnostics: StructureDiagnostic[];
+    constructor(structure: ApplicationStructure);
+    findModule(moduleId: string): ModuleNode | undefined;
+    findFeature(qualifiedId: string): FeatureNode | undefined;
+    firstFeature(moduleId: string): FeatureNode | undefined;
+    firstFeatureId(moduleId: string): string | undefined;
+    findSlice(qualifiedId: string): SliceNode | undefined;
+    kindOf(sliceId: string): SliceKind | undefined;
+    findFeaturesByName(name: string): string[];
+    private indexContainer;
+    private claim;
+    private reportAmbiguousName;
+}
+//# sourceMappingURL=ApplicationStructureIndex.d.ts.map

package/dist/esm/structure/ApplicationStructureIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplicationStructureIndex.d.ts","sourceRoot":"","sources":["../../../structure/ApplicationStructureIndex.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC1G,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAW5D,qBAAa,yBAAyB;IAatB,QAAQ,CAAC,SAAS,EAAE,oBAAoB;IAZpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+B;IAG9D,QAAQ,CAAC,WAAW,EAAE,mBAAmB,EAAE,CAAM;IAMjD,YAAqB,SAAS,EAAE,oBAAoB,EAYnD;IAOD,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEnD;IAOD,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAExD;IAOD,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAEtD;IAOD,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGnD;IAOD,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAEpD;IAOD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE7C;IAOD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEzC;IAED,OAAO,CAAC,cAAc;IA2BtB,OAAO,CAAC,KAAK;IAeb,OAAO,CAAC,mBAAmB;CAc9B"}