@plaudit/gutenberg-api-extensions 2.82.0 → 2.84.0

package/dist/blocks/data-controller/trigger-handlers.d.ts

@@ -0,0 +1,140 @@
+import { ActionReducerMapBuilder } from "@reduxjs/toolkit";
+import type { Draft } from "immer";
+import type { NodePath } from "../simple-native-property-api";
+import type { DCNode, DCStoreState } from "../data-controller";
+export declare const triggerHandlers: {
+    readonly validation: {
+        addAction: (action: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<any[], {
+            path: NodePath;
+        }, string, never, {
+            inBatch?: boolean;
+        }>) => number;
+        isInstance: (action: any) => action is {
+            payload: {
+                path: NodePath;
+            };
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        shouldTrigger: (action: any) => action is {
+            payload: {
+                path: NodePath;
+            };
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        attachTo: (builder: ActionReducerMapBuilder<DCStoreState>) => Omit<ActionReducerMapBuilder<DCStoreState>, "addCase" | "addAsyncThunk">;
+    };
+    readonly conditionChecks: {
+        addAction: (action: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<any[], {}, string, never, {
+            inBatch?: boolean;
+        }>) => number;
+        isInstance: (action: any) => action is {
+            payload: {};
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        shouldTrigger: (action: any) => action is {
+            payload: {};
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        attachTo: (builder: ActionReducerMapBuilder<DCStoreState>) => Omit<ActionReducerMapBuilder<DCStoreState>, "addCase" | "addAsyncThunk">;
+    };
+    readonly changedByManagedControl: {
+        addAction: (action: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<any[], {}, string, never, {
+            inBatch?: boolean;
+        }>) => number;
+        isInstance: (action: any) => action is {
+            payload: {};
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        shouldTrigger: (action: any) => action is {
+            payload: {};
+            type: string;
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        } & {
+            meta: {
+                inBatch?: boolean;
+            };
+        };
+        attachTo: (builder: ActionReducerMapBuilder<DCStoreState>) => Omit<ActionReducerMapBuilder<DCStoreState>, "addCase" | "addAsyncThunk">;
+    };
+};
+type CommonTriggers = {
+    changedByManagedControl?: boolean;
+    conditionChecks?: boolean;
+};
+type BaseActionMeta<ADDITIONAL_TRIGGERS extends {
+    [K in Exclude<keyof typeof triggerHandlers, keyof CommonTriggers>]?: boolean;
+}> = {
+    inBatch?: boolean;
+    triggers: CommonTriggers & ADDITIONAL_TRIGGERS;
+};
+export type GlobalActionMeta = BaseActionMeta<{}>;
+export declare function createGlobalAction<P extends {
+    [key: Exclude<string, 'type' | 'inBatch'>]: any;
+} = {}, T extends string = string>(type: T, triggers?: GlobalActionMeta['triggers']): import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: P, inBatch?: boolean | undefined], P, T, never, {
+    inBatch: boolean;
+    triggers: CommonTriggers;
+}>;
+export type PathedActionMeta = BaseActionMeta<{
+    validation?: boolean;
+}>;
+export declare function createPathedAction<P extends {
+    [key: Exclude<string, 'type' | 'path' | 'inBatch'>]: any;
+} = {}, T extends string = string>(type: T, triggers?: PathedActionMeta['triggers']): import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[payload: P & {
+    path: NodePath;
+}, inBatch?: boolean | undefined], P & {
+    path: NodePath;
+}, T, never, {
+    inBatch: boolean;
+    triggers: CommonTriggers & {
+        validation?: boolean;
+    };
+}>;
+export declare function validateNode(path: NodePath, draft: Draft<DCStoreState>): void;
+/**
+ * @return true iff the validation state changed
+ */
+export declare function validateFoundNode(node: DCNode, path: NodePath, draft: Draft<DCStoreState>): boolean;
+export {};

package/dist/blocks/data-controller/trigger-handlers.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerHandlers = void 0;
+exports.createGlobalAction = createGlobalAction;
+exports.createPathedAction = createPathedAction;
+exports.validateNode = validateNode;
+exports.validateFoundNode = validateFoundNode;
+const toolkit_1 = require("@reduxjs/toolkit");
+const PathError_1 = require("../PathError");
+const simple_native_property_internal_shared_1 = require("../simple-native-property-internal-shared");
+const conditions_1 = require("../conditions");
+const utils_1 = require("./utils");
+function makeTriggerHandler(reducer) {
+    const triggeringActionCreators = [];
+    const isInstance = (action) => {
+        return triggeringActionCreators.some(actionCreator => actionCreator.match(action));
+    };
+    const shouldTrigger = (action) => isInstance(action) && (action.meta.inBatch !== true);
+    return {
+        addAction: (action) => triggeringActionCreators.push(action), isInstance, shouldTrigger,
+        attachTo: (builder) => builder.addMatcher(shouldTrigger, reducer)
+    };
+}
+exports.triggerHandlers = {
+    validation: makeTriggerHandler((state, { payload: { path } }) => {
+        validateNode(path, state);
+        return state;
+    }),
+    conditionChecks: makeTriggerHandler(performConditionChecks),
+    changedByManagedControl: makeTriggerHandler(state => {
+        state.changedByManagedControl = true;
+    }),
+};
+function createGlobalAction(type, triggers = {}) {
+    const res = (0, toolkit_1.createAction)(type, (payload, inBatch = false) => ({ payload, meta: { inBatch, triggers } }));
+    for (const [trigger, enabled] of Object.entries(triggers)) {
+        if (enabled) {
+            exports.triggerHandlers[trigger].addAction(res);
+        }
+    }
+    return res;
+}
+function createPathedAction(type, triggers = {}) {
+    const res = (0, toolkit_1.createAction)(type, (payload, inBatch = false) => ({ payload, meta: { inBatch, triggers } }));
+    for (const [trigger, enabled] of Object.entries(triggers)) {
+        if (enabled) {
+            exports.triggerHandlers[trigger].addAction(res);
+        }
+    }
+    return res;
+}
+function validateNode(path, draft) {
+    if (validateFoundNode((0, utils_1.walkToNode)(draft.treeRoot, path), path, draft)) {
+        draft.rerenderTrigger = draft.rerenderTrigger + 1;
+    }
+}
+/**
+ * @return true iff the validation state changed
+ */
+function validateFoundNode(node, path, draft) {
+    const definition = node.definition;
+    if (definition) {
+        let validationError;
+        const value = (0, utils_1.getOptionalValue)(path, draft);
+        if (definition.required && !value) {
+            validationError = `"${definition.label || definition.name}" is required.`;
+        }
+        else {
+            validationError = definition.validator?.(value) ?? "";
+        }
+        if (node.validationError !== validationError) {
+            node.validationError = validationError;
+            return true;
+        }
+    }
+    return false;
+}
+function performConditionChecks(state) {
+    const blockClientId = state.blockClientId;
+    const propertyValueResolverBuilder = path => propertyPath => (0, conditions_1.resolveValueForCondition)(propertyPath, path, blockClientId, property => (0, utils_1.getDataStore)(property, state, false));
+    (0, utils_1.applyToTree)(state.treeRoot, (node, path) => {
+        const condition = node.condition;
+        if (condition === undefined) {
+            node.rendered = true;
+            return utils_1.TreeMutatorResult.CONTINUE;
+        }
+        else {
+            const newRendered = (0, conditions_1.testCondition)(condition, propertyValueResolverBuilder(path));
+            if (newRendered !== node.rendered) {
+                const dataStore = (0, utils_1.getDataStore)(path[0], state);
+                let currentValue;
+                try {
+                    currentValue = (0, utils_1.walkToNodeInValue)(dataStore.getValue(path[0]), path);
+                }
+                catch (e) {
+                    if (!(e instanceof PathError_1.PathError)) {
+                        throw e;
+                    }
+                    currentValue = undefined;
+                }
+                if (!newRendered) {
+                    // Create a backup if we are transitioning from rendered -> unrendered
+                    node.backup = currentValue;
+                    (0, utils_1.removeValueFromBackingDataStore)(dataStore, path);
+                }
+                else if (currentValue === undefined) {
+                    // Restore from backup if we are transitioning from unrendered -> rendered
+                    const stateNode = (0, utils_1.walkToNode)(state.treeRoot, path);
+                    (0, utils_1.writeValueToBackingDataStore)(dataStore, path, stateNode.backup ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(stateNode.definition));
+                }
+                node.rendered = newRendered;
+            }
+            return node.rendered ? utils_1.TreeMutatorResult.CONTINUE : utils_1.TreeMutatorResult.SKIP_DESCENDANTS;
+        }
+    });
+}
+//# sourceMappingURL=trigger-handlers.js.map

package/dist/blocks/data-controller/trigger-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-handlers.js","sourceRoot":"","sources":["../../../src/blocks/data-controller/trigger-handlers.ts"],"names":[],"mappings":";;;AAmDA,gDAQC;AAGD,gDAQC;AAED,oCAIC;AAKD,8CAgBC;AAjGD,8CAAyH;AAIzH,4CAAuC;AAEvC,sGAA0F;AAC1F,8CAAsE;AACtE,mCASiB;AAKjB,SAAS,kBAAkB,CAAiE,OAAiC;IAG5H,MAAM,wBAAwB,GAA8B,EAAE,CAAC;IAC/D,MAAM,UAAU,GAAG,CAAC,MAAW,EAAwB,EAAE;QACxD,OAAO,wBAAwB,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACpF,CAAC,CAAC;IACF,MAAM,aAAa,GAAG,CAAC,MAAW,EAAwB,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;IAClH,OAAO;QACN,SAAS,EAAE,CAAC,MAA+B,EAAE,EAAE,CAAC,wBAAwB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,aAAa;QAChH,QAAQ,EAAG,CAAC,OAAuC,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO,CAAC;KAClG,CAAA;AACF,CAAC;AAEY,QAAA,eAAe,GAAG;IAC9B,UAAU,EAAE,kBAAkB,CAAiC,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,EAAC,IAAI,EAAC,EAAC,EAAE,EAAE;QAC3F,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC1B,OAAO,KAAK,CAAC;IACd,CAAC,CAAC;IACF,eAAe,EAAE,kBAAkB,CAAe,sBAAsB,CAAC;IACzE,uBAAuB,EAAE,kBAAkB,CAAe,KAAK,CAAC,EAAE;QACjE,KAAK,CAAC,uBAAuB,GAAG,IAAI,CAAC;IACtC,CAAC,CAAC;CACO,CAAC;AAMX,SAAgB,kBAAkB,CAA4F,IAAO,EAAE,WAAyC,EAAE;IACjL,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,IAAI,EAAE,CAAC,OAAU,EAAE,UAAmB,KAAK,EAAE,EAAE,CAAC,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,EAAC,CAAC,CAAC,CAAC;IACjH,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3D,IAAI,OAAO,EAAE,CAAC;YACb,uBAAe,CAAC,OAAgC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClE,CAAC;IACF,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC;AAGD,SAAgB,kBAAkB,CAAmG,IAAO,EAAE,WAAyC,EAAE;IACxL,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,IAAI,EAAE,CAAC,OAA2B,EAAE,UAAmB,KAAK,EAAE,EAAE,CAAC,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,EAAC,CAAC,CAAC,CAAC;IAClI,KAAK,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3D,IAAI,OAAO,EAAE,CAAC;YACb,uBAAe,CAAC,OAAgC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAClE,CAAC;IACF,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC;AAED,SAAgB,YAAY,CAAC,IAAc,EAAE,KAA0B;IACtE,IAAI,iBAAiB,CAAC,IAAA,kBAAU,EAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;QACtE,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,GAAG,CAAC,CAAC;IACnD,CAAC;AACF,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB,CAAC,IAAY,EAAE,IAAc,EAAE,KAA0B;IACzF,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;IACnC,IAAI,UAAU,EAAE,CAAC;QAChB,IAAI,eAAuB,CAAC;QAC5B,MAAM,KAAK,GAAG,IAAA,wBAAgB,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5C,IAAI,UAAU,CAAC,QAAQ,IAAI,CAAC,KAAK,EAAE,CAAC;YACnC,eAAe,GAAG,IAAI,UAAU,CAAC,KAAK,IAAI,UAAU,CAAC,IAAI,gBAAgB,CAAC;QAC3E,CAAC;aAAM,CAAC;YACP,eAAe,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACvD,CAAC;QACD,IAAI,IAAI,CAAC,eAAe,KAAK,eAAe,EAAE,CAAC;YAC9C,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;YACvC,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAGD,SAAS,sBAAsB,CAAC,KAA0B;IACzD,MAAM,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;IAC1C,MAAM,4BAA4B,GACjC,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,CAAC,IAAA,qCAAwB,EAAC,YAAY,EAAE,IAAI,EAAE,aAAa,EACjF,QAAQ,CAAC,EAAE,CAAC,IAAA,oBAAY,EAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IACpD,IAAA,mBAAW,EAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACjC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,OAAO,yBAAiB,CAAC,QAAQ,CAAC;QACnC,CAAC;aAAM,CAAC;YACP,MAAM,WAAW,GAAG,IAAA,0BAAa,EAAC,SAAS,EAAE,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC;YACjF,IAAI,WAAW,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACnC,MAAM,SAAS,GAAG,IAAA,oBAAY,EAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBAC/C,IAAI,YAAiB,CAAC;gBACtB,IAAI,CAAC;oBACJ,YAAY,GAAG,IAAA,yBAAiB,EAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;gBACrE,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACZ,IAAI,CAAC,CAAC,CAAC,YAAY,qBAAS,CAAC,EAAE,CAAC;wBAC/B,MAAM,CAAC,CAAC;oBACT,CAAC;oBACD,YAAY,GAAG,SAAS,CAAC;gBAC1B,CAAC;gBACD,IAAI,CAAC,WAAW,EAAE,CAAC;oBAClB,sEAAsE;oBACtE,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC;oBAC3B,IAAA,uCAA+B,EAAC,SAAS,EAAE,IAAI,CAAC,CAAC;gBAClD,CAAC;qBAAM,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;oBACvC,0EAA0E;oBAC1E,MAAM,SAAS,GAAG,IAAA,kBAAU,EAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;oBACnD,IAAA,oCAA4B,EAAC,SAAS,EAAE,IAAI,EAAE,SAAS,CAAC,MAAM,IAAI,IAAA,wEAA+B,EAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC1H,CAAC;gBACD,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC;YAC7B,CAAC;YACD,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,yBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,yBAAiB,CAAC,gBAAgB,CAAC;QACxF,CAAC;IACF,CAAC,CAAC,CAAC;AACJ,CAAC"}

package/dist/blocks/data-controller/utils.d.ts

@@ -0,0 +1,43 @@
+import { Draft } from "immer";
+import type { DCNode, DCStoreState } from "../data-controller";
+import type { DataStore, HydratedSimpleNativeProperty, NodePath, RawPath } from "../simple-native-property-api";
+export declare function removeFromParentNode(parentNode: any | undefined, path: RawPath): void;
+export declare function moveNodeWithinParent(parentNode: any | undefined | null, path: RawPath, move: {
+    from: number;
+    to: number;
+} | {
+    from: string;
+    to: string;
+}): void;
+export declare function isNumericMove(move: {
+    from: number;
+    to: number;
+} | {
+    from: string;
+    to: string;
+}): move is {
+    from: number;
+    to: number;
+};
+export declare function resolveParentNodeDefinition(root: DCNode, path: RawPath): HydratedSimpleNativeProperty | undefined;
+export declare function populateValueBasedOnDefinition(value: any, definition: HydratedSimpleNativeProperty | undefined): any;
+export declare function walkToNode(root: DCNode, path: RawPath): DCNode;
+export declare function descendIntoDCNodeChild(current: DCNode | undefined, path: RawPath, i: number): DCNode;
+export declare function getDataStore(property: string, state: Draft<DCStoreState>, throwOnError: false): DataStore | undefined;
+export declare function getDataStore(property: string, state: Draft<DCStoreState>, throwOnError?: undefined | true): DataStore;
+export declare function getOptionalValue(path: NodePath, state: Draft<DCStoreState>): any;
+export declare function removeValueFromBackingDataStore(dataStore: DataStore, path: NodePath): void;
+export declare function writeValueToBackingDataStoreWithCorrections(path: NodePath, state: DCStoreState, value: any): void;
+export declare function writeValueToBackingDataStore(dataStore: DataStore, path: NodePath, value: any): void;
+/**
+ * @param dsValue a value from a {@link DataStore}
+ * @param path this is expected to be the entire path (including the node that was used to get {@link dsValue}
+ */
+export declare function walkToNodeInValue(dsValue: any, path: RawPath): any;
+export declare enum TreeMutatorResult {
+    STOP = 0,
+    CONTINUE = 1,
+    SKIP_DESCENDANTS = 2
+}
+export declare function applyToTree(tree: DCNode, mutator: (node: DCNode, path: NodePath) => TreeMutatorResult, path?: RawPath): TreeMutatorResult.STOP | TreeMutatorResult.CONTINUE;
+export declare function buildNodeFromDataAndDefinition(data: any, definition: HydratedSimpleNativeProperty): DCNode;

package/dist/blocks/data-controller/utils.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMutatorResult = void 0;
+exports.removeFromParentNode = removeFromParentNode;
+exports.moveNodeWithinParent = moveNodeWithinParent;
+exports.isNumericMove = isNumericMove;
+exports.resolveParentNodeDefinition = resolveParentNodeDefinition;
+exports.populateValueBasedOnDefinition = populateValueBasedOnDefinition;
+exports.walkToNode = walkToNode;
+exports.descendIntoDCNodeChild = descendIntoDCNodeChild;
+exports.getDataStore = getDataStore;
+exports.getOptionalValue = getOptionalValue;
+exports.removeValueFromBackingDataStore = removeValueFromBackingDataStore;
+exports.writeValueToBackingDataStoreWithCorrections = writeValueToBackingDataStoreWithCorrections;
+exports.writeValueToBackingDataStore = writeValueToBackingDataStore;
+exports.walkToNodeInValue = walkToNodeInValue;
+exports.applyToTree = applyToTree;
+exports.buildNodeFromDataAndDefinition = buildNodeFromDataAndDefinition;
+const hooks_1 = require("@wordpress/hooks");
+const immer_1 = require("immer");
+const MoveError_1 = require("../MoveError");
+const PathError_1 = require("../PathError");
+const simple_native_property_internal_shared_1 = require("../simple-native-property-internal-shared");
+function removeFromParentNode(parentNode, path) {
+    if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
+        throw new PathError_1.PathError("Encountered a non-existent node while expecting one.", path);
+    }
+    const nodeName = path[path.length - 1];
+    if (typeof nodeName === 'string') {
+        if (Array.isArray(parentNode)) {
+            throw new PathError_1.PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path, path.length - 1);
+        }
+        delete parentNode[nodeName];
+    }
+    else if (nodeName === undefined) {
+        throw new PathError_1.PathError("Encountered an undefined name in a path.", path);
+    }
+    else {
+        if (!Array.isArray(parentNode)) {
+            throw new PathError_1.PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, path.length - 1);
+        }
+        parentNode.splice(nodeName, 1);
+    }
+}
+function moveNodeWithinParent(parentNode, path, move) {
+    if (typeof parentNode !== 'object' || parentNode === undefined || parentNode === null) {
+        throw new PathError_1.PathError("Encountered a non-existent node while expecting one.", path);
+    }
+    if (isNumericMove(move)) {
+        if (!Array.isArray(parentNode)) {
+            throw new MoveError_1.MoveError("Attempted to move a child of a node with string-keyed descendants by index", path, move);
+        }
+        if (move.from > move.to) {
+            parentNode.splice(move.to, 0, ...parentNode.splice(move.from, 1));
+        }
+        else { //We know that
+            parentNode.splice(move.to - 1, 0, ...parentNode.splice(move.from, 1));
+        }
+    }
+    else {
+        if (Array.isArray(parentNode)) {
+            throw new MoveError_1.MoveError("Attempted to move a child of a node with indexed descendants by string-key", path, move);
+        }
+        if (parentNode[move.to] !== undefined) {
+            throw new MoveError_1.MoveError("Attempted to move a string-keyed child to the same key as another", path, move);
+        }
+    }
+}
+function isNumericMove(move) {
+    return typeof move.from === 'number' && typeof move.to === 'number';
+}
+function resolveParentNodeDefinition(root, path) {
+    if (path.length < 2) {
+        throw new PathError_1.PathError("Unable to get the parent node of a path with less than two nodes", path, path.length - 1, PathError_1.PathErrorType.INSUFFICIENT_LENGTH);
+    }
+    return walkToNode(root, path.slice(0, path.length - (typeof path[path.length - 2] === 'number' ? 2 : 1))).definition;
+}
+function populateValueBasedOnDefinition(value, definition) {
+    const typedChildren = Array.isArray(definition?.children) ? definition.children : definition?.children?.[value?.type];
+    if (!typedChildren?.length) {
+        return value ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(definition);
+    }
+    else if (value === null || value === undefined) {
+        return (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(definition);
+    }
+    else if (typeof value !== 'object') {
+        return value;
+    }
+    else if (Array.isArray(value)) {
+        return value;
+    }
+    return { ...value, ...Object.fromEntries(typedChildren.map(def => [def.name, populateValueBasedOnDefinition(value[def.name], def)])) };
+}
+function walkToNode(root, path) {
+    let current = root;
+    for (let i = 0; i < path.length; i++) {
+        current = descendIntoDCNodeChild(current, path, i);
+    }
+    return current;
+}
+function descendIntoDCNodeChild(current, path, i) {
+    if (current?.children === undefined) {
+        throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
+    }
+    const pathNode = path[i];
+    if (typeof pathNode === 'string') {
+        if (Array.isArray(current.children)) {
+            throw new PathError_1.PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path, i);
+        }
+        current = current.children[pathNode];
+    }
+    else if (pathNode === undefined) {
+        throw new PathError_1.PathError("Encountered an undefined name in a path.", path, i);
+    }
+    else {
+        if (!Array.isArray(current.children)) {
+            throw new PathError_1.PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, i);
+        }
+        current = current.children[pathNode];
+    }
+    if (current === undefined) {
+        throw new PathError_1.PathError("Encountered a non-existent node while expecting one.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
+    }
+    return current;
+}
+function getDataStore(property, state, throwOnError = true) {
+    let dataStore = state.dataStores.byProperty[property];
+    if (dataStore) {
+        return dataStore;
+    }
+    dataStore = state.dataStores.list.find(dataStore => dataStore.handlesProperty(property));
+    if (dataStore) {
+        console.warn(`Unable to locate the DataStore for ${property} via the byProperty map, but did find a DataStore that handles that property. This should not be possible.`);
+    }
+    else if (throwOnError) {
+        throw new Error(`Unable to resolve the dataStore for ${property} on block ${state.blockClientId}`);
+    }
+    return dataStore;
+}
+function getOptionalValue(path, state) {
+    try {
+        return walkToNodeInValue(getDataStore(path[0], state).getValue(path[0]), path);
+    }
+    catch (e) {
+        if (e instanceof PathError_1.PathError) {
+            return undefined;
+        }
+        throw e;
+    }
+}
+function removeValueFromBackingDataStore(dataStore, path) {
+    const dsValue = dataStore.getValue(path[0]);
+    if (path.length === 1) {
+        dataStore.setValue(path[0], undefined);
+    }
+    else {
+        dataStore.setValue(path[0], (0, immer_1.produce)(dsValue, (dsValueDraft) => {
+            const nodeParent = walkToNodeInValue(dsValueDraft, path.slice(0, path.length - 1));
+            const nodeName = path[path.length - 1];
+            if (typeof nodeName === 'string') {
+                delete nodeParent[nodeName];
+            }
+            else if (nodeName === undefined) {
+                throw new PathError_1.PathError("Encountered an undefined name in a path.", path);
+            }
+            else {
+                nodeParent.splice(nodeName, 1);
+            }
+        }));
+    }
+}
+function writeValueToBackingDataStoreWithCorrections(path, state, value) {
+    if (typeof value === 'number' && Number.isNaN(value)) {
+        value = undefined; // This ensures that NaN's don't get stored
+    }
+    const rootDCNode = state.treeRoot.children[path[0]];
+    if (rootDCNode === undefined) {
+        throw new PathError_1.PathError("Encountered a path pointing to a non-existent root node.", path, 0);
+    }
+    const dataStore = getDataStore(path[0], state);
+    // This path both handles scalar values and ensures that the root "value" of Groups and Lists are initialized before writing the actual attribute
+    // In order to avoid accidentally overwriting group data when lazily adding items (i.e. via a ToolsPanel instance), we skip this code path if the group's root value has already been initialized
+    if (path.length === 1 || (value === undefined && dataStore.getValue(path[0]) === undefined)) {
+        const writtenValue = value ?? (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(rootDCNode.definition, path.length === 1);
+        dataStore.setValue(path[0], writtenValue);
+        if (rootDCNode.definition) {
+            (0, hooks_1.doAction)('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', writtenValue, rootDCNode.definition, dataStore);
+        }
+        if (path.length === 1) {
+            return;
+        }
+    }
+    let closestUsableDefinition = rootDCNode.definition;
+    let lastWrittenValue;
+    dataStore.setValue(path[0], (0, immer_1.produce)(dataStore.getValue(path[0]), (dsValueDraft) => {
+        let currentDSValue = dsValueDraft;
+        let currentDCNode = rootDCNode;
+        for (let i = 1; i < path.length - 1; i++) {
+            const nodeName = path[i];
+            currentDCNode = descendIntoDCNodeChild(currentDCNode, path, i);
+            if (typeof nodeName === 'string') {
+                //We only update the definition being used when we descend into a new node proper
+                closestUsableDefinition = currentDCNode.definition;
+            }
+            else if (nodeName === undefined) {
+                throw new PathError_1.PathError("Encountered an undefined name in a path.", path, i);
+            }
+            let nextDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
+            if (nextDSValue === undefined) {
+                lastWrittenValue = currentDSValue[nodeName] = (0, simple_native_property_internal_shared_1.buildDefaultValueFromDefinition)(closestUsableDefinition);
+                currentDSValue = descendIntoDSValueNodeChild(currentDSValue, path, i);
+                if (currentDSValue === undefined) {
+                    throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
+                }
+            }
+            else {
+                currentDSValue = nextDSValue;
+            }
+        }
+        const nodeName = path[path.length - 1];
+        if (nodeName === undefined) {
+            throw new PathError_1.PathError("Encountered an undefined name in a path.", path);
+        }
+        lastWrittenValue = currentDSValue[nodeName] = value;
+    }));
+    if (closestUsableDefinition) {
+        (0, hooks_1.doAction)('plaudit.gutenbergApiExtensions.simpleNativeProperties.afterWrite', lastWrittenValue, closestUsableDefinition, dataStore);
+    }
+}
+function writeValueToBackingDataStore(dataStore, path, value) {
+    if (typeof value === 'number' && Number.isNaN(value)) {
+        value = undefined; // This ensures that NaN's don't get stored
+    }
+    const dsValue = dataStore.getValue(path[0]);
+    if (path.length === 1) {
+        dataStore.setValue(path[0], value);
+    }
+    else {
+        dataStore.setValue(path[0], (0, immer_1.produce)(dsValue, (dsValueDraft) => {
+            const nodeParent = walkToNodeInValue(dsValueDraft, path.slice(0, path.length - 1));
+            const nodeName = path[path.length - 1];
+            if (nodeName === undefined) {
+                throw new PathError_1.PathError("Encountered an undefined name in a path.", path);
+            }
+            nodeParent[nodeName] = value;
+        }));
+    }
+}
+/**
+ * @param dsValue a value from a {@link DataStore}
+ * @param path this is expected to be the entire path (including the node that was used to get {@link dsValue}
+ */
+function walkToNodeInValue(dsValue, path) {
+    let current = dsValue;
+    for (let i = 1; i < path.length; i++) {
+        if (current === undefined) {
+            throw new PathError_1.PathError("Encountered a leaf node while expecting one with descendants.", path, i, PathError_1.PathErrorType.UNEXPECTED_LEAF);
+        }
+        current = descendIntoDSValueNodeChild(current, path, i);
+    }
+    return current;
+}
+function descendIntoDSValueNodeChild(current, path, i) {
+    const pathNode = path[i];
+    if (typeof pathNode === 'string') {
+        if (Array.isArray(current)) {
+            throw new PathError_1.PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path, i);
+        }
+        current = current[pathNode];
+    }
+    else if (pathNode === undefined) {
+        throw new PathError_1.PathError("Encountered an undefined name in a path.", path, i);
+    }
+    else {
+        if (!Array.isArray(current)) {
+            throw new PathError_1.PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path, i);
+        }
+        current = current[pathNode];
+    }
+    return current;
+}
+var TreeMutatorResult;
+(function (TreeMutatorResult) {
+    TreeMutatorResult[TreeMutatorResult["STOP"] = 0] = "STOP";
+    TreeMutatorResult[TreeMutatorResult["CONTINUE"] = 1] = "CONTINUE";
+    TreeMutatorResult[TreeMutatorResult["SKIP_DESCENDANTS"] = 2] = "SKIP_DESCENDANTS";
+})(TreeMutatorResult || (exports.TreeMutatorResult = TreeMutatorResult = {}));
+function applyToTree(tree, mutator, path = []) {
+    if (tree.children === undefined) {
+        return TreeMutatorResult.CONTINUE;
+    }
+    const steps = Array.isArray(tree.children)
+        ? tree.children.map((node, index) => [path.toSpliced(path.length, 0, index), node])
+        : Object.entries(tree.children).map(([name, node]) => [path.toSpliced(path.length, 0, name), node]);
+    for (const [nodePath, node] of steps) {
+        const mutatorRes = mutator(node, nodePath);
+        if (!mutatorRes) {
+            return TreeMutatorResult.STOP;
+        }
+        else if (mutatorRes === TreeMutatorResult.CONTINUE) {
+            if (!applyToTree(node, mutator, nodePath)) {
+                return TreeMutatorResult.STOP;
+            }
+        }
+    }
+    return TreeMutatorResult.CONTINUE;
+}
+function buildNodeFromDataAndDefinition(data, definition) {
+    const children = definition.children;
+    if (children) {
+        if (data === undefined || data === null) {
+            if (definition.type === 'array') {
+                return { rendered: true, condition: definition.condition, definition, validationError: "", children: [] };
+            }
+            else if (definition.type === 'object') {
+                if (Array.isArray(children)) {
+                    return {
+                        rendered: true, condition: definition.condition, definition, validationError: "",
+                        children: Object.fromEntries(children.map(def => [def.name, buildNodeFromDataAndDefinition(undefined, def)]))
+                    };
+                }
+                else {
+                    //TODO: We might need to throw an error here
+                    return { rendered: true, condition: definition.condition, definition, validationError: "", children: {} };
+                }
+            }
+        }
+        else if (typeof data === 'object') {
+            if (Array.isArray(data)) {
+                return {
+                    rendered: true, condition: definition.condition, definition, validationError: "", children: data.map(item => {
+                        const typedChildren = Array.isArray(children) ? children : children[item.type];
+                        if (typedChildren === undefined) {
+                            //TODO: We might need to throw an error here
+                            return { children: [], rendered: true, validationError: "" };
+                        }
+                        return {
+                            children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(item[def.name], def)])),
+                            rendered: true, validationError: ""
+                        };
+                    })
+                };
+            }
+            else {
+                const typedChildren = Array.isArray(children) ? children : children[data.type];
+                if (typedChildren === undefined) {
+                    //TODO: We might need to throw an error here
+                    return { rendered: true, condition: definition.condition, definition, validationError: "", children: [] };
+                }
+                return {
+                    rendered: true, condition: definition.condition, definition, validationError: "",
+                    children: Object.fromEntries(typedChildren.map(def => [def.name, buildNodeFromDataAndDefinition(data[def.name], def)]))
+                };
+            }
+        }
+    }
+    return { rendered: true, condition: definition.condition, definition, validationError: "" };
+}
+//# sourceMappingURL=utils.js.map