@cratis/scene.engine 4.22.1 → 4.24.0

package/descriptors/componentBadge.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ComponentDescriptor } from '@cratis/scene.model';
+
+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.
+ */
+export function componentBadge(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'badge'>): string {
+    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: string): string {
+    return component.slice(component.lastIndexOf(':') + 1);
+}
+
+function capitalize(letters: string): string {
+    return letters.charAt(0).toUpperCase() + letters.slice(1).toLowerCase();
+}

package/descriptors/index.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './validateComponentDescriptors';
+export * from './componentBadge';
+export * from './matchComponentQuery';
+export * from './rankFrequentlyUsedComponents';

package/descriptors/matchComponentQuery.ts

@@ -0,0 +1,55 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ComponentDescriptor } from '@cratis/scene.model';
+
+/**
+ * How a component answers a picker's filter text (spec PICK2).
+ */
+export interface ComponentQueryMatch {
+    /** The component is shown for this filter. */
+    matched: boolean;
+
+    /** What matched, strongest first: the display name, the category, or one of the keywords. Absent when nothing matched. */
+    via?: 'name' | 'category' | 'keyword';
+
+    /** The `[start, end)` ranges of the display name to highlight. Empty unless the name matched. */
+    ranges: [number, number][];
+
+    /** The keyword the component matched through. Present only when `via` is `keyword`: the picker shows it as a hint. */
+    keyword?: string;
+}
+
+/**
+ * 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.
+ */
+export function matchComponentQuery(descriptor: Pick<ComponentDescriptor, 'component' | 'displayName' | 'category' | 'keywords'>, query: string): ComponentQueryMatch {
+    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: string, needle: string): [number, number][] {
+    const found: [number, number][] = [];
+    for (let at = text.indexOf(needle); at >= 0; at = text.indexOf(needle, at + needle.length)) {
+        found.push([at, at + needle.length]);
+    }
+
+    return found;
+}

package/descriptors/rankFrequentlyUsedComponents.ts

@@ -0,0 +1,29 @@
+// 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.
+ */
+export interface ComponentUsage {
+    /** How many times the component was added. */
+    count: number;
+
+    /** When it was last added, in milliseconds since the epoch. */
+    last: number;
+}
+
+/** The number of components the "Frequently used" group lists (spec PICK3). */
+export 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.
+ */
+export function rankFrequentlyUsedComponents(usage: Readonly<Record<string, ComponentUsage>>, limit: number = frequentlyUsedLimit): string[] {
+    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);
+}

package/descriptors/validateComponentDescriptors.ts

@@ -0,0 +1,122 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import {
+    ComponentDescriptor, ComponentDesignModeDescriptor, DiagnosticCode, DiagnosticSeverity, PropertyDescriptor, PropertyEditorKind, PropertyValueType,
+    SceneDiagnostic, componentCategories,
+} from '@cratis/scene.model';
+
+/**
+ * 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.
+ */
+export function validateComponentDescriptors(
+    descriptors: readonly ComponentDescriptor[],
+    registered?: readonly string[],
+    knownCategories: readonly string[] = componentCategories
+): SceneDiagnostic[] {
+    const diagnostics: SceneDiagnostic[] = [];
+    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: string, message: string): SceneDiagnostic {
+    return { code: DiagnosticCode.ComponentCategoryMissing, severity: DiagnosticSeverity.Error, component, message };
+}
+
+function invalidDesignMode(component: string, message: string): SceneDiagnostic {
+    return { code: DiagnosticCode.ComponentDesignModeInvalid, severity: DiagnosticSeverity.Error, component, message };
+}
+
+function validateDesignMode(descriptor: ComponentDescriptor, designMode: ComponentDesignModeDescriptor): SceneDiagnostic[] {
+    const { component } = descriptor;
+    const diagnostics: SceneDiagnostic[] = [];
+    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<string>();
+    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<string>();
+    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: string, properties: readonly PropertyDescriptor[], parent: string): SceneDiagnostic[] {
+    const diagnostics: SceneDiagnostic[] = [];
+    const invalid = (path: string, message: string): SceneDiagnostic => ({
+        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;
+}

package/dist/cjs/descriptors/componentBadge.js

@@ -0,0 +1,35 @@
+'use strict';
+
+// 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();
+}
+
+exports.componentBadge = componentBadge;
+//# sourceMappingURL=componentBadge.js.map

package/dist/cjs/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/cjs/descriptors/matchComponentQuery.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// 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;
+}
+
+exports.matchComponentQuery = matchComponentQuery;
+//# sourceMappingURL=matchComponentQuery.js.map

package/dist/cjs/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/cjs/descriptors/rankFrequentlyUsedComponents.js

@@ -0,0 +1,18 @@
+'use strict';
+
+// 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);
+}
+
+exports.frequentlyUsedLimit = frequentlyUsedLimit;
+exports.rankFrequentlyUsedComponents = rankFrequentlyUsedComponents;
+//# sourceMappingURL=rankFrequentlyUsedComponents.js.map

package/dist/cjs/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/cjs/descriptors/validateComponentDescriptors.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var scene_model = require('@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 = scene_model.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: scene_model.DiagnosticCode.ComponentCategoryUnknown,
+                severity: scene_model.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: scene_model.DiagnosticCode.ComponentCategoryMissing,
+        severity: scene_model.DiagnosticSeverity.Error,
+        component,
+        message
+    };
+}
+function invalidDesignMode(component, message) {
+    return {
+        code: scene_model.DiagnosticCode.ComponentDesignModeInvalid,
+        severity: scene_model.DiagnosticSeverity.Error,
+        component,
+        message
+    };
+}
+function validateDesignMode(descriptor, designMode) {
+    const { component } = descriptor;
+    const diagnostics = [];
+    const collections = new Set(descriptor.properties.filter((property)=>property.valueType === scene_model.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: scene_model.DiagnosticCode.PropertyEditorOptionsInvalid,
+            severity: scene_model.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 === scene_model.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;
+}
+
+exports.validateComponentDescriptors = validateComponentDescriptors;
+//# sourceMappingURL=validateComponentDescriptors.js.map

package/dist/cjs/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/cjs/index.js

@@ -27,6 +27,10 @@ var resolveIconLibraries = require('./icons/resolveIconLibraries.js');
 var EffectiveIconEntry = require('./icons/EffectiveIconEntry.js');
 var EffectiveIconCatalog = require('./icons/EffectiveIconCatalog.js');
 var analyzeIconImpact = require('./icons/analyzeIconImpact.js');
+var validateComponentDescriptors = require('./descriptors/validateComponentDescriptors.js');
+var componentBadge = require('./descriptors/componentBadge.js');
+var matchComponentQuery = require('./descriptors/matchComponentQuery.js');
+var rankFrequentlyUsedComponents = require('./descriptors/rankFrequentlyUsedComponents.js');
 var resolveComponentName = require('./resolveComponentName.js');
 var computeSizeClass = require('./computeSizeClass.js');
 var evaluateFlowArrangement = require('./evaluateFlowArrangement.js');
@@ -71,6 +75,8 @@ var applyEdit = require('./editing/applyEdit.js');
 var iconDiagnostics = require('./editing/iconDiagnostics.js');
 var diagnoseIcons = require('./editing/diagnoseIcons.js');
 var collectIconUsages = require('./editing/collectIconUsages.js');
+var StructureDiagnosticCode = require('./structure/StructureDiagnosticCode.js');
+var ApplicationStructureIndex = require('./structure/ApplicationStructureIndex.js');
 
 
 
@@ -115,6 +121,11 @@ exports.resolveIconLibraries = resolveIconLibraries.resolveIconLibraries;
 exports.referencesOfEntry = EffectiveIconEntry.referencesOfEntry;
 exports.EffectiveIconCatalog = EffectiveIconCatalog.EffectiveIconCatalog;
 exports.analyzeIconImpact = analyzeIconImpact.analyzeIconImpact;
+exports.validateComponentDescriptors = validateComponentDescriptors.validateComponentDescriptors;
+exports.componentBadge = componentBadge.componentBadge;
+exports.matchComponentQuery = matchComponentQuery.matchComponentQuery;
+exports.frequentlyUsedLimit = rankFrequentlyUsedComponents.frequentlyUsedLimit;
+exports.rankFrequentlyUsedComponents = rankFrequentlyUsedComponents.rankFrequentlyUsedComponents;
 exports.corePackage = resolveComponentName.corePackage;
 exports.effectivePackages = resolveComponentName.effectivePackages;
 exports.resolveComponentName = resolveComponentName.resolveComponentName;
@@ -209,4 +220,6 @@ exports.iconProblemsOfItems = iconDiagnostics.iconProblemsOfItems;
 exports.iconProblemsOfProperty = iconDiagnostics.iconProblemsOfProperty;
 exports.diagnoseIcons = diagnoseIcons.diagnoseIcons;
 exports.collectIconUsages = collectIconUsages.collectIconUsages;
+exports.StructureDiagnosticCode = StructureDiagnosticCode.StructureDiagnosticCode;
+exports.ApplicationStructureIndex = ApplicationStructureIndex.ApplicationStructureIndex;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

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