@cratis/scene.engine 4.2.0 → 4.3.0

package/dist/cjs/editing/validateValue.js

@@ -0,0 +1,114 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+/**
+ * Checks a value against a property descriptor.
+ *
+ * @param descriptor The property the value is for.
+ * @param value The value to check. `undefined` means "not set", which is fine unless the property is required.
+ * @returns The reason the value is not acceptable, or `undefined` when it is.
+ */ function validateValue(descriptor, value) {
+    const constraints = descriptor.constraints ?? {};
+    if (value === undefined || value === null) {
+        return constraints.required ? 'a value is required' : undefined;
+    }
+    switch(descriptor.valueType){
+        case scene_model.PropertyValueType.String:
+            {
+                if (typeof value !== 'string') return 'expected a string';
+                if (constraints.minimumLength !== undefined && value.length < constraints.minimumLength) return `must be at least ${constraints.minimumLength} characters`;
+                if (constraints.maximumLength !== undefined && value.length > constraints.maximumLength) return `must be at most ${constraints.maximumLength} characters`;
+                if (constraints.pattern !== undefined && !new RegExp(`^(?:${constraints.pattern})$`).test(value)) return `must match ${constraints.pattern}`;
+                return undefined;
+            }
+        case scene_model.PropertyValueType.Number:
+            {
+                if (typeof value !== 'number' || !Number.isFinite(value)) return 'expected a number';
+                if (constraints.integer && !Number.isInteger(value)) return 'expected a whole number';
+                if (constraints.minimum !== undefined && value < constraints.minimum) return `must be at least ${constraints.minimum}`;
+                if (constraints.maximum !== undefined && value > constraints.maximum) return `must be at most ${constraints.maximum}`;
+                return undefined;
+            }
+        case scene_model.PropertyValueType.Boolean:
+            return typeof value === 'boolean' ? undefined : 'expected true or false';
+        case scene_model.PropertyValueType.Enum:
+            return (descriptor.choices ?? []).some((choice)=>choice.value === value) ? undefined : 'not one of the allowed choices';
+        case scene_model.PropertyValueType.Icon:
+            if (!isRecord(value) || !isNonEmptyString(value.library) || !isNonEmptyString(value.key)) return 'expected an icon reference with a library and a key';
+            return value.variant === undefined || typeof value.variant === 'string' ? undefined : 'the icon variant must be a string';
+        case scene_model.PropertyValueType.Destination:
+            if (!isRecord(value) || !isNonEmptyString(value.screen)) return 'expected a destination naming a screen';
+            return value.routeParameterBindings === undefined || isRecord(value.routeParameterBindings) ? undefined : 'routeParameterBindings must be an object';
+        case scene_model.PropertyValueType.QueryReference:
+            if (isNonEmptyString(value)) return undefined;
+            if (!isRecord(value) || !isNonEmptyString(value.queryId) || !isNonEmptyString(value.query)) return 'expected a query name or a query binding';
+            return Array.isArray(value.arguments) && Array.isArray(value.results) ? undefined : 'a query binding needs arguments and results lists';
+        case scene_model.PropertyValueType.Collection:
+            return validateCollection(descriptor, value);
+        default:
+            return isRecord(value) || Array.isArray(value) ? undefined : 'expected a structured value';
+    }
+}
+function validateCollection(descriptor, value) {
+    if (!Array.isArray(value)) return 'expected a list';
+    const constraints = descriptor.constraints ?? {};
+    if (constraints.minimumItems !== undefined && value.length < constraints.minimumItems) return `needs at least ${constraints.minimumItems} items`;
+    if (constraints.maximumItems !== undefined && value.length > constraints.maximumItems) return `allows at most ${constraints.maximumItems} items`;
+    const identities = new Set();
+    for (const item of value){
+        if (!isRecord(item) || !isNonEmptyString(item.id)) return 'every item needs an id';
+        if (identities.has(item.id)) return `the item id '${item.id}' is used twice`;
+        identities.add(item.id);
+        const { id: _identity, ...values } = item;
+        const problem = validateItemValues(descriptor.item, values).at(0);
+        if (problem) return `item '${item.id}': ${problem.field} ${problem.problem}`;
+    }
+    return undefined;
+}
+/**
+ * Checks a collection item's field values against the collection's item descriptor.
+ *
+ * @param itemDescriptor What the items look like.
+ * @param values The item's field values, keyed by field path.
+ * @returns Every field that is unknown or has an unacceptable value.
+ */ function validateItemValues(itemDescriptor, values) {
+    const fields = itemDescriptor?.properties ?? [];
+    const problems = [];
+    for (const [field, fieldValue] of Object.entries(values)){
+        const fieldDescriptor = fields.find((candidate)=>candidate.path === field);
+        if (!fieldDescriptor) {
+            problems.push({
+                field,
+                problem: 'is not a field of this collection\'s items'
+            });
+            continue;
+        }
+        const problem = validateValue(fieldDescriptor, fieldValue);
+        if (problem) problems.push({
+            field,
+            problem
+        });
+    }
+    for (const fieldDescriptor of fields){
+        if (fieldDescriptor.constraints?.required && values[fieldDescriptor.path] === undefined) {
+            problems.push({
+                field: fieldDescriptor.path,
+                problem: 'a value is required'
+            });
+        }
+    }
+    return problems;
+}
+
+exports.validateItemValues = validateItemValues;
+exports.validateValue = validateValue;
+//# sourceMappingURL=validateValue.js.map

package/dist/cjs/editing/validateValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateValue.js","sources":["../../../editing/validateValue.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, PropertyDescriptor, PropertyValueType } from '@cratis/scene.model';\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isNonEmptyString(value: unknown): value is string {\n    return typeof value === 'string' && value.length > 0;\n}\n\n/**\n * Checks a value against a property descriptor.\n *\n * @param descriptor The property the value is for.\n * @param value The value to check. `undefined` means \"not set\", which is fine unless the property is required.\n * @returns The reason the value is not acceptable, or `undefined` when it is.\n */\nexport function validateValue(descriptor: PropertyDescriptor, value: unknown): string | undefined {\n    const constraints = descriptor.constraints ?? {};\n    if (value === undefined || value === null) {\n        return constraints.required ? 'a value is required' : undefined;\n    }\n\n    switch (descriptor.valueType) {\n        case PropertyValueType.String: {\n            if (typeof value !== 'string') return 'expected a string';\n            if (constraints.minimumLength !== undefined && value.length < constraints.minimumLength) return `must be at least ${constraints.minimumLength} characters`;\n            if (constraints.maximumLength !== undefined && value.length > constraints.maximumLength) return `must be at most ${constraints.maximumLength} characters`;\n            if (constraints.pattern !== undefined && !new RegExp(`^(?:${constraints.pattern})$`).test(value)) return `must match ${constraints.pattern}`;\n            return undefined;\n        }\n\n        case PropertyValueType.Number: {\n            if (typeof value !== 'number' || !Number.isFinite(value)) return 'expected a number';\n            if (constraints.integer && !Number.isInteger(value)) return 'expected a whole number';\n            if (constraints.minimum !== undefined && value < constraints.minimum) return `must be at least ${constraints.minimum}`;\n            if (constraints.maximum !== undefined && value > constraints.maximum) return `must be at most ${constraints.maximum}`;\n            return undefined;\n        }\n\n        case PropertyValueType.Boolean:\n            return typeof value === 'boolean' ? undefined : 'expected true or false';\n\n        case PropertyValueType.Enum:\n            return (descriptor.choices ?? []).some(choice => choice.value === value) ? undefined : 'not one of the allowed choices';\n\n        case PropertyValueType.Icon:\n            if (!isRecord(value) || !isNonEmptyString(value.library) || !isNonEmptyString(value.key)) return 'expected an icon reference with a library and a key';\n            return value.variant === undefined || typeof value.variant === 'string' ? undefined : 'the icon variant must be a string';\n\n        case PropertyValueType.Destination:\n            if (!isRecord(value) || !isNonEmptyString(value.screen)) return 'expected a destination naming a screen';\n            return value.routeParameterBindings === undefined || isRecord(value.routeParameterBindings)\n                ? undefined\n                : 'routeParameterBindings must be an object';\n\n        case PropertyValueType.QueryReference:\n            if (isNonEmptyString(value)) return undefined;\n            if (!isRecord(value) || !isNonEmptyString(value.queryId) || !isNonEmptyString(value.query)) return 'expected a query name or a query binding';\n            return Array.isArray(value.arguments) && Array.isArray(value.results) ? undefined : 'a query binding needs arguments and results lists';\n\n        case PropertyValueType.Collection:\n            return validateCollection(descriptor, value);\n\n        default:\n            return isRecord(value) || Array.isArray(value) ? undefined : 'expected a structured value';\n    }\n}\n\nfunction validateCollection(descriptor: PropertyDescriptor, value: unknown): string | undefined {\n    if (!Array.isArray(value)) return 'expected a list';\n    const constraints = descriptor.constraints ?? {};\n    if (constraints.minimumItems !== undefined && value.length < constraints.minimumItems) return `needs at least ${constraints.minimumItems} items`;\n    if (constraints.maximumItems !== undefined && value.length > constraints.maximumItems) return `allows at most ${constraints.maximumItems} items`;\n\n    const identities = new Set<string>();\n    for (const item of value) {\n        if (!isRecord(item) || !isNonEmptyString(item.id)) return 'every item needs an id';\n        if (identities.has(item.id)) return `the item id '${item.id}' is used twice`;\n        identities.add(item.id);\n\n        const { id: _identity, ...values } = item;\n        const problem = validateItemValues(descriptor.item, values).at(0);\n        if (problem) return `item '${item.id}': ${problem.field} ${problem.problem}`;\n    }\n\n    return undefined;\n}\n\n/**\n * One field of a collection item that does not fit its descriptor.\n */\nexport interface ItemFieldProblem {\n    field: string;\n    problem: string;\n}\n\n/**\n * Checks a collection item's field values against the collection's item descriptor.\n *\n * @param itemDescriptor What the items look like.\n * @param values The item's field values, keyed by field path.\n * @returns Every field that is unknown or has an unacceptable value.\n */\nexport function validateItemValues(itemDescriptor: CollectionItemDescriptor | undefined, values: Record<string, unknown>): ItemFieldProblem[] {\n    const fields = itemDescriptor?.properties ?? [];\n    const problems: ItemFieldProblem[] = [];\n\n    for (const [field, fieldValue] of Object.entries(values)) {\n        const fieldDescriptor = fields.find(candidate => candidate.path === field);\n        if (!fieldDescriptor) {\n            problems.push({ field, problem: 'is not a field of this collection\\'s items' });\n            continue;\n        }\n\n        const problem = validateValue(fieldDescriptor, fieldValue);\n        if (problem) problems.push({ field, problem });\n    }\n\n    for (const fieldDescriptor of fields) {\n        if (fieldDescriptor.constraints?.required && values[fieldDescriptor.path] === undefined) {\n            problems.push({ field: fieldDescriptor.path, problem: 'a value is required' });\n        }\n    }\n\n    return problems;\n}\n"],"names":["isRecord","value","Array","isArray","isNonEmptyString","length","validateValue","descriptor","constraints","undefined","required","valueType","PropertyValueType","String","minimumLength","maximumLength","pattern","RegExp","test","Number","isFinite","integer","isInteger","minimum","maximum","Boolean","Enum","choices","some","choice","Icon","library","key","variant","Destination","screen","routeParameterBindings","QueryReference","queryId","query","arguments","results","Collection","validateCollection","minimumItems","maximumItems","identities","Set","item","id","has","add","_identity","values","problem","validateItemValues","at","field","itemDescriptor","fields","properties","problems","fieldValue","Object","entries","fieldDescriptor","find","candidate","path","push"],"mappings":"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"}

package/dist/cjs/index.js

@@ -21,6 +21,20 @@ 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');
 
 
 
@@ -75,4 +89,41 @@ 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;
 //# 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,8 @@
+import { EditingScope, QueryCandidate } from '@cratis/scene.model';
+import { DescriptorCatalog } from './DescriptorCatalog';
+export interface EditingContext {
+    catalog: DescriptorCatalog;
+    scope: EditingScope;
+    queryCandidates?: QueryCandidate[];
+}
+//# 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,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"}

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