@cratis/scene.engine 4.3.0 → 4.4.0

package/dist/cjs/icons/resolveIconLibraries.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+var resolvePackageDependencies = require('../resolvePackageDependencies.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Finds the icon libraries a profile's packages make active - the ones it lists and the ones its other
+ * packages declare a dependency on - through the normal package resolver, so an icon library is
+ * selected, ordered and version-checked exactly as any other package is.
+ *
+ * Several libraries coexist. Nothing here ranks them: two libraries that both ship `home` stay two
+ * different icons, told apart by the library in their {@link IconReference}.
+ *
+ * @param selected The package names the profile lists.
+ * @param catalog Every package that could be selected.
+ */ function resolveIconLibraries(selected, catalog) {
+    const selection = resolvePackageDependencies.resolvePackageDependencies(selected, catalog);
+    const index = new Map(catalog.map((scenePackage)=>[
+            scenePackage.name,
+            scenePackage
+        ]));
+    const chosen = new Set(selected);
+    const active = selection.packages.map((name)=>index.get(name)).filter((scenePackage)=>scenePackage !== undefined);
+    const libraries = active.filter((scenePackage)=>scenePackage.kind === scene_model.PackageKind.IconLibrary).map((scenePackage)=>({
+            library: scenePackage.name,
+            package: scenePackage,
+            isSelected: chosen.has(scenePackage.name),
+            requiredBy: active.filter((other)=>other.dependencies.some((dependency)=>dependency.name === scenePackage.name)).map((other)=>other.name)
+        }));
+    const libraryNames = new Set(libraries.map((resolved)=>resolved.library));
+    const diagnostics = selection.versionConflicts.filter((conflict)=>libraryNames.has(conflict.dependsOn)).map((conflict)=>({
+            kind: 'incompatible-version',
+            library: conflict.dependsOn,
+            message: `'${conflict.package}' needs the icon library '${conflict.dependsOn}' at '${conflict.requiredRange}', but version ${conflict.actualVersion} is what is available`
+        }));
+    return {
+        libraries,
+        diagnostics
+    };
+}
+
+exports.resolveIconLibraries = resolveIconLibraries;
+//# sourceMappingURL=resolveIconLibraries.js.map

package/dist/cjs/icons/resolveIconLibraries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveIconLibraries.js","sources":["../../../icons/resolveIconLibraries.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 { PackageKind, ScenePackage } from '@cratis/scene.model';\nimport { resolvePackageDependencies } from '../resolvePackageDependencies';\nimport { IconDiagnostic } from './IconDiagnostic';\nimport { IconLibraryResolution } from './IconLibraryResolution';\n\n/**\n * Finds the icon libraries a profile's packages make active - the ones it lists and the ones its other\n * packages declare a dependency on - through the normal package resolver, so an icon library is\n * selected, ordered and version-checked exactly as any other package is.\n *\n * Several libraries coexist. Nothing here ranks them: two libraries that both ship `home` stay two\n * different icons, told apart by the library in their {@link IconReference}.\n *\n * @param selected The package names the profile lists.\n * @param catalog Every package that could be selected.\n */\nexport function resolveIconLibraries(selected: string[], catalog: ScenePackage[]): IconLibraryResolution {\n    const selection = resolvePackageDependencies(selected, catalog);\n    const index = new Map(catalog.map((scenePackage) => [scenePackage.name, scenePackage]));\n    const chosen = new Set(selected);\n    const active = selection.packages.map((name) => index.get(name)).filter((scenePackage): scenePackage is ScenePackage => scenePackage !== undefined);\n\n    const libraries = active\n        .filter((scenePackage) => scenePackage.kind === PackageKind.IconLibrary)\n        .map((scenePackage) => ({\n            library: scenePackage.name,\n            package: scenePackage,\n            isSelected: chosen.has(scenePackage.name),\n            requiredBy: active\n                .filter((other) => other.dependencies.some((dependency) => dependency.name === scenePackage.name))\n                .map((other) => other.name),\n        }));\n\n    const libraryNames = new Set(libraries.map((resolved) => resolved.library));\n    const diagnostics: IconDiagnostic[] = selection.versionConflicts\n        .filter((conflict) => libraryNames.has(conflict.dependsOn))\n        .map((conflict) => ({\n            kind: 'incompatible-version',\n            library: conflict.dependsOn,\n            message: `'${conflict.package}' needs the icon library '${conflict.dependsOn}' at '${conflict.requiredRange}', but version ${conflict.actualVersion} is what is available`,\n        }));\n\n    return { libraries, diagnostics };\n}\n"],"names":["resolveIconLibraries","selected","catalog","selection","resolvePackageDependencies","index","Map","map","scenePackage","name","chosen","Set","active","packages","get","filter","undefined","libraries","kind","PackageKind","IconLibrary","library","package","isSelected","has","requiredBy","other","dependencies","some","dependency","libraryNames","resolved","diagnostics","versionConflicts","conflict","dependsOn","message","requiredRange","actualVersion"],"mappings":";;;;;AAAA;AACA;AAOA;;;;;;;;;;AAUC,IACM,SAASA,oBAAAA,CAAqBC,QAAkB,EAAEC,OAAuB,EAAA;IAC5E,MAAMC,SAAAA,GAAYC,sDAA2BH,QAAAA,EAAUC,OAAAA,CAAAA;AACvD,IAAA,MAAMG,QAAQ,IAAIC,GAAAA,CAAIJ,QAAQK,GAAG,CAAC,CAACC,YAAAA,GAAiB;AAACA,YAAAA,YAAAA,CAAaC,IAAI;AAAED,YAAAA;AAAa,SAAA,CAAA,CAAA;IACrF,MAAME,MAAAA,GAAS,IAAIC,GAAAA,CAAIV,QAAAA,CAAAA;AACvB,IAAA,MAAMW,SAAST,SAAAA,CAAUU,QAAQ,CAACN,GAAG,CAAC,CAACE,IAAAA,GAASJ,KAAAA,CAAMS,GAAG,CAACL,IAAAA,CAAAA,CAAAA,CAAOM,MAAM,CAAC,CAACP,eAA+CA,YAAAA,KAAiBQ,SAAAA,CAAAA;AAEzI,IAAA,MAAMC,YAAYL,MAAAA,CACbG,MAAM,CAAC,CAACP,eAAiBA,YAAAA,CAAaU,IAAI,KAAKC,uBAAAA,CAAYC,WAAW,CAAA,CACtEb,GAAG,CAAC,CAACC,gBAAkB;AACpBa,YAAAA,OAAAA,EAASb,aAAaC,IAAI;YAC1Ba,OAAAA,EAASd,YAAAA;AACTe,YAAAA,UAAAA,EAAYb,MAAAA,CAAOc,GAAG,CAAChB,YAAAA,CAAaC,IAAI,CAAA;YACxCgB,UAAAA,EAAYb,MAAAA,CACPG,MAAM,CAAC,CAACW,QAAUA,KAAAA,CAAMC,YAAY,CAACC,IAAI,CAAC,CAACC,aAAeA,UAAAA,CAAWpB,IAAI,KAAKD,YAAAA,CAAaC,IAAI,CAAA,CAAA,CAC/FF,GAAG,CAAC,CAACmB,KAAAA,GAAUA,KAAAA,CAAMjB,IAAI;SAClC,CAAA,CAAA;IAEJ,MAAMqB,YAAAA,GAAe,IAAInB,GAAAA,CAAIM,SAAAA,CAAUV,GAAG,CAAC,CAACwB,QAAAA,GAAaA,QAAAA,CAASV,OAAO,CAAA,CAAA;AACzE,IAAA,MAAMW,cAAgC7B,SAAAA,CAAU8B,gBAAgB,CAC3DlB,MAAM,CAAC,CAACmB,QAAAA,GAAaJ,YAAAA,CAAaN,GAAG,CAACU,SAASC,SAAS,CAAA,CAAA,CACxD5B,GAAG,CAAC,CAAC2B,YAAc;YAChBhB,IAAAA,EAAM,sBAAA;AACNG,YAAAA,OAAAA,EAASa,SAASC,SAAS;YAC3BC,OAAAA,EAAS,CAAC,CAAC,EAAEF,QAAAA,CAASZ,OAAO,CAAC,0BAA0B,EAAEY,QAAAA,CAASC,SAAS,CAAC,MAAM,EAAED,QAAAA,CAASG,aAAa,CAAC,eAAe,EAAEH,QAAAA,CAASI,aAAa,CAAC,qBAAqB;SAC7K,CAAA,CAAA;IAEJ,OAAO;AAAErB,QAAAA,SAAAA;AAAWe,QAAAA;AAAY,KAAA;AACpC;;"}

package/dist/cjs/index.js

@@ -4,6 +4,10 @@ var renderElement = require('./renderElement.js');
 var elementKind = require('./elementKind.js');
 var panelKind = require('./panelKind.js');
 var flowNodeKind = require('./flowNodeKind.js');
+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 resolveComponentName = require('./resolveComponentName.js');
 var computeSizeClass = require('./computeSizeClass.js');
 var evaluateFlowArrangement = require('./evaluateFlowArrangement.js');
@@ -35,6 +39,9 @@ var applyEffectiveConfiguration = require('./editing/applyEffectiveConfiguration
 var indexDocument = require('./editing/indexDocument.js');
 var inspect = require('./editing/inspect.js');
 var applyEdit = require('./editing/applyEdit.js');
+var iconDiagnostics = require('./editing/iconDiagnostics.js');
+var diagnoseIcons = require('./editing/diagnoseIcons.js');
+var collectIconUsages = require('./editing/collectIconUsages.js');
 
 
 
@@ -54,6 +61,10 @@ exports.isFlowGrid = flowNodeKind.isFlowGrid;
 exports.isFlowLeaf = flowNodeKind.isFlowLeaf;
 exports.isFlowRow = flowNodeKind.isFlowRow;
 exports.isFlowSlotLeaf = flowNodeKind.isFlowSlotLeaf;
+exports.resolveIconLibraries = resolveIconLibraries.resolveIconLibraries;
+exports.referencesOfEntry = EffectiveIconEntry.referencesOfEntry;
+exports.EffectiveIconCatalog = EffectiveIconCatalog.EffectiveIconCatalog;
+exports.analyzeIconImpact = analyzeIconImpact.analyzeIconImpact;
 exports.corePackage = resolveComponentName.corePackage;
 exports.effectivePackages = resolveComponentName.effectivePackages;
 exports.resolveComponentName = resolveComponentName.resolveComponentName;
@@ -126,4 +137,9 @@ exports.panelLayoutType = indexDocument.panelLayoutType;
 exports.inspect = inspect.inspect;
 exports.provenanceOf = inspect.provenanceOf;
 exports.applyEdit = applyEdit.applyEdit;
+exports.iconProblem = iconDiagnostics.iconProblem;
+exports.iconProblemsOfItems = iconDiagnostics.iconProblemsOfItems;
+exports.iconProblemsOfProperty = iconDiagnostics.iconProblemsOfProperty;
+exports.diagnoseIcons = diagnoseIcons.diagnoseIcons;
+exports.collectIconUsages = collectIconUsages.collectIconUsages;
 //# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/editing/EditingContext.d.ts

@@ -1,8 +1,10 @@
 import { EditingScope, QueryCandidate } from '@cratis/scene.model';
+import { EffectiveIconCatalog } from '../icons/EffectiveIconCatalog';
 import { DescriptorCatalog } from './DescriptorCatalog';
 export interface EditingContext {
     catalog: DescriptorCatalog;
     scope: EditingScope;
     queryCandidates?: QueryCandidate[];
+    iconCatalog?: EffectiveIconCatalog;
 }
 //# sourceMappingURL=EditingContext.d.ts.map

package/dist/esm/editing/EditingContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditingContext.d.ts","sourceRoot":"","sources":["../../../editing/EditingContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAMxD,MAAM,WAAW,cAAc;IAE3B,OAAO,EAAE,iBAAiB,CAAC;IAG3B,KAAK,EAAE,YAAY,CAAC;IAMpB,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;CACtC"}
+{"version":3,"file":"EditingContext.d.ts","sourceRoot":"","sources":["../../../editing/EditingContext.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAMxD,MAAM,WAAW,cAAc;IAE3B,OAAO,EAAE,iBAAiB,CAAC;IAG3B,KAAK,EAAE,YAAY,CAAC;IAMpB,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;IAUnC,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACtC"}

package/dist/esm/editing/collectIconUsages.d.ts

@@ -0,0 +1,5 @@
+import { SceneDocument } from '@cratis/scene.model';
+import { IconUsage } from '../icons/IconUsage';
+import { DescriptorCatalog } from './DescriptorCatalog';
+export declare function collectIconUsages(document: SceneDocument, catalog: DescriptorCatalog): IconUsage[];
+//# sourceMappingURL=collectIconUsages.d.ts.map

package/dist/esm/editing/collectIconUsages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectIconUsages.d.ts","sourceRoot":"","sources":["../../../editing/collectIconUsages.ts"],"names":[],"mappings":"AAGA,OAAO,EAA+D,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjH,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAA2B,MAAM,qBAAqB,CAAC;AAsCjF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,iBAAiB,GAAG,SAAS,EAAE,CA6BlG"}

package/dist/esm/editing/collectIconUsages.js

@@ -0,0 +1,84 @@
+import { PropertyValueType } from '@cratis/scene.model';
+import { collectComponents } from './collectComponents.js';
+import { findComponentDescriptor } from './DescriptorCatalog.js';
+import { getValueAtPath } from './pathAccess.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function iconFields(property) {
+    return (property.item?.properties ?? []).filter((field)=>field.valueType === PropertyValueType.Icon).map((field)=>field.path);
+}
+function usagesOf(property, value, items, location) {
+    if (property.valueType === PropertyValueType.Icon) {
+        return value === undefined ? [] : [
+            {
+                value: value,
+                location: `${location}:${property.path}`
+            }
+        ];
+    }
+    return property.valueType === PropertyValueType.Collection ? (items ?? []).flatMap((item)=>iconFields(property).filter((field)=>item.values[field] !== undefined).map((field)=>({
+                value: item.values[field],
+                location: `${location}:${property.path}:${item.id}:${field}`
+            }))) : [];
+}
+function ownerItems(value) {
+    return (Array.isArray(value) ? value : []).filter((item)=>item !== null && typeof item === 'object').map(({ id, ...values })=>({
+            id: String(id),
+            values
+        }));
+}
+/**
+ * Finds every icon value stored anywhere in a document - the values components carry themselves, and the values
+ * and collection-item icon fields that template instances contributed - as the `IconUsage`s that
+ * `analyzeIconImpact` takes, so "what would removing this library break" can be asked of a whole document.
+ *
+ * Each usage's `location` reads `<owner or instance>:<component>:<path>[:<itemId>:<field>]`, where the first part is
+ * the contributing instance id (`screen:Orders`) for a contributed value and the name of the owning layout or
+ * template for a value the component carries. Values are read as stored; none are changed.
+ *
+ * @param document The document to read.
+ * @param catalog The descriptors saying which properties are icons.
+ */ function collectIconUsages(document, catalog) {
+    const usages = [];
+    const componentNames = new Map();
+    const owners = [
+        ...document.layouts.map((layout)=>({
+                name: layout.name,
+                value: layout
+            })),
+        ...document.screenTemplates.map((template)=>({
+                name: template.name,
+                value: template
+            })),
+        ...document.dialogTemplates.map((template)=>({
+                name: template.name,
+                value: template
+            })),
+        ...document.screens.map((screen)=>({
+                name: screen.name,
+                value: screen
+            }))
+    ];
+    for (const owner of owners){
+        for (const component of collectComponents(owner.value)){
+            if (!componentNames.has(component.id)) componentNames.set(component.id, component.componentName);
+            for (const property of findComponentDescriptor(catalog, component.componentName)?.properties ?? []){
+                const value = getValueAtPath(component.properties, property.path);
+                usages.push(...usagesOf(property, value, ownerItems(value), `${owner.name}:${component.id}`));
+            }
+        }
+    }
+    for (const contribution of document.instanceContributions){
+        const componentName = componentNames.get(contribution.component);
+        const property = componentName === undefined ? undefined : findComponentDescriptor(catalog, componentName)?.properties.find((candidate)=>candidate.path === contribution.path);
+        if (property) usages.push(...contributedUsages(property, contribution));
+    }
+    return usages;
+}
+function contributedUsages(property, contribution) {
+    return usagesOf(property, contribution.value, contribution.items, `${contribution.instance}:${contribution.component}`);
+}
+
+export { collectIconUsages };
+//# sourceMappingURL=collectIconUsages.js.map

package/dist/esm/editing/collectIconUsages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectIconUsages.js","sources":["../../../editing/collectIconUsages.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 { InstanceContribution, PropertyDescriptor, PropertyValueType, SceneDocument } from '@cratis/scene.model';\nimport { IconUsage } from '../icons/IconUsage';\nimport { collectComponents } from './collectComponents';\nimport { DescriptorCatalog, findComponentDescriptor } from './DescriptorCatalog';\nimport { getValueAtPath } from './pathAccess';\n\nfunction iconFields(property: PropertyDescriptor): string[] {\n    return (property.item?.properties ?? []).filter((field) => field.valueType === PropertyValueType.Icon).map((field) => field.path);\n}\n\nfunction usagesOf(property: PropertyDescriptor, value: unknown, items: { id: string; values: Record<string, unknown> }[] | undefined, location: string): IconUsage[] {\n    if (property.valueType === PropertyValueType.Icon) {\n        return value === undefined ? [] : [{ value: value as IconUsage['value'], location: `${location}:${property.path}` }];\n    }\n\n    return property.valueType === PropertyValueType.Collection\n        ? (items ?? []).flatMap((item) =>\n              iconFields(property)\n                  .filter((field) => item.values[field] !== undefined)\n                  .map((field) => ({ value: item.values[field] as IconUsage['value'], location: `${location}:${property.path}:${item.id}:${field}` })))\n        : [];\n}\n\nfunction ownerItems(value: unknown): { id: string; values: Record<string, unknown> }[] {\n    return (Array.isArray(value) ? value : [])\n        .filter((item): item is Record<string, unknown> => item !== null && typeof item === 'object')\n        .map(({ id, ...values }) => ({ id: String(id), values }));\n}\n\n/**\n * Finds every icon value stored anywhere in a document - the values components carry themselves, and the values\n * and collection-item icon fields that template instances contributed - as the `IconUsage`s that\n * `analyzeIconImpact` takes, so \"what would removing this library break\" can be asked of a whole document.\n *\n * Each usage's `location` reads `<owner or instance>:<component>:<path>[:<itemId>:<field>]`, where the first part is\n * the contributing instance id (`screen:Orders`) for a contributed value and the name of the owning layout or\n * template for a value the component carries. Values are read as stored; none are changed.\n *\n * @param document The document to read.\n * @param catalog The descriptors saying which properties are icons.\n */\nexport function collectIconUsages(document: SceneDocument, catalog: DescriptorCatalog): IconUsage[] {\n    const usages: IconUsage[] = [];\n    const componentNames = new Map<string, string>();\n\n    const owners: { name: string; value: unknown }[] = [\n        ...document.layouts.map((layout) => ({ name: layout.name, value: layout })),\n        ...document.screenTemplates.map((template) => ({ name: template.name, value: template })),\n        ...document.dialogTemplates.map((template) => ({ name: template.name, value: template })),\n        ...document.screens.map((screen) => ({ name: screen.name, value: screen })),\n    ];\n\n    for (const owner of owners) {\n        for (const component of collectComponents(owner.value)) {\n            if (!componentNames.has(component.id)) componentNames.set(component.id, component.componentName);\n\n            for (const property of findComponentDescriptor(catalog, component.componentName)?.properties ?? []) {\n                const value = getValueAtPath(component.properties, property.path);\n                usages.push(...usagesOf(property, value, ownerItems(value), `${owner.name}:${component.id}`));\n            }\n        }\n    }\n\n    for (const contribution of document.instanceContributions) {\n        const componentName = componentNames.get(contribution.component);\n        const property = componentName === undefined ? undefined : findComponentDescriptor(catalog, componentName)?.properties.find((candidate) => candidate.path === contribution.path);\n        if (property) usages.push(...contributedUsages(property, contribution));\n    }\n\n    return usages;\n}\n\nfunction contributedUsages(property: PropertyDescriptor, contribution: InstanceContribution): IconUsage[] {\n    return usagesOf(property, contribution.value, contribution.items, `${contribution.instance}:${contribution.component}`);\n}\n"],"names":["iconFields","property","item","properties","filter","field","valueType","PropertyValueType","Icon","map","path","usagesOf","value","items","location","undefined","Collection","flatMap","values","id","ownerItems","Array","isArray","String","collectIconUsages","document","catalog","usages","componentNames","Map","owners","layouts","layout","name","screenTemplates","template","dialogTemplates","screens","screen","owner","component","collectComponents","has","set","componentName","findComponentDescriptor","getValueAtPath","push","contribution","instanceContributions","get","find","candidate","contributedUsages","instance"],"mappings":"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"}

package/dist/esm/editing/diagnoseIcons.d.ts

@@ -0,0 +1,4 @@
+import { SceneDiagnostic, SceneDocument } from '@cratis/scene.model';
+import { EditingContext } from './EditingContext';
+export declare function diagnoseIcons(document: SceneDocument, context: EditingContext): SceneDiagnostic[];
+//# sourceMappingURL=diagnoseIcons.d.ts.map

package/dist/esm/editing/diagnoseIcons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnoseIcons.d.ts","sourceRoot":"","sources":["../../../editing/diagnoseIcons.ts"],"names":[],"mappings":"AAGA,OAAO,EAA6D,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEhI,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAuBlD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,eAAe,EAAE,CA+BjG"}

package/dist/esm/editing/diagnoseIcons.js

@@ -0,0 +1,65 @@
+import { PropertyValueType, DiagnosticSeverity } from '@cratis/scene.model';
+import { findComponentDescriptor } from './DescriptorCatalog.js';
+import { iconProblemsOfProperty, iconProblemsOfItems } from './iconDiagnostics.js';
+import { getValueAtPath } from './pathAccess.js';
+import { resolveEffectiveConfiguration } from './resolveEffectiveConfiguration.js';
+import { resolveTemplateChain } from './resolveTemplateChain.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function isIconBearing(property) {
+    return property.valueType === PropertyValueType.Icon || property.valueType === PropertyValueType.Collection && (property.item?.properties ?? []).some((field)=>field.valueType === PropertyValueType.Icon);
+}
+/**
+ * Reports every icon in what the editing scope renders - the template chain's own values and what each instance
+ * contributed - that the profile's icon catalog cannot supply: a library the profile lacks, an icon or variant a
+ * library no longer has, a library at an incompatible version.
+ *
+ * It reports; it never changes anything. The offending values stay in the document, still applied (a renderer
+ * shows its fallback), and apply again as soon as the icon is available, so removing a library is reversible.
+ * Each diagnostic names the component, property, collection item and - for a contributed value - the instance.
+ *
+ * Returns nothing when the context carries no `iconCatalog`. Load the catalogs first (`iconCatalog.load()`) for
+ * definite answers; an icon from an unloaded library is reported as not verified.
+ */ function diagnoseIcons(document, context) {
+    const iconCatalog = context.iconCatalog;
+    if (!iconCatalog) return [];
+    const chain = resolveTemplateChain(document, context.scope);
+    const configuration = resolveEffectiveConfiguration(chain, document.instanceContributions, context.catalog);
+    const diagnostics = [];
+    for (const level of chain.levels){
+        for (const element of level.elements){
+            const descriptor = findComponentDescriptor(context.catalog, element.componentName);
+            const configured = configuration.components.find((candidate)=>candidate.component === element.id);
+            for (const property of (descriptor?.properties ?? []).filter(isIconBearing)){
+                const effective = configured?.values.find((candidate)=>candidate.path === property.path);
+                const where = {
+                    component: element.id,
+                    ...effective?.contributedBy === undefined ? {} : {
+                        instance: effective.contributedBy
+                    }
+                };
+                if (property.valueType === PropertyValueType.Icon) {
+                    const value = effective ? effective.value : getValueAtPath(element.properties, property.path);
+                    diagnostics.push(...iconProblemsOfProperty(iconCatalog, property, value, DiagnosticSeverity.Warning, where));
+                } else if (effective?.items) {
+                    const items = effective.items.map((item)=>({
+                            id: item.id,
+                            values: item.values,
+                            instance: item.origin === 'owner' ? undefined : item.origin
+                        }));
+                    diagnostics.push(...iconProblemsOfItems(iconCatalog, property.item, items, DiagnosticSeverity.Warning, {
+                        component: element.id,
+                        path: property.path
+                    }));
+                } else {
+                    diagnostics.push(...iconProblemsOfProperty(iconCatalog, property, getValueAtPath(element.properties, property.path), DiagnosticSeverity.Warning, where));
+                }
+            }
+        }
+    }
+    return diagnostics;
+}
+
+export { diagnoseIcons };
+//# sourceMappingURL=diagnoseIcons.js.map

package/dist/esm/editing/diagnoseIcons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnoseIcons.js","sources":["../../../editing/diagnoseIcons.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 { DiagnosticSeverity, PropertyDescriptor, PropertyValueType, SceneDiagnostic, SceneDocument } from '@cratis/scene.model';\nimport { findComponentDescriptor } from './DescriptorCatalog';\nimport { EditingContext } from './EditingContext';\nimport { iconProblemsOfItems, iconProblemsOfProperty } from './iconDiagnostics';\nimport { getValueAtPath } from './pathAccess';\nimport { resolveEffectiveConfiguration } from './resolveEffectiveConfiguration';\nimport { resolveTemplateChain } from './resolveTemplateChain';\n\nfunction isIconBearing(property: PropertyDescriptor): boolean {\n    return property.valueType === PropertyValueType.Icon\n        || (property.valueType === PropertyValueType.Collection && (property.item?.properties ?? []).some((field) => field.valueType === PropertyValueType.Icon));\n}\n\n/**\n * Reports every icon in what the editing scope renders - the template chain's own values and what each instance\n * contributed - that the profile's icon catalog cannot supply: a library the profile lacks, an icon or variant a\n * library no longer has, a library at an incompatible version.\n *\n * It reports; it never changes anything. The offending values stay in the document, still applied (a renderer\n * shows its fallback), and apply again as soon as the icon is available, so removing a library is reversible.\n * Each diagnostic names the component, property, collection item and - for a contributed value - the instance.\n *\n * Returns nothing when the context carries no `iconCatalog`. Load the catalogs first (`iconCatalog.load()`) for\n * definite answers; an icon from an unloaded library is reported as not verified.\n */\nexport function diagnoseIcons(document: SceneDocument, context: EditingContext): SceneDiagnostic[] {\n    const iconCatalog = context.iconCatalog;\n    if (!iconCatalog) return [];\n\n    const chain = resolveTemplateChain(document, context.scope);\n    const configuration = resolveEffectiveConfiguration(chain, document.instanceContributions, context.catalog);\n    const diagnostics: SceneDiagnostic[] = [];\n\n    for (const level of chain.levels) {\n        for (const element of level.elements) {\n            const descriptor = findComponentDescriptor(context.catalog, element.componentName);\n            const configured = configuration.components.find((candidate) => candidate.component === element.id);\n\n            for (const property of (descriptor?.properties ?? []).filter(isIconBearing)) {\n                const effective = configured?.values.find((candidate) => candidate.path === property.path);\n                const where = { component: element.id, ...(effective?.contributedBy === undefined ? {} : { instance: effective.contributedBy }) };\n\n                if (property.valueType === PropertyValueType.Icon) {\n                    const value = effective ? effective.value : getValueAtPath(element.properties, property.path);\n                    diagnostics.push(...iconProblemsOfProperty(iconCatalog, property, value, DiagnosticSeverity.Warning, where));\n                } else if (effective?.items) {\n                    const items = effective.items.map((item) => ({ id: item.id, values: item.values, instance: item.origin === 'owner' ? undefined : item.origin }));\n                    diagnostics.push(...iconProblemsOfItems(iconCatalog, property.item, items, DiagnosticSeverity.Warning, { component: element.id, path: property.path }));\n                } else {\n                    diagnostics.push(...iconProblemsOfProperty(iconCatalog, property, getValueAtPath(element.properties, property.path), DiagnosticSeverity.Warning, where));\n                }\n            }\n        }\n    }\n\n    return diagnostics;\n}\n"],"names":["isIconBearing","property","valueType","PropertyValueType","Icon","Collection","item","properties","some","field","diagnoseIcons","document","context","iconCatalog","chain","resolveTemplateChain","scope","configuration","resolveEffectiveConfiguration","instanceContributions","catalog","diagnostics","level","levels","element","elements","descriptor","findComponentDescriptor","componentName","configured","components","find","candidate","component","id","filter","effective","values","path","where","contributedBy","undefined","instance","value","getValueAtPath","push","iconProblemsOfProperty","DiagnosticSeverity","Warning","items","map","origin","iconProblemsOfItems"],"mappings":"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"}

package/dist/esm/editing/iconDiagnostics.d.ts

@@ -0,0 +1,11 @@
+import { CollectionItemDescriptor, DiagnosticSeverity, PropertyDescriptor, SceneDiagnostic } from '@cratis/scene.model';
+import { EffectiveIconCatalog } from '../icons/EffectiveIconCatalog';
+import { DiagnosticContext } from './diagnostics';
+export declare function iconProblem(catalog: EffectiveIconCatalog, value: unknown, severity: DiagnosticSeverity, context: DiagnosticContext): SceneDiagnostic | undefined;
+export declare function iconProblemsOfItems(catalog: EffectiveIconCatalog, itemDescriptor: CollectionItemDescriptor | undefined, items: {
+    id: string;
+    values: Record<string, unknown>;
+    instance?: string;
+}[], severity: DiagnosticSeverity, context: DiagnosticContext): SceneDiagnostic[];
+export declare function iconProblemsOfProperty(catalog: EffectiveIconCatalog, descriptor: PropertyDescriptor, value: unknown, severity: DiagnosticSeverity, context: DiagnosticContext): SceneDiagnostic[];
+//# sourceMappingURL=iconDiagnostics.d.ts.map

package/dist/esm/editing/iconDiagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iconDiagnostics.d.ts","sourceRoot":"","sources":["../../../editing/iconDiagnostics.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAkB,kBAAkB,EAAE,kBAAkB,EAAqB,eAAe,EAAmB,MAAM,qBAAqB,CAAC;AAC5K,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAwBlD,wBAAgB,WAAW,CAAC,OAAO,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,GAAG,eAAe,GAAG,SAAS,CAchK;AAQD,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,oBAAoB,EAC7B,cAAc,EAAE,wBAAwB,GAAG,SAAS,EACpD,KAAK,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,EAC3E,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,iBAAiB,GAC3B,eAAe,EAAE,CAQnB;AASD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,GAAG,eAAe,EAAE,CAcjM"}

package/dist/esm/editing/iconDiagnostics.js

@@ -0,0 +1,99 @@
+import { DiagnosticCode, isIconReference, DiagnosticSeverity, PropertyValueType } 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.
+const codes = {
+    'missing-library': DiagnosticCode.MissingIconLibrary,
+    'missing-icon': DiagnosticCode.MissingIcon,
+    'missing-variant': DiagnosticCode.MissingIconVariant,
+    'incompatible-version': DiagnosticCode.IncompatibleIconLibrary,
+    'catalog-unavailable': DiagnosticCode.IconCatalogUnavailable
+};
+/**
+ * Checks one icon value against the effective icon catalog.
+ *
+ * Nothing is rewritten or dropped: this only reports. A value whose library, icon or variant is missing, or
+ * whose library is at an incompatible version, produces a diagnostic of the given severity - an error when
+ * the value is being *set* (the edit is refused), a warning when it is already stored (it is kept, and
+ * applies again if the icon comes back). A value that cannot be judged yet, because its library's catalog has
+ * not been loaded, produces an `IconNotVerified` warning rather than silently passing.
+ *
+ * @param catalog The effective catalog of the profile being edited.
+ * @param value The value; anything that is not an icon reference is left to `validateValue`.
+ * @param severity How serious a definite problem is.
+ * @param context What the diagnostic is about.
+ */ function iconProblem(catalog, value, severity, context) {
+    if (!isIconReference(value)) return undefined;
+    const resolution = catalog.lookup(value);
+    if (resolution === undefined) {
+        return {
+            code: DiagnosticCode.IconNotVerified,
+            severity: DiagnosticSeverity.Warning,
+            message: `The catalog of the icon library '${value.library}' is not loaded, so '${value.key}' could not be verified.`,
+            ...context
+        };
+    }
+    return resolution.isResolved ? undefined : {
+        code: codes[resolution.diagnostic.kind],
+        severity,
+        message: `${resolution.diagnostic.message}.`,
+        ...context
+    };
+}
+/**
+ * Checks the icon fields of collection items.
+ *
+ * @param itemDescriptor What the items look like.
+ * @param items The items, each with its id and field values.
+ */ function iconProblemsOfItems(catalog, itemDescriptor, items, severity, context) {
+    const iconFields = (itemDescriptor?.properties ?? []).filter((field)=>field.valueType === PropertyValueType.Icon);
+    return items.flatMap((item)=>iconFields.flatMap((field)=>{
+            const problem = iconProblem(catalog, item.values[field.path], severity, {
+                ...context,
+                itemId: item.id,
+                ...item.instance === undefined ? {} : {
+                    instance: item.instance
+                }
+            });
+            return problem ? [
+                {
+                    ...problem,
+                    message: `'${field.label}' of '${item.id}': ${problem.message}`
+                }
+            ] : [];
+        }));
+}
+/**
+ * Checks a property's value - an icon, or a collection whose items have icon fields - against the effective icon
+ * catalog. Any other kind of property has nothing to check.
+ *
+ * @param descriptor The property.
+ * @param value The value; for a collection, the flat items (`{ id, ...fields }`) as they are stored.
+ */ function iconProblemsOfProperty(catalog, descriptor, value, severity, context) {
+    if (descriptor.valueType === PropertyValueType.Icon) {
+        const problem = iconProblem(catalog, value, severity, {
+            ...context,
+            path: descriptor.path
+        });
+        return problem ? [
+            {
+                ...problem,
+                message: `'${descriptor.label}': ${problem.message}`
+            }
+        ] : [];
+    }
+    if (descriptor.valueType === PropertyValueType.Collection && Array.isArray(value)) {
+        const items = value.filter((item)=>item !== null && typeof item === 'object').map(({ id, ...values })=>({
+                id: String(id),
+                values
+            }));
+        return iconProblemsOfItems(catalog, descriptor.item, items, severity, {
+            ...context,
+            path: descriptor.path
+        });
+    }
+    return [];
+}
+
+export { iconProblem, iconProblemsOfItems, iconProblemsOfProperty };
+//# sourceMappingURL=iconDiagnostics.js.map

package/dist/esm/editing/iconDiagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iconDiagnostics.js","sources":["../../../editing/iconDiagnostics.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 { CollectionItemDescriptor, DiagnosticCode, DiagnosticSeverity, PropertyDescriptor, PropertyValueType, SceneDiagnostic, isIconReference } from '@cratis/scene.model';\nimport { EffectiveIconCatalog } from '../icons/EffectiveIconCatalog';\nimport { IconDiagnosticKind } from '../icons/IconDiagnostic';\nimport { DiagnosticContext } from './diagnostics';\n\nconst codes: Record<IconDiagnosticKind, DiagnosticCode> = {\n    'missing-library': DiagnosticCode.MissingIconLibrary,\n    'missing-icon': DiagnosticCode.MissingIcon,\n    'missing-variant': DiagnosticCode.MissingIconVariant,\n    'incompatible-version': DiagnosticCode.IncompatibleIconLibrary,\n    'catalog-unavailable': DiagnosticCode.IconCatalogUnavailable,\n};\n\n/**\n * Checks one icon value against the effective icon catalog.\n *\n * Nothing is rewritten or dropped: this only reports. A value whose library, icon or variant is missing, or\n * whose library is at an incompatible version, produces a diagnostic of the given severity - an error when\n * the value is being *set* (the edit is refused), a warning when it is already stored (it is kept, and\n * applies again if the icon comes back). A value that cannot be judged yet, because its library's catalog has\n * not been loaded, produces an `IconNotVerified` warning rather than silently passing.\n *\n * @param catalog The effective catalog of the profile being edited.\n * @param value The value; anything that is not an icon reference is left to `validateValue`.\n * @param severity How serious a definite problem is.\n * @param context What the diagnostic is about.\n */\nexport function iconProblem(catalog: EffectiveIconCatalog, value: unknown, severity: DiagnosticSeverity, context: DiagnosticContext): SceneDiagnostic | undefined {\n    if (!isIconReference(value)) return undefined;\n\n    const resolution = catalog.lookup(value);\n    if (resolution === undefined) {\n        return {\n            code: DiagnosticCode.IconNotVerified,\n            severity: DiagnosticSeverity.Warning,\n            message: `The catalog of the icon library '${value.library}' is not loaded, so '${value.key}' could not be verified.`,\n            ...context,\n        };\n    }\n\n    return resolution.isResolved ? undefined : { code: codes[resolution.diagnostic.kind], severity, message: `${resolution.diagnostic.message}.`, ...context };\n}\n\n/**\n * Checks the icon fields of collection items.\n *\n * @param itemDescriptor What the items look like.\n * @param items The items, each with its id and field values.\n */\nexport function iconProblemsOfItems(\n    catalog: EffectiveIconCatalog,\n    itemDescriptor: CollectionItemDescriptor | undefined,\n    items: { id: string; values: Record<string, unknown>; instance?: string }[],\n    severity: DiagnosticSeverity,\n    context: DiagnosticContext\n): SceneDiagnostic[] {\n    const iconFields = (itemDescriptor?.properties ?? []).filter((field) => field.valueType === PropertyValueType.Icon);\n    return items.flatMap((item) =>\n        iconFields.flatMap((field) => {\n            const problem = iconProblem(catalog, item.values[field.path], severity, { ...context, itemId: item.id, ...(item.instance === undefined ? {} : { instance: item.instance }) });\n            return problem ? [{ ...problem, message: `'${field.label}' of '${item.id}': ${problem.message}` }] : [];\n        })\n    );\n}\n\n/**\n * Checks a property's value - an icon, or a collection whose items have icon fields - against the effective icon\n * catalog. Any other kind of property has nothing to check.\n *\n * @param descriptor The property.\n * @param value The value; for a collection, the flat items (`{ id, ...fields }`) as they are stored.\n */\nexport function iconProblemsOfProperty(catalog: EffectiveIconCatalog, descriptor: PropertyDescriptor, value: unknown, severity: DiagnosticSeverity, context: DiagnosticContext): SceneDiagnostic[] {\n    if (descriptor.valueType === PropertyValueType.Icon) {\n        const problem = iconProblem(catalog, value, severity, { ...context, path: descriptor.path });\n        return problem ? [{ ...problem, message: `'${descriptor.label}': ${problem.message}` }] : [];\n    }\n\n    if (descriptor.valueType === PropertyValueType.Collection && Array.isArray(value)) {\n        const items = value\n            .filter((item): item is Record<string, unknown> => item !== null && typeof item === 'object')\n            .map(({ id, ...values }) => ({ id: String(id), values }));\n        return iconProblemsOfItems(catalog, descriptor.item, items, severity, { ...context, path: descriptor.path });\n    }\n\n    return [];\n}\n"],"names":["codes","DiagnosticCode","MissingIconLibrary","MissingIcon","MissingIconVariant","IncompatibleIconLibrary","IconCatalogUnavailable","iconProblem","catalog","value","severity","context","isIconReference","undefined","resolution","lookup","code","IconNotVerified","DiagnosticSeverity","Warning","message","library","key","isResolved","diagnostic","kind","iconProblemsOfItems","itemDescriptor","items","iconFields","properties","filter","field","valueType","PropertyValueType","Icon","flatMap","item","problem","values","path","itemId","id","instance","label","iconProblemsOfProperty","descriptor","Collection","Array","isArray","map","String"],"mappings":"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"}

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

@@ -16,4 +16,7 @@ export * from './EditingContext';
 export * from './inspect';
 export * from './EditOutcome';
 export * from './applyEdit';
+export * from './iconDiagnostics';
+export * from './diagnoseIcons';
+export * from './collectIconUsages';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editing/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../editing/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/esm/editing/index.js

@@ -16,4 +16,7 @@ export * from './EditingContext';
 export * from './inspect';
 export * from './EditOutcome';
 export * from './applyEdit';
+export * from './iconDiagnostics';
+export * from './diagnoseIcons';
+export * from './collectIconUsages';
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../editing/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../editing/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC"}

package/dist/esm/editing/inspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../editing/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,EACqE,cAAc,EACtF,cAAc,EAA0E,aAAa,EACxG,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAyB,aAAa,EAAY,MAAM,kBAAkB,CAAC;AAElF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAUhD,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,GAAG,cAAc,CAO1I;AA0ED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAoCpH"}
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../editing/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,EACyF,cAAc,EAC1G,cAAc,EAA0E,aAAa,EACxG,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAyB,aAAa,EAAY,MAAM,kBAAkB,CAAC;AAGlF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAUhD,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS,GAAG,cAAc,CAO1I;AA0FD,wBAAgB,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,CAyCpH"}

package/dist/esm/editing/inspect.js

@@ -1,6 +1,7 @@
-import { SceneNodeKind, DiagnosticCode, ProvenanceKind, PropertyValueType, ValueSource, EditTarget } from '@cratis/scene.model';
+import { SceneNodeKind, DiagnosticCode, ProvenanceKind, PropertyValueType, ValueSource, EditTarget, DiagnosticSeverity } from '@cratis/scene.model';
 import { describeNode, readNodeValue } from './describeNode.js';
 import { computeExposureGrants, grantKey } from './exposureGrants.js';
+import { iconProblemsOfProperty, iconProblemsOfItems } from './iconDiagnostics.js';
 import { indexDocument } from './indexDocument.js';
 import { resolveEffectiveConfiguration } from './resolveEffectiveConfiguration.js';
 import { resolveTemplateChain } from './resolveTemplateChain.js';
@@ -74,6 +75,28 @@ function inspectProperty(descriptor, record, provenance, scopeInstance, grants,
     }
     return inspected;
 }
+/**
+ * Reports icons the profile cannot supply - on the node itself and in configuration contributed to it. The values
+ * stay where they are; these are warnings.
+ */ function iconDiagnosticsOf(properties, iconCatalog, nodeId) {
+    return properties.flatMap((property)=>{
+        const descriptor = property.descriptor;
+        if (descriptor.valueType !== PropertyValueType.Collection) {
+            return iconProblemsOfProperty(iconCatalog, descriptor, property.effectiveValue, DiagnosticSeverity.Warning, {
+                nodeId
+            });
+        }
+        const items = (property.items ?? []).map((item)=>({
+                id: item.id,
+                values: item.values,
+                instance: item.origin === 'owner' ? undefined : item.origin
+            }));
+        return iconProblemsOfItems(iconCatalog, descriptor.item, items, DiagnosticSeverity.Warning, {
+            nodeId,
+            path: descriptor.path
+        });
+    });
+}
 /**
  * Describes one node for an editor: what it is, where it comes from, what can be edited on it - with current and
  * effective values and effective editability - and what can be done with it.
@@ -106,6 +129,10 @@ function inspectProperty(descriptor, record, provenance, scopeInstance, grants,
     if (chain.levels.length === 0) {
         diagnostics.push(...chain.diagnostics.filter((diagnostic)=>diagnostic.code === DiagnosticCode.UnknownScope));
     }
+    const properties = description.properties.map((descriptor)=>inspectProperty(descriptor, record, provenance, scopeInstance, scopeGrants, configuredValues));
+    if (context.iconCatalog) {
+        diagnostics.push(...iconDiagnosticsOf(properties, context.iconCatalog, nodeId));
+    }
     return {
         nodeId,
         kind: record.kind,
@@ -113,7 +140,7 @@ function inspectProperty(descriptor, record, provenance, scopeInstance, grants,
         label: record.label,
         parentId: record.parentId,
         provenance,
-        properties: description.properties.map((descriptor)=>inspectProperty(descriptor, record, provenance, scopeInstance, scopeGrants, configuredValues)),
+        properties,
         capabilities: description.capabilities,
         removable: isRemovable(record, provenance),
         diagnostics