@cratis/scene.engine 4.2.1 → 4.4.0

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');
@@ -21,6 +25,23 @@ var incompatibleStarterThemes = require('./incompatibleStarterThemes.js');
 var runActions = require('./runActions.js');
 var resolveBehaviors = require('./resolveBehaviors.js');
 var resolveStrings = require('./resolveStrings.js');
+var diagnostics = require('./editing/diagnostics.js');
+var nodeIds = require('./editing/nodeIds.js');
+var layoutTypeDescriptors = require('./editing/layoutTypeDescriptors.js');
+var DescriptorCatalog = require('./editing/DescriptorCatalog.js');
+var validateValue = require('./editing/validateValue.js');
+var validateBinding = require('./editing/validateBinding.js');
+var collectComponents = require('./editing/collectComponents.js');
+var resolveTemplateChain = require('./editing/resolveTemplateChain.js');
+var exposureGrants = require('./editing/exposureGrants.js');
+var resolveEffectiveConfiguration = require('./editing/resolveEffectiveConfiguration.js');
+var applyEffectiveConfiguration = require('./editing/applyEffectiveConfiguration.js');
+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');
 
 
 
@@ -40,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;
@@ -75,4 +100,46 @@ exports.resolveIntervalBehaviors = resolveBehaviors.resolveIntervalBehaviors;
 exports.isStringsReference = resolveStrings.isStringsReference;
 exports.resolveStringsInElement = resolveStrings.resolveStringsInElement;
 exports.resolveStringsValue = resolveStrings.resolveStringsValue;
+exports.errorDiagnostic = diagnostics.errorDiagnostic;
+exports.hasErrors = diagnostics.hasErrors;
+exports.warningDiagnostic = diagnostics.warningDiagnostic;
+exports.dialogTemplateNodeId = nodeIds.dialogTemplateNodeId;
+exports.elementNodeId = nodeIds.elementNodeId;
+exports.flowNodeId = nodeIds.flowNodeId;
+exports.freeformNodeId = nodeIds.freeformNodeId;
+exports.layoutNodeId = nodeIds.layoutNodeId;
+exports.ownerArrangementId = nodeIds.ownerArrangementId;
+exports.placementNodeId = nodeIds.placementNodeId;
+exports.scopeInstanceId = nodeIds.scopeInstanceId;
+exports.scopeNodeId = nodeIds.scopeNodeId;
+exports.screenNodeId = nodeIds.screenNodeId;
+exports.screenTemplateNodeId = nodeIds.screenTemplateNodeId;
+exports.slotNodeId = nodeIds.slotNodeId;
+exports.layoutTypeDescriptors = layoutTypeDescriptors.layoutTypeDescriptors;
+exports.placementProperties = layoutTypeDescriptors.placementProperties;
+exports.templateProperties = layoutTypeDescriptors.templateProperties;
+exports.createDescriptorCatalog = DescriptorCatalog.createDescriptorCatalog;
+exports.findComponentDescriptor = DescriptorCatalog.findComponentDescriptor;
+exports.findLayoutTypeDescriptor = DescriptorCatalog.findLayoutTypeDescriptor;
+exports.validateItemValues = validateValue.validateItemValues;
+exports.validateValue = validateValue.validateValue;
+exports.areTypesCompatible = validateBinding.areTypesCompatible;
+exports.validateBinding = validateBinding.validateBinding;
+exports.collectComponents = collectComponents.collectComponents;
+exports.resolveTemplateChain = resolveTemplateChain.resolveTemplateChain;
+exports.computeExposureGrants = exposureGrants.computeExposureGrants;
+exports.grantKey = exposureGrants.grantKey;
+exports.resolveEffectiveConfiguration = resolveEffectiveConfiguration.resolveEffectiveConfiguration;
+exports.applyEffectiveConfiguration = applyEffectiveConfiguration.applyEffectiveConfiguration;
+exports.flowLayoutType = indexDocument.flowLayoutType;
+exports.indexDocument = indexDocument.indexDocument;
+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/DescriptorCatalog.d.ts

@@ -0,0 +1,9 @@
+import { ComponentDescriptor, LayoutTypeDescriptor } from '@cratis/scene.model';
+export interface DescriptorCatalog {
+    components: ComponentDescriptor[];
+    layoutTypes: LayoutTypeDescriptor[];
+}
+export declare function createDescriptorCatalog(componentDescriptors?: ComponentDescriptor[]): DescriptorCatalog;
+export declare function findComponentDescriptor(catalog: DescriptorCatalog, componentName: string): ComponentDescriptor | undefined;
+export declare function findLayoutTypeDescriptor(catalog: DescriptorCatalog, type: string): LayoutTypeDescriptor | undefined;
+//# sourceMappingURL=DescriptorCatalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DescriptorCatalog.d.ts","sourceRoot":"","sources":["../../../editing/DescriptorCatalog.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAUhF,MAAM,WAAW,iBAAiB;IAC9B,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAQD,wBAAgB,uBAAuB,CAAC,oBAAoB,GAAE,mBAAmB,EAAO,GAAG,iBAAiB,CAK3G;AAQD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAM1H;AAKD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAEnH"}

package/dist/esm/editing/DescriptorCatalog.js

@@ -0,0 +1,38 @@
+import { layoutTypeDescriptors } from './layoutTypeDescriptors.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Builds a catalog from the component descriptors of the active packages, plus the built-in layout types.
+ *
+ * When two descriptors name the same component the later one wins, which is the same override-priority rule
+ * the profile's package order already means for components.
+ */ function createDescriptorCatalog(componentDescriptors = []) {
+    const byComponent = new Map();
+    for (const descriptor of componentDescriptors)byComponent.set(descriptor.component, descriptor);
+    return {
+        components: [
+            ...byComponent.values()
+        ],
+        layoutTypes: layoutTypeDescriptors
+    };
+}
+/**
+ * Finds the descriptor of a component by the name an element carries.
+ *
+ * An exact match wins. Otherwise a bare name (`dataTable`) finds the one descriptor whose component ends in
+ * `:dataTable`; a bare name that several packages describe has no single answer, so it finds none.
+ */ function findComponentDescriptor(catalog, componentName) {
+    const exact = catalog.components.find((descriptor)=>descriptor.component === componentName);
+    if (exact) return exact;
+    const matches = catalog.components.filter((descriptor)=>descriptor.component.endsWith(`:${componentName}`));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+/**
+ * Finds the descriptor of a layout type.
+ */ function findLayoutTypeDescriptor(catalog, type) {
+    return catalog.layoutTypes.find((descriptor)=>descriptor.type === type);
+}
+
+export { createDescriptorCatalog, findComponentDescriptor, findLayoutTypeDescriptor };
+//# sourceMappingURL=DescriptorCatalog.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DescriptorCatalog.js","sources":["../../../editing/DescriptorCatalog.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, LayoutTypeDescriptor } from '@cratis/scene.model';\nimport { layoutTypeDescriptors } from './layoutTypeDescriptors';\n\n/**\n * Everything an editor knows how to describe: the component descriptors packages contribute, and the layout types\n * the model itself defines.\n *\n * It is a derived view over what packages ship - not a registry anything registers into. Build one from the\n * descriptors of the packages a profile lists, and rebuild it when the list changes.\n */\nexport interface DescriptorCatalog {\n    components: ComponentDescriptor[];\n    layoutTypes: LayoutTypeDescriptor[];\n}\n\n/**\n * Builds a catalog from the component descriptors of the active packages, plus the built-in layout types.\n *\n * When two descriptors name the same component the later one wins, which is the same override-priority rule\n * the profile's package order already means for components.\n */\nexport function createDescriptorCatalog(componentDescriptors: ComponentDescriptor[] = []): DescriptorCatalog {\n    const byComponent = new Map<string, ComponentDescriptor>();\n    for (const descriptor of componentDescriptors) byComponent.set(descriptor.component, descriptor);\n\n    return { components: [...byComponent.values()], layoutTypes: layoutTypeDescriptors };\n}\n\n/**\n * Finds the descriptor of a component by the name an element carries.\n *\n * An exact match wins. Otherwise a bare name (`dataTable`) finds the one descriptor whose component ends in\n * `:dataTable`; a bare name that several packages describe has no single answer, so it finds none.\n */\nexport function findComponentDescriptor(catalog: DescriptorCatalog, componentName: string): ComponentDescriptor | undefined {\n    const exact = catalog.components.find(descriptor => descriptor.component === componentName);\n    if (exact) return exact;\n\n    const matches = catalog.components.filter(descriptor => descriptor.component.endsWith(`:${componentName}`));\n    return matches.length === 1 ? matches[0] : undefined;\n}\n\n/**\n * Finds the descriptor of a layout type.\n */\nexport function findLayoutTypeDescriptor(catalog: DescriptorCatalog, type: string): LayoutTypeDescriptor | undefined {\n    return catalog.layoutTypes.find(descriptor => descriptor.type === type);\n}\n"],"names":["createDescriptorCatalog","componentDescriptors","byComponent","Map","descriptor","set","component","components","values","layoutTypes","layoutTypeDescriptors","findComponentDescriptor","catalog","componentName","exact","find","matches","filter","endsWith","length","undefined","findLayoutTypeDescriptor","type"],"mappings":";;AAAA;AACA;AAiBA;;;;;AAKC,IACM,SAASA,uBAAAA,CAAwBC,oBAAAA,GAA8C,EAAE,EAAA;AACpF,IAAA,MAAMC,cAAc,IAAIC,GAAAA,EAAAA;IACxB,KAAK,MAAMC,cAAcH,oBAAAA,CAAsBC,WAAAA,CAAYG,GAAG,CAACD,UAAAA,CAAWE,SAAS,EAAEF,UAAAA,CAAAA;IAErF,OAAO;QAAEG,UAAAA,EAAY;AAAIL,YAAAA,GAAAA,WAAAA,CAAYM,MAAM;AAAG,SAAA;QAAEC,WAAAA,EAAaC;AAAsB,KAAA;AACvF;AAEA;;;;;AAKC,IACM,SAASC,uBAAAA,CAAwBC,OAA0B,EAAEC,aAAqB,EAAA;IACrF,MAAMC,KAAAA,GAAQF,OAAAA,CAAQL,UAAU,CAACQ,IAAI,CAACX,CAAAA,UAAAA,GAAcA,UAAAA,CAAWE,SAAS,KAAKO,aAAAA,CAAAA;AAC7E,IAAA,IAAIC,OAAO,OAAOA,KAAAA;AAElB,IAAA,MAAME,UAAUJ,OAAAA,CAAQL,UAAU,CAACU,MAAM,CAACb,CAAAA,UAAAA,GAAcA,UAAAA,CAAWE,SAAS,CAACY,QAAQ,CAAC,CAAC,CAAC,EAAEL,aAAAA,CAAAA,CAAe,CAAA,CAAA;AACzG,IAAA,OAAOG,QAAQG,MAAM,KAAK,IAAIH,OAAO,CAAC,EAAE,GAAGI,SAAAA;AAC/C;AAEA;;AAEC,IACM,SAASC,wBAAAA,CAAyBT,OAA0B,EAAEU,IAAY,EAAA;IAC7E,OAAOV,OAAAA,CAAQH,WAAW,CAACM,IAAI,CAACX,CAAAA,UAAAA,GAAcA,UAAAA,CAAWkB,IAAI,KAAKA,IAAAA,CAAAA;AACtE;;"}

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

@@ -0,0 +1,31 @@
+import { SceneDiagnostic, SceneNodeKind } from '@cratis/scene.model';
+export type DocumentPath = (string | number)[];
+export interface ListLocation {
+    path: DocumentPath;
+    index: number;
+}
+export interface NodeRecord {
+    id: string;
+    kind: SceneNodeKind;
+    typeId: string;
+    label: string;
+    path: DocumentPath;
+    value: unknown;
+    parentId?: string;
+    owner: string;
+    ownerKind: SceneNodeKind;
+    list?: ListLocation;
+    leafId?: string;
+    placementIds?: string[];
+    mirror?: {
+        prefix: DocumentPath;
+        others: DocumentPath[];
+    };
+    slotName?: string;
+    contentPath?: DocumentPath;
+}
+export interface DocumentIndex {
+    nodes: Map<string, NodeRecord>;
+    diagnostics: SceneDiagnostic[];
+}
+//# sourceMappingURL=DocumentIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentIndex.d.ts","sourceRoot":"","sources":["../../../editing/DocumentIndex.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKrE,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;AAK/C,MAAM,WAAW,YAAY;IAEzB,IAAI,EAAE,YAAY,CAAC;IAGnB,KAAK,EAAE,MAAM,CAAC;CACjB;AAKD,MAAM,WAAW,UAAU;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,aAAa,CAAC;IAGpB,MAAM,EAAE,MAAM,CAAC;IAGf,KAAK,EAAE,MAAM,CAAC;IAGd,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IAEf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,aAAa,CAAC;IAGzB,IAAI,CAAC,EAAE,YAAY,CAAC;IAGpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAGhB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAMxB,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,YAAY,EAAE,CAAA;KAAE,CAAC;IAG1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,WAAW,CAAC,EAAE,YAAY,CAAC;CAC9B;AAKD,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/B,WAAW,EAAE,eAAe,EAAE,CAAC;CAClC"}

package/dist/esm/editing/DocumentIndex.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DocumentIndex.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentIndex.js","sourceRoot":"","sources":["../../../editing/DocumentIndex.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,7 @@
+import { SceneDiagnostic, SceneDocument } from '@cratis/scene.model';
+export interface EditOutcome {
+    model: SceneDocument;
+    diagnostics: SceneDiagnostic[];
+    applied: boolean;
+}
+//# sourceMappingURL=EditOutcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditOutcome.d.ts","sourceRoot":"","sources":["../../../editing/EditOutcome.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKrE,MAAM,WAAW,WAAW;IAKxB,KAAK,EAAE,aAAa,CAAC;IAGrB,WAAW,EAAE,eAAe,EAAE,CAAC;IAG/B,OAAO,EAAE,OAAO,CAAC;CACpB"}

package/dist/esm/editing/EditOutcome.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EditOutcome.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditOutcome.js","sourceRoot":"","sources":["../../../editing/EditOutcome.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,20 @@
+import { SceneDocument } from '@cratis/scene.model';
+import { EditingContext } from './EditingContext';
+import { DocumentIndex, NodeRecord } from './DocumentIndex';
+import { ExposureGrant, ExposureGrants } from './exposureGrants';
+import { TemplateChain } from './TemplateChain';
+import { EffectiveConfiguration } from '@cratis/scene.model';
+export declare class EditSession {
+    readonly document: SceneDocument;
+    readonly context: EditingContext;
+    readonly index: DocumentIndex;
+    readonly chain: TemplateChain;
+    readonly grants: ExposureGrants;
+    readonly configuration: EffectiveConfiguration;
+    constructor(document: SceneDocument, context: EditingContext);
+    get scopeInstance(): string | undefined;
+    get scopeGrants(): Map<string, ExposureGrant>;
+    isLocal(record: NodeRecord): boolean;
+    sourceOf(record: NodeRecord): string;
+}
+//# sourceMappingURL=EditSession.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditSession.d.ts","sourceRoot":"","sources":["../../../editing/EditSession.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAyB,MAAM,kBAAkB,CAAC;AAKxF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAK7D,qBAAa,WAAW;IAMR,QAAQ,CAAC,QAAQ,EAAE,aAAa;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc;IAL9E,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,sBAAsB,CAAC;IAE/C,YAAqB,QAAQ,EAAE,aAAa,EAAW,OAAO,EAAE,cAAc,EAK7E;IAGD,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAEtC;IAGD,IAAI,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAE5C;IAGD,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAEnC;IAGD,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEnC;CACJ"}

package/dist/esm/editing/EditSession.js

@@ -0,0 +1,42 @@
+import { ProvenanceKind } from '@cratis/scene.model';
+import { computeExposureGrants } from './exposureGrants.js';
+import { indexDocument } from './indexDocument.js';
+import { provenanceOf } from './inspect.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.
+/**
+ * Everything an edit needs to decide whether it is allowed, worked out once against the document as it was.
+ */ class EditSession {
+    document;
+    context;
+    index;
+    chain;
+    grants;
+    configuration;
+    constructor(document, context){
+        this.document = document;
+        this.context = context;
+        this.index = indexDocument(document);
+        this.chain = resolveTemplateChain(document, context.scope);
+        this.grants = computeExposureGrants(this.chain, context.catalog);
+        this.configuration = resolveEffectiveConfiguration(this.chain, document.instanceContributions, context.catalog);
+    }
+    /** The instance id the scope contributes as, or `undefined` when the scope was not found. */ get scopeInstance() {
+        return this.chain.levels.at(-1)?.instance;
+    }
+    /** What the scope's instance may configure on inherited components. */ get scopeGrants() {
+        return (this.scopeInstance === undefined ? undefined : this.grants.byInstance.get(this.scopeInstance)) ?? new Map();
+    }
+    /** Whether the scope itself owns the node. */ isLocal(record) {
+        return provenanceOf(record, this.chain, this.scopeGrants).kind === ProvenanceKind.Local;
+    }
+    /** Where an inherited node comes from, for a message. */ sourceOf(record) {
+        return record.owner;
+    }
+}
+
+export { EditSession };
+//# sourceMappingURL=EditSession.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditSession.js","sources":["../../../editing/EditSession.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 { ProvenanceKind, SceneDocument } from '@cratis/scene.model';\nimport { EditingContext } from './EditingContext';\nimport { DocumentIndex, NodeRecord } from './DocumentIndex';\nimport { ExposureGrant, ExposureGrants, computeExposureGrants } from './exposureGrants';\nimport { indexDocument } from './indexDocument';\nimport { provenanceOf } from './inspect';\nimport { resolveEffectiveConfiguration } from './resolveEffectiveConfiguration';\nimport { resolveTemplateChain } from './resolveTemplateChain';\nimport { TemplateChain } from './TemplateChain';\nimport { EffectiveConfiguration } from '@cratis/scene.model';\n\n/**\n * Everything an edit needs to decide whether it is allowed, worked out once against the document as it was.\n */\nexport class EditSession {\n    readonly index: DocumentIndex;\n    readonly chain: TemplateChain;\n    readonly grants: ExposureGrants;\n    readonly configuration: EffectiveConfiguration;\n\n    constructor(readonly document: SceneDocument, readonly context: EditingContext) {\n        this.index = indexDocument(document);\n        this.chain = resolveTemplateChain(document, context.scope);\n        this.grants = computeExposureGrants(this.chain, context.catalog);\n        this.configuration = resolveEffectiveConfiguration(this.chain, document.instanceContributions, context.catalog);\n    }\n\n    /** The instance id the scope contributes as, or `undefined` when the scope was not found. */\n    get scopeInstance(): string | undefined {\n        return this.chain.levels.at(-1)?.instance;\n    }\n\n    /** What the scope's instance may configure on inherited components. */\n    get scopeGrants(): Map<string, ExposureGrant> {\n        return (this.scopeInstance === undefined ? undefined : this.grants.byInstance.get(this.scopeInstance)) ?? new Map();\n    }\n\n    /** Whether the scope itself owns the node. */\n    isLocal(record: NodeRecord): boolean {\n        return provenanceOf(record, this.chain, this.scopeGrants).kind === ProvenanceKind.Local;\n    }\n\n    /** Where an inherited node comes from, for a message. */\n    sourceOf(record: NodeRecord): string {\n        return record.owner;\n    }\n}\n"],"names":["EditSession","index","chain","grants","configuration","context","document","indexDocument","resolveTemplateChain","scope","computeExposureGrants","catalog","resolveEffectiveConfiguration","instanceContributions","scopeInstance","levels","at","instance","scopeGrants","undefined","byInstance","get","Map","isLocal","record","provenanceOf","kind","ProvenanceKind","Local","sourceOf","owner"],"mappings":";;;;;;;AAAA;AACA;AAaA;;AAEC,IACM,MAAMA,WAAAA,CAAAA;;;IACAC,KAAAA;IACAC,KAAAA;IACAC,MAAAA;IACAC,aAAAA;AAET,IAAA,WAAA,CAAY,QAAgC,EAAWC,OAAuB,CAAE;aAA3DC,QAAAA,GAAAA,QAAAA;aAAkCD,OAAAA,GAAAA,OAAAA;QACnD,IAAI,CAACJ,KAAK,GAAGM,aAAAA,CAAcD,QAAAA,CAAAA;AAC3B,QAAA,IAAI,CAACJ,KAAK,GAAGM,oBAAAA,CAAqBF,QAAAA,EAAUD,QAAQI,KAAK,CAAA;QACzD,IAAI,CAACN,MAAM,GAAGO,qBAAAA,CAAsB,IAAI,CAACR,KAAK,EAAEG,OAAAA,CAAQM,OAAO,CAAA;AAC/D,QAAA,IAAI,CAACP,aAAa,GAAGQ,6BAAAA,CAA8B,IAAI,CAACV,KAAK,EAAEI,QAAAA,CAASO,qBAAqB,EAAER,OAAAA,CAAQM,OAAO,CAAA;AAClH,IAAA;kGAGA,IAAIG,aAAAA,GAAoC;QACpC,OAAO,IAAI,CAACZ,KAAK,CAACa,MAAM,CAACC,EAAE,CAAC,EAAC,CAAA,EAAIC,QAAAA;AACrC,IAAA;4EAGA,IAAIC,WAAAA,GAA0C;QAC1C,OAAQ,CAAA,IAAI,CAACJ,aAAa,KAAKK,SAAAA,GAAYA,YAAY,IAAI,CAAChB,MAAM,CAACiB,UAAU,CAACC,GAAG,CAAC,IAAI,CAACP,aAAa,CAAA,KAAM,IAAIQ,GAAAA,EAAAA;AAClH,IAAA;mDAGAC,OAAAA,CAAQC,MAAkB,EAAW;AACjC,QAAA,OAAOC,YAAAA,CAAaD,MAAAA,EAAQ,IAAI,CAACtB,KAAK,EAAE,IAAI,CAACgB,WAAW,CAAA,CAAEQ,IAAI,KAAKC,eAAeC,KAAK;AAC3F,IAAA;8DAGAC,QAAAA,CAASL,MAAkB,EAAU;AACjC,QAAA,OAAOA,OAAOM,KAAK;AACvB,IAAA;AACJ;;"}

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

@@ -0,0 +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

@@ -0,0 +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,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/EditingContext.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EditingContext.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EditingContext.js","sourceRoot":"","sources":["../../../editing/EditingContext.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,13 @@
+import { ExposedProperty, ExternalComponent, SceneDiagnostic, SceneNodeKind } from '@cratis/scene.model';
+export interface TemplateChainLevel {
+    owner: string;
+    kind: SceneNodeKind;
+    instance: string;
+    elements: ExternalComponent[];
+    exposures: ExposedProperty[];
+}
+export interface TemplateChain {
+    levels: TemplateChainLevel[];
+    diagnostics: SceneDiagnostic[];
+}
+//# sourceMappingURL=TemplateChain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateChain.d.ts","sourceRoot":"","sources":["../../../editing/TemplateChain.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAKzG,MAAM,WAAW,kBAAkB;IAE/B,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,EAAE,aAAa,CAAC;IAGpB,QAAQ,EAAE,MAAM,CAAC;IAGjB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAG9B,SAAS,EAAE,eAAe,EAAE,CAAC;CAChC;AAOD,MAAM,WAAW,aAAa;IAE1B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAG7B,WAAW,EAAE,eAAe,EAAE,CAAC;CAClC"}

package/dist/esm/editing/TemplateChain.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TemplateChain.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateChain.js","sourceRoot":"","sources":["../../../editing/TemplateChain.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,5 @@
+import { SceneDocument, SceneEdit } from '@cratis/scene.model';
+import { EditOutcome } from './EditOutcome';
+import { EditingContext } from './EditingContext';
+export declare function applyEdit(model: SceneDocument, edit: SceneEdit, context: EditingContext): EditOutcome;
+//# sourceMappingURL=applyEdit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyEdit.d.ts","sourceRoot":"","sources":["../../../editing/applyEdit.ts"],"names":[],"mappings":"AAGA,OAAO,EAAmC,aAAa,EAAE,SAAS,EAAiB,MAAM,qBAAqB,CAAC;AAE/G,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAqDlD,wBAAgB,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,GAAG,WAAW,CASrG"}

package/dist/esm/editing/applyEdit.js

@@ -0,0 +1,81 @@
+import { DiagnosticCode, SceneEditKind } from '@cratis/scene.model';
+import { hasErrors, errorDiagnostic } from './diagnostics.js';
+import { EditSession } from './EditSession.js';
+import { applyUnexposeProperty, applyExposeProperty } from './exposureEdits.js';
+import { applyEditCollectionItem, applyReorderCollectionItem, applyRemoveCollectionItem, applyAddCollectionItem, applyResetInstanceValue, applySetInstanceValue } from './instanceEdits.js';
+import { applyChangeLayoutType } from './layoutTypeEdits.js';
+import { cloneData } from './pathAccess.js';
+import { applyResetProperty, applySetProperty } from './propertyEdits.js';
+import { applyRemoveNode, applyMoveNode, applyInsertNode } from './structureEdits.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function run(session, edit, clone, diagnostics) {
+    const handle = (handler)=>handler(session, edit, clone, diagnostics);
+    switch(edit.kind){
+        case SceneEditKind.SetProperty:
+            return handle(applySetProperty);
+        case SceneEditKind.ResetProperty:
+            return handle(applyResetProperty);
+        case SceneEditKind.ChangeLayoutType:
+            return handle(applyChangeLayoutType);
+        case SceneEditKind.InsertNode:
+            return handle(applyInsertNode);
+        case SceneEditKind.MoveNode:
+            return handle(applyMoveNode);
+        case SceneEditKind.RemoveNode:
+            return handle(applyRemoveNode);
+        case SceneEditKind.SetInstanceValue:
+            return handle(applySetInstanceValue);
+        case SceneEditKind.ResetInstanceValue:
+            return handle(applyResetInstanceValue);
+        case SceneEditKind.AddCollectionItem:
+            return handle(applyAddCollectionItem);
+        case SceneEditKind.RemoveCollectionItem:
+            return handle(applyRemoveCollectionItem);
+        case SceneEditKind.ReorderCollectionItem:
+            return handle(applyReorderCollectionItem);
+        case SceneEditKind.EditCollectionItem:
+            return handle(applyEditCollectionItem);
+        case SceneEditKind.ExposeProperty:
+            return handle(applyExposeProperty);
+        case SceneEditKind.UnexposeProperty:
+            return handle(applyUnexposeProperty);
+        default:
+            diagnostics.push(errorDiagnostic(DiagnosticCode.InvalidEdit, `'${edit.kind}' is not an edit this engine knows.`));
+    }
+}
+/**
+ * Applies one edit to a document.
+ *
+ * Pure and immutable: the document passed in is never changed, and the result is a new document. Edits are plain
+ * data, so a host can persist them and build undo and redo by keeping the documents either side. On any error the
+ * prior document comes back - the same object - together with the diagnostics, so a refused edit leaves nothing
+ * half done.
+ *
+ * What an edit may touch follows the editing scope. Nodes the scope owns are edited directly; inherited nodes are
+ * read-only, and their exposed properties are configured with the instance edits, which are checked against what
+ * each owner exposed.
+ *
+ * @param model The document to edit.
+ * @param edit What to do.
+ * @param context The catalog and the editing scope.
+ */ function applyEdit(model, edit, context) {
+    const session = new EditSession(model, context);
+    const clone = cloneData(model);
+    const diagnostics = [];
+    run(session, edit, clone, diagnostics);
+    if (hasErrors(diagnostics)) return {
+        model,
+        diagnostics,
+        applied: false
+    };
+    return {
+        model: clone,
+        diagnostics,
+        applied: true
+    };
+}
+
+export { applyEdit };
+//# sourceMappingURL=applyEdit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyEdit.js","sources":["../../../editing/applyEdit.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 { DiagnosticCode, SceneDiagnostic, SceneDocument, SceneEdit, SceneEditKind } from '@cratis/scene.model';\nimport { errorDiagnostic, hasErrors } from './diagnostics';\nimport { EditOutcome } from './EditOutcome';\nimport { EditingContext } from './EditingContext';\nimport { EditSession } from './EditSession';\nimport { applyExposeProperty, applyUnexposeProperty } from './exposureEdits';\nimport {\n    applyAddCollectionItem, applyEditCollectionItem, applyRemoveCollectionItem, applyReorderCollectionItem,\n    applyResetInstanceValue, applySetInstanceValue,\n} from './instanceEdits';\nimport { applyChangeLayoutType } from './layoutTypeEdits';\nimport { cloneData } from './pathAccess';\nimport { applyResetProperty, applySetProperty } from './propertyEdits';\nimport { applyInsertNode, applyMoveNode, applyRemoveNode } from './structureEdits';\n\ntype Handler<TEdit extends SceneEdit> = (session: EditSession, edit: TEdit, clone: SceneDocument, diagnostics: SceneDiagnostic[]) => void;\n\nfunction run(session: EditSession, edit: SceneEdit, clone: SceneDocument, diagnostics: SceneDiagnostic[]): void {\n    const handle = <TEdit extends SceneEdit>(handler: Handler<TEdit>) => handler(session, edit as TEdit, clone, diagnostics);\n\n    switch (edit.kind) {\n        case SceneEditKind.SetProperty: return handle(applySetProperty);\n        case SceneEditKind.ResetProperty: return handle(applyResetProperty);\n        case SceneEditKind.ChangeLayoutType: return handle(applyChangeLayoutType);\n        case SceneEditKind.InsertNode: return handle(applyInsertNode);\n        case SceneEditKind.MoveNode: return handle(applyMoveNode);\n        case SceneEditKind.RemoveNode: return handle(applyRemoveNode);\n        case SceneEditKind.SetInstanceValue: return handle(applySetInstanceValue);\n        case SceneEditKind.ResetInstanceValue: return handle(applyResetInstanceValue);\n        case SceneEditKind.AddCollectionItem: return handle(applyAddCollectionItem);\n        case SceneEditKind.RemoveCollectionItem: return handle(applyRemoveCollectionItem);\n        case SceneEditKind.ReorderCollectionItem: return handle(applyReorderCollectionItem);\n        case SceneEditKind.EditCollectionItem: return handle(applyEditCollectionItem);\n        case SceneEditKind.ExposeProperty: return handle(applyExposeProperty);\n        case SceneEditKind.UnexposeProperty: return handle(applyUnexposeProperty);\n        default:\n            diagnostics.push(errorDiagnostic(DiagnosticCode.InvalidEdit, `'${(edit as { kind?: string }).kind}' is not an edit this engine knows.`));\n    }\n}\n\n/**\n * Applies one edit to a document.\n *\n * Pure and immutable: the document passed in is never changed, and the result is a new document. Edits are plain\n * data, so a host can persist them and build undo and redo by keeping the documents either side. On any error the\n * prior document comes back - the same object - together with the diagnostics, so a refused edit leaves nothing\n * half done.\n *\n * What an edit may touch follows the editing scope. Nodes the scope owns are edited directly; inherited nodes are\n * read-only, and their exposed properties are configured with the instance edits, which are checked against what\n * each owner exposed.\n *\n * @param model The document to edit.\n * @param edit What to do.\n * @param context The catalog and the editing scope.\n */\nexport function applyEdit(model: SceneDocument, edit: SceneEdit, context: EditingContext): EditOutcome {\n    const session = new EditSession(model, context);\n    const clone = cloneData(model);\n    const diagnostics: SceneDiagnostic[] = [];\n\n    run(session, edit, clone, diagnostics);\n\n    if (hasErrors(diagnostics)) return { model, diagnostics, applied: false };\n    return { model: clone, diagnostics, applied: true };\n}\n"],"names":["run","session","edit","clone","diagnostics","handle","handler","kind","SceneEditKind","SetProperty","applySetProperty","ResetProperty","applyResetProperty","ChangeLayoutType","applyChangeLayoutType","InsertNode","applyInsertNode","MoveNode","applyMoveNode","RemoveNode","applyRemoveNode","SetInstanceValue","applySetInstanceValue","ResetInstanceValue","applyResetInstanceValue","AddCollectionItem","applyAddCollectionItem","RemoveCollectionItem","applyRemoveCollectionItem","ReorderCollectionItem","applyReorderCollectionItem","EditCollectionItem","applyEditCollectionItem","ExposeProperty","applyExposeProperty","UnexposeProperty","applyUnexposeProperty","push","errorDiagnostic","DiagnosticCode","InvalidEdit","applyEdit","model","context","EditSession","cloneData","hasErrors","applied"],"mappings":";;;;;;;;;;AAAA;AACA;AAmBA,SAASA,IAAIC,OAAoB,EAAEC,IAAe,EAAEC,KAAoB,EAAEC,WAA8B,EAAA;AACpG,IAAA,MAAMC,SAAS,CAA0BC,OAAAA,GAA4BA,OAAAA,CAAQL,OAAAA,EAASC,MAAeC,KAAAA,EAAOC,WAAAA,CAAAA;AAE5G,IAAA,OAAQF,KAAKK,IAAI;AACb,QAAA,KAAKC,cAAcC,WAAW;AAAE,YAAA,OAAOJ,MAAAA,CAAOK,gBAAAA,CAAAA;AAC9C,QAAA,KAAKF,cAAcG,aAAa;AAAE,YAAA,OAAON,MAAAA,CAAOO,kBAAAA,CAAAA;AAChD,QAAA,KAAKJ,cAAcK,gBAAgB;AAAE,YAAA,OAAOR,MAAAA,CAAOS,qBAAAA,CAAAA;AACnD,QAAA,KAAKN,cAAcO,UAAU;AAAE,YAAA,OAAOV,MAAAA,CAAOW,eAAAA,CAAAA;AAC7C,QAAA,KAAKR,cAAcS,QAAQ;AAAE,YAAA,OAAOZ,MAAAA,CAAOa,aAAAA,CAAAA;AAC3C,QAAA,KAAKV,cAAcW,UAAU;AAAE,YAAA,OAAOd,MAAAA,CAAOe,eAAAA,CAAAA;AAC7C,QAAA,KAAKZ,cAAca,gBAAgB;AAAE,YAAA,OAAOhB,MAAAA,CAAOiB,qBAAAA,CAAAA;AACnD,QAAA,KAAKd,cAAce,kBAAkB;AAAE,YAAA,OAAOlB,MAAAA,CAAOmB,uBAAAA,CAAAA;AACrD,QAAA,KAAKhB,cAAciB,iBAAiB;AAAE,YAAA,OAAOpB,MAAAA,CAAOqB,sBAAAA,CAAAA;AACpD,QAAA,KAAKlB,cAAcmB,oBAAoB;AAAE,YAAA,OAAOtB,MAAAA,CAAOuB,yBAAAA,CAAAA;AACvD,QAAA,KAAKpB,cAAcqB,qBAAqB;AAAE,YAAA,OAAOxB,MAAAA,CAAOyB,0BAAAA,CAAAA;AACxD,QAAA,KAAKtB,cAAcuB,kBAAkB;AAAE,YAAA,OAAO1B,MAAAA,CAAO2B,uBAAAA,CAAAA;AACrD,QAAA,KAAKxB,cAAcyB,cAAc;AAAE,YAAA,OAAO5B,MAAAA,CAAO6B,mBAAAA,CAAAA;AACjD,QAAA,KAAK1B,cAAc2B,gBAAgB;AAAE,YAAA,OAAO9B,MAAAA,CAAO+B,qBAAAA,CAAAA;AACnD,QAAA;AACIhC,YAAAA,WAAAA,CAAYiC,IAAI,CAACC,eAAAA,CAAgBC,cAAAA,CAAeC,WAAW,EAAE,CAAC,CAAC,EAAE,IAACtC,CAA2BK,IAAI,CAAC,mCAAmC,CAAC,CAAA,CAAA;AAC9I;AACJ;AAEA;;;;;;;;;;;;;;;AAeC,IACM,SAASkC,SAAAA,CAAUC,KAAoB,EAAExC,IAAe,EAAEyC,OAAuB,EAAA;IACpF,MAAM1C,OAAAA,GAAU,IAAI2C,WAAAA,CAAYF,KAAAA,EAAOC,OAAAA,CAAAA;AACvC,IAAA,MAAMxC,QAAQ0C,SAAAA,CAAUH,KAAAA,CAAAA;AACxB,IAAA,MAAMtC,cAAiC,EAAE;IAEzCJ,GAAAA,CAAIC,OAAAA,EAASC,MAAMC,KAAAA,EAAOC,WAAAA,CAAAA;IAE1B,IAAI0C,SAAAA,CAAU1C,cAAc,OAAO;AAAEsC,QAAAA,KAAAA;AAAOtC,QAAAA,WAAAA;QAAa2C,OAAAA,EAAS;AAAM,KAAA;IACxE,OAAO;QAAEL,KAAAA,EAAOvC,KAAAA;AAAOC,QAAAA,WAAAA;QAAa2C,OAAAA,EAAS;AAAK,KAAA;AACtD;;"}

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

@@ -0,0 +1,3 @@
+import { EffectiveConfiguration, SceneElement } from '@cratis/scene.model';
+export declare function applyEffectiveConfiguration(element: SceneElement, configuration: EffectiveConfiguration): SceneElement;
+//# sourceMappingURL=applyEffectiveConfiguration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyEffectiveConfiguration.d.ts","sourceRoot":"","sources":["../../../editing/applyEffectiveConfiguration.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkB,sBAAsB,EAA0C,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAcnI,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,GAAG,YAAY,CAmCtH"}

package/dist/esm/editing/applyEffectiveConfiguration.js

@@ -0,0 +1,60 @@
+import { isExternalComponent, isContentControl, isItemsControl, isPanel } from '../elementKind.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Returns the element tree a renderer should draw once effective configuration is applied: each configurable
+ * component carries its resolved properties.
+ *
+ * Pure, and structure-sharing - an element with nothing to change comes back as the same object, so a renderer
+ * that memoizes on identity does not redraw what did not change. There is no design-time flag here or anywhere
+ * downstream: a screen being edited and a screen being played go through this same function.
+ *
+ * @param element The element tree from the template or screen.
+ * @param configuration What {@link resolveEffectiveConfiguration} produced for the chain the tree sits in.
+ */ function applyEffectiveConfiguration(element, configuration) {
+    if (isExternalComponent(element)) {
+        const resolved = configuration.components.find((candidate)=>candidate.component === element.id);
+        let changed = resolved !== undefined;
+        const slots = {};
+        for (const [name, children] of Object.entries(element.slots)){
+            const mapped = children.map((child)=>applyEffectiveConfiguration(child, configuration));
+            if (mapped.some((child, index)=>child !== children[index])) changed = true;
+            slots[name] = mapped;
+        }
+        const updated = {
+            ...element,
+            properties: resolved?.properties ?? element.properties,
+            slots
+        };
+        return changed ? updated : element;
+    }
+    if (isContentControl(element)) {
+        const content = applyEffectiveConfiguration(element.content, configuration);
+        const updated = {
+            ...element,
+            content
+        };
+        return content === element.content ? element : updated;
+    }
+    if (isItemsControl(element)) {
+        const itemTemplate = applyEffectiveConfiguration(element.itemTemplate, configuration);
+        const updated = {
+            ...element,
+            itemTemplate
+        };
+        return itemTemplate === element.itemTemplate ? element : updated;
+    }
+    if (isPanel(element)) {
+        const children = element.children.map((child)=>applyEffectiveConfiguration(child, configuration));
+        const updated = {
+            ...element,
+            children
+        };
+        return children.some((child, index)=>child !== element.children[index]) ? updated : element;
+    }
+    return element;
+}
+
+export { applyEffectiveConfiguration };
+//# sourceMappingURL=applyEffectiveConfiguration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"applyEffectiveConfiguration.js","sources":["../../../editing/applyEffectiveConfiguration.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 { ContentControl, EffectiveConfiguration, ExternalComponent, ItemsControl, Panel, SceneElement } from '@cratis/scene.model';\nimport { isContentControl, isExternalComponent, isItemsControl, isPanel } from '../elementKind';\n\n/**\n * Returns the element tree a renderer should draw once effective configuration is applied: each configurable\n * component carries its resolved properties.\n *\n * Pure, and structure-sharing - an element with nothing to change comes back as the same object, so a renderer\n * that memoizes on identity does not redraw what did not change. There is no design-time flag here or anywhere\n * downstream: a screen being edited and a screen being played go through this same function.\n *\n * @param element The element tree from the template or screen.\n * @param configuration What {@link resolveEffectiveConfiguration} produced for the chain the tree sits in.\n */\nexport function applyEffectiveConfiguration(element: SceneElement, configuration: EffectiveConfiguration): SceneElement {\n    if (isExternalComponent(element)) {\n        const resolved = configuration.components.find(candidate => candidate.component === element.id);\n        let changed = resolved !== undefined;\n\n        const slots: typeof element.slots = {};\n        for (const [name, children] of Object.entries(element.slots)) {\n            const mapped = children.map(child => applyEffectiveConfiguration(child, configuration));\n            if (mapped.some((child, index) => child !== children[index])) changed = true;\n            slots[name] = mapped;\n        }\n\n        const updated: ExternalComponent = { ...element, properties: resolved?.properties ?? element.properties, slots };\n        return changed ? updated : element;\n    }\n\n    if (isContentControl(element)) {\n        const content = applyEffectiveConfiguration(element.content, configuration);\n        const updated: ContentControl = { ...element, content };\n        return content === element.content ? element : updated;\n    }\n\n    if (isItemsControl(element)) {\n        const itemTemplate = applyEffectiveConfiguration(element.itemTemplate, configuration);\n        const updated: ItemsControl = { ...element, itemTemplate };\n        return itemTemplate === element.itemTemplate ? element : updated;\n    }\n\n    if (isPanel(element)) {\n        const children = element.children.map(child => applyEffectiveConfiguration(child, configuration));\n        const updated: Panel = { ...element, children };\n        return children.some((child, index) => child !== element.children[index]) ? updated : element;\n    }\n\n    return element;\n}\n"],"names":["applyEffectiveConfiguration","element","configuration","isExternalComponent","resolved","components","find","candidate","component","id","changed","undefined","slots","name","children","Object","entries","mapped","map","child","some","index","updated","properties","isContentControl","content","isItemsControl","itemTemplate","isPanel"],"mappings":";;AAAA;AACA;AAKA;;;;;;;;;;AAUC,IACM,SAASA,2BAAAA,CAA4BC,OAAqB,EAAEC,aAAqC,EAAA;AACpG,IAAA,IAAIC,oBAAoBF,OAAAA,CAAAA,EAAU;AAC9B,QAAA,MAAMG,QAAAA,GAAWF,aAAAA,CAAcG,UAAU,CAACC,IAAI,CAACC,CAAAA,SAAAA,GAAaA,SAAAA,CAAUC,SAAS,KAAKP,OAAAA,CAAQQ,EAAE,CAAA;AAC9F,QAAA,IAAIC,UAAUN,QAAAA,KAAaO,SAAAA;AAE3B,QAAA,MAAMC,QAA8B,EAAC;QACrC,KAAK,MAAM,CAACC,IAAAA,EAAMC,QAAAA,CAAS,IAAIC,OAAOC,OAAO,CAACf,OAAAA,CAAQW,KAAK,CAAA,CAAG;AAC1D,YAAA,MAAMK,SAASH,QAAAA,CAASI,GAAG,CAACC,CAAAA,KAAAA,GAASnB,4BAA4BmB,KAAAA,EAAOjB,aAAAA,CAAAA,CAAAA;YACxE,IAAIe,MAAAA,CAAOG,IAAI,CAAC,CAACD,KAAAA,EAAOE,KAAAA,GAAUF,KAAAA,KAAUL,QAAQ,CAACO,KAAAA,CAAM,CAAA,EAAGX,OAAAA,GAAU,IAAA;YACxEE,KAAK,CAACC,KAAK,GAAGI,MAAAA;AAClB,QAAA;AAEA,QAAA,MAAMK,OAAAA,GAA6B;AAAE,YAAA,GAAGrB,OAAO;YAAEsB,UAAAA,EAAYnB,QAAAA,EAAUmB,UAAAA,IAActB,OAAAA,CAAQsB,UAAU;AAAEX,YAAAA;AAAM,SAAA;AAC/G,QAAA,OAAOF,UAAUY,OAAAA,GAAUrB,OAAAA;AAC/B,IAAA;AAEA,IAAA,IAAIuB,iBAAiBvB,OAAAA,CAAAA,EAAU;AAC3B,QAAA,MAAMwB,OAAAA,GAAUzB,2BAAAA,CAA4BC,OAAAA,CAAQwB,OAAO,EAAEvB,aAAAA,CAAAA;AAC7D,QAAA,MAAMoB,OAAAA,GAA0B;AAAE,YAAA,GAAGrB,OAAO;AAAEwB,YAAAA;AAAQ,SAAA;AACtD,QAAA,OAAOA,OAAAA,KAAYxB,OAAAA,CAAQwB,OAAO,GAAGxB,OAAAA,GAAUqB,OAAAA;AACnD,IAAA;AAEA,IAAA,IAAII,eAAezB,OAAAA,CAAAA,EAAU;AACzB,QAAA,MAAM0B,YAAAA,GAAe3B,2BAAAA,CAA4BC,OAAAA,CAAQ0B,YAAY,EAAEzB,aAAAA,CAAAA;AACvE,QAAA,MAAMoB,OAAAA,GAAwB;AAAE,YAAA,GAAGrB,OAAO;AAAE0B,YAAAA;AAAa,SAAA;AACzD,QAAA,OAAOA,YAAAA,KAAiB1B,OAAAA,CAAQ0B,YAAY,GAAG1B,OAAAA,GAAUqB,OAAAA;AAC7D,IAAA;AAEA,IAAA,IAAIM,QAAQ3B,OAAAA,CAAAA,EAAU;QAClB,MAAMa,QAAAA,GAAWb,QAAQa,QAAQ,CAACI,GAAG,CAACC,CAAAA,KAAAA,GAASnB,2BAAAA,CAA4BmB,KAAAA,EAAOjB,aAAAA,CAAAA,CAAAA;AAClF,QAAA,MAAMoB,OAAAA,GAAiB;AAAE,YAAA,GAAGrB,OAAO;AAAEa,YAAAA;AAAS,SAAA;AAC9C,QAAA,OAAOA,QAAAA,CAASM,IAAI,CAAC,CAACD,KAAAA,EAAOE,KAAAA,GAAUF,KAAAA,KAAUlB,OAAAA,CAAQa,QAAQ,CAACO,KAAAA,CAAM,CAAA,GAAIC,OAAAA,GAAUrB,OAAAA;AAC1F,IAAA;IAEA,OAAOA,OAAAA;AACX;;"}

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

@@ -0,0 +1,3 @@
+import { ExternalComponent } from '@cratis/scene.model';
+export declare function collectComponents(owner: unknown): ExternalComponent[];
+//# sourceMappingURL=collectComponents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectComponents.d.ts","sourceRoot":"","sources":["../../../editing/collectComponents.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAgBxD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAgBrE"}

package/dist/esm/editing/collectComponents.js

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function isExternalComponentValue(value) {
+    const candidate = value;
+    return typeof candidate.id === 'string' && typeof candidate.componentName === 'string' && candidate.properties !== null && typeof candidate.properties === 'object';
+}
+/**
+ * Finds every external component anywhere inside a layout, template, dialog template or screen, each once by id.
+ *
+ * It scans the value's structure rather than following a fixed list of properties, so a component is found
+ * wherever the model keeps it - slot content, a flow leaf, a freeform placement, a panel's children, another
+ * component's slot. A freeform arrangement repeats an element across its size-class variants; the first copy
+ * is the one returned.
+ */ function collectComponents(owner) {
+    const found = new Map();
+    const visit = (value)=>{
+        if (value === null || typeof value !== 'object') return;
+        if (Array.isArray(value)) {
+            for (const item of value)visit(item);
+            return;
+        }
+        if (isExternalComponentValue(value) && !found.has(value.id)) found.set(value.id, value);
+        for (const child of Object.values(value))visit(child);
+    };
+    visit(owner);
+    return [
+        ...found.values()
+    ];
+}
+
+export { collectComponents };
+//# sourceMappingURL=collectComponents.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectComponents.js","sources":["../../../editing/collectComponents.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 { ExternalComponent } from '@cratis/scene.model';\n\nfunction isExternalComponentValue(value: object): value is ExternalComponent {\n    const candidate = value as Partial<ExternalComponent>;\n    return typeof candidate.id === 'string' && typeof candidate.componentName === 'string'\n        && candidate.properties !== null && typeof candidate.properties === 'object';\n}\n\n/**\n * Finds every external component anywhere inside a layout, template, dialog template or screen, each once by id.\n *\n * It scans the value's structure rather than following a fixed list of properties, so a component is found\n * wherever the model keeps it - slot content, a flow leaf, a freeform placement, a panel's children, another\n * component's slot. A freeform arrangement repeats an element across its size-class variants; the first copy\n * is the one returned.\n */\nexport function collectComponents(owner: unknown): ExternalComponent[] {\n    const found = new Map<string, ExternalComponent>();\n\n    const visit = (value: unknown): void => {\n        if (value === null || typeof value !== 'object') return;\n        if (Array.isArray(value)) {\n            for (const item of value) visit(item);\n            return;\n        }\n\n        if (isExternalComponentValue(value) && !found.has(value.id)) found.set(value.id, value);\n        for (const child of Object.values(value)) visit(child);\n    };\n\n    visit(owner);\n    return [...found.values()];\n}\n"],"names":["isExternalComponentValue","value","candidate","id","componentName","properties","collectComponents","owner","found","Map","visit","Array","isArray","item","has","set","child","Object","values"],"mappings":"AAAA;AACA;AAIA,SAASA,yBAAyBC,KAAa,EAAA;AAC3C,IAAA,MAAMC,SAAAA,GAAYD,KAAAA;AAClB,IAAA,OAAO,OAAOC,SAAAA,CAAUC,EAAE,KAAK,QAAA,IAAY,OAAOD,SAAAA,CAAUE,aAAa,KAAK,QAAA,IACvEF,UAAUG,UAAU,KAAK,QAAQ,OAAOH,SAAAA,CAAUG,UAAU,KAAK,QAAA;AAC5E;AAEA;;;;;;;IAQO,SAASC,iBAAAA,CAAkBC,KAAc,EAAA;AAC5C,IAAA,MAAMC,QAAQ,IAAIC,GAAAA,EAAAA;AAElB,IAAA,MAAMC,QAAQ,CAACT,KAAAA,GAAAA;AACX,QAAA,IAAIA,KAAAA,KAAU,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAA,EAAU;QACjD,IAAIU,KAAAA,CAAMC,OAAO,CAACX,KAAAA,CAAAA,EAAQ;YACtB,KAAK,MAAMY,IAAAA,IAAQZ,KAAAA,CAAOS,KAAAA,CAAMG,IAAAA,CAAAA;AAChC,YAAA;AACJ,QAAA;AAEA,QAAA,IAAIb,wBAAAA,CAAyBC,KAAAA,CAAAA,IAAU,CAACO,KAAAA,CAAMM,GAAG,CAACb,KAAAA,CAAME,EAAE,CAAA,EAAGK,KAAAA,CAAMO,GAAG,CAACd,KAAAA,CAAME,EAAE,EAAEF,KAAAA,CAAAA;AACjF,QAAA,KAAK,MAAMe,KAAAA,IAASC,MAAAA,CAAOC,MAAM,CAACjB,OAAQS,KAAAA,CAAMM,KAAAA,CAAAA;AACpD,IAAA,CAAA;IAEAN,KAAAA,CAAMH,KAAAA,CAAAA;IACN,OAAO;AAAIC,QAAAA,GAAAA,KAAAA,CAAMU,MAAM;AAAG,KAAA;AAC9B;;"}

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"}