@embeddables/cli 0.8.0 → 0.8.1

package/dist/helpers/json.js

@@ -0,0 +1,622 @@
+export function translateJsonDiffToEditCommands({ previousObject = {}, currentObject = {}, path = [], objectMatchKeys = {}, basePath = [], forceObjectKeyInFirstLevelIteration, extraAlternativePathObjectMatchKeys = [], }) {
+    const commands = [];
+    //* Find which key to identify objects an array by. Default is 'id', but can be overridden by objectMatchKeys
+    const defaultObjectMatchKeys = {
+        load_tags: 'url',
+        content_sources: 'key',
+    };
+    objectMatchKeys = { ...defaultObjectMatchKeys, ...objectMatchKeys };
+    let objectMatchKey = undefined; //* default value
+    //* Find the latest occurrence of a key in the path that matches objectMatchKeys
+    for (let i = path.length - 1; i >= 0; i--) {
+        const pathSegment = path[i];
+        if (objectMatchKeys[pathSegment]) {
+            objectMatchKey = objectMatchKeys[pathSegment];
+            break;
+        }
+    }
+    if (forceObjectKeyInFirstLevelIteration)
+        objectMatchKey = forceObjectKeyInFirstLevelIteration;
+    if (!previousObject && !currentObject)
+        return commands;
+    if (Array.isArray(previousObject) && Array.isArray(currentObject)) {
+        const arrayCommands = translateArrayJsonDiffToEditCommands({
+            path,
+            previousArray: previousObject,
+            currentArray: currentObject,
+            objectMatchKeys,
+            basePath,
+            extraAlternativePathObjectMatchKeys,
+        });
+        commands.push(...arrayCommands);
+        return commands;
+    }
+    //* Get all unique keys from both objects
+    const previousKeys = new Set(Object.keys(previousObject || {}));
+    const currentKeys = new Set(Object.keys(currentObject || {}));
+    const allKeys = new Set(Array.from(previousKeys).concat(Array.from(currentKeys)));
+    allKeys.forEach((key) => {
+        const currentPath = [...path, key];
+        const previousValue = previousObject?.[key];
+        const currentValue = currentObject?.[key];
+        //* Property was removed
+        if (previousKeys.has(key) && !currentKeys.has(key)) {
+            if (currentPath[currentPath.length - 1] === key) {
+                commands.push({
+                    type: 'remove',
+                    data: {
+                        path: [...basePath, ...currentPath.slice(0, -1)],
+                        propertyToRemove: key,
+                        objectMatchKey,
+                        alternativePathObjectMatchKeys: objectMatchKey
+                            ? [...extraAlternativePathObjectMatchKeys, objectMatchKey]
+                            : !!extraAlternativePathObjectMatchKeys.length
+                                ? extraAlternativePathObjectMatchKeys
+                                : undefined,
+                    },
+                });
+            }
+            else {
+                commands.push({
+                    type: 'remove',
+                    data: {
+                        path: [...basePath, ...currentPath],
+                        propertyToRemove: key,
+                        objectMatchKey,
+                        alternativePathObjectMatchKeys: objectMatchKey
+                            ? [...extraAlternativePathObjectMatchKeys, objectMatchKey]
+                            : !!extraAlternativePathObjectMatchKeys.length
+                                ? extraAlternativePathObjectMatchKeys
+                                : undefined,
+                    },
+                });
+            }
+            return;
+        }
+        //* Property was added
+        if (!previousKeys.has(key) && currentKeys.has(key)) {
+            commands.push({
+                type: 'set',
+                data: {
+                    path: [...basePath, ...currentPath],
+                    value: currentValue,
+                    objectMatchKey,
+                    alternativePathObjectMatchKeys: objectMatchKey
+                        ? [...extraAlternativePathObjectMatchKeys, objectMatchKey]
+                        : !!extraAlternativePathObjectMatchKeys.length
+                            ? extraAlternativePathObjectMatchKeys
+                            : undefined,
+                },
+            });
+            return;
+        }
+        //* Property exists in both - check for changes
+        if (previousKeys.has(key) && currentKeys.has(key)) {
+            //* If both values are arrays, handle array comparison
+            if (Array.isArray(previousValue) && Array.isArray(currentValue)) {
+                const arrayCommands = translateArrayJsonDiffToEditCommands({
+                    path: currentPath,
+                    previousArray: previousValue,
+                    currentArray: currentValue,
+                    objectMatchKeys,
+                    basePath,
+                    extraAlternativePathObjectMatchKeys,
+                });
+                commands.push(...arrayCommands);
+            }
+            //* If both values are objects (but not arrays), recurse
+            else if (previousValue &&
+                currentValue &&
+                typeof previousValue === 'object' &&
+                typeof currentValue === 'object' &&
+                !Array.isArray(previousValue) &&
+                !Array.isArray(currentValue)) {
+                const nestedCommands = translateJsonDiffToEditCommands({
+                    path: currentPath,
+                    previousObject: previousValue,
+                    currentObject: currentValue,
+                    objectMatchKeys,
+                    basePath,
+                    extraAlternativePathObjectMatchKeys,
+                });
+                commands.push(...nestedCommands);
+            }
+            //* Primitive value comparison
+            else if (!deepEqual(previousValue, currentValue)) {
+                commands.push({
+                    type: 'set',
+                    data: {
+                        path: [...basePath, ...currentPath],
+                        value: currentValue,
+                        objectMatchKey,
+                        alternativePathObjectMatchKeys: objectMatchKey
+                            ? [...extraAlternativePathObjectMatchKeys, objectMatchKey]
+                            : !!extraAlternativePathObjectMatchKeys.length
+                                ? extraAlternativePathObjectMatchKeys
+                                : undefined,
+                    },
+                });
+            }
+        }
+    });
+    return commands;
+}
+export function translateArrayJsonDiffToEditCommands({ previousArray = [], currentArray = [], path = [], objectMatchKeys = {}, basePath = [], extraAlternativePathObjectMatchKeys = [], }) {
+    const commands = [];
+    //* Find which key to identify objects an array by. Default is 'id', but can be overridden by objectMatchKeys
+    const defaultObjectMatchKeys = {
+        load_tags: 'url',
+        content_sources: 'key',
+    };
+    objectMatchKeys = { ...defaultObjectMatchKeys, ...objectMatchKeys };
+    const lastPathSegment = path[path.length - 1] ?? '';
+    const objectMatchKey = objectMatchKeys[lastPathSegment] ?? 'id';
+    //* Create maps for objects with 'id' field for efficient lookup
+    const previousItemsById = new Map();
+    const currentItemsById = new Map();
+    //* Separate items with and without 'id' field
+    const previousWithoutId = [];
+    const currentWithoutId = [];
+    previousArray.forEach((item, index) => {
+        if (item && typeof item === 'object' && item[objectMatchKey]) {
+            previousItemsById.set(item[objectMatchKey], { item, index });
+        }
+        else {
+            previousWithoutId.push(item);
+        }
+    });
+    currentArray.forEach((item, index) => {
+        if (item && typeof item === 'object' && item[objectMatchKey]) {
+            currentItemsById.set(item[objectMatchKey], { item, index });
+        }
+        else {
+            currentWithoutId.push(item);
+        }
+    });
+    //* Handle items with primary key field
+    //* Check for removed items
+    previousItemsById.forEach(({ item }, id) => {
+        if (!currentItemsById.has(id)) {
+            commands.push({
+                type: 'remove',
+                data: {
+                    path: [...basePath, ...path, id],
+                    objectMatchKey,
+                    alternativePathObjectMatchKeys: [...extraAlternativePathObjectMatchKeys, objectMatchKey],
+                },
+            });
+        }
+    });
+    //* Check for added and modified items
+    currentItemsById.forEach(({ item: currentItem, index }, id) => {
+        if (!previousItemsById.has(id)) {
+            let position;
+            //* Check if the item is a component
+            if (currentItem.type && currentItem.id && currentItem.key) {
+                //* Components have a type property
+                const component = currentItem;
+                position = getInsertPositionForComponent({
+                    afterComponentId: index > 0 ? currentArray[index - 1][objectMatchKey] : undefined,
+                    beforeComponentId: index < currentArray.length - 1 ? currentArray[index + 1][objectMatchKey] : undefined,
+                    parentComponentId: component.parent_id || undefined,
+                    globalLocation: component._location || undefined,
+                    components: currentArray,
+                });
+            }
+            else {
+                //* For non-components, use the original position logic
+                position = {
+                    after: index > 0 ? currentArray[index - 1][objectMatchKey] : undefined,
+                    before: index < currentArray.length - 1 ? currentArray[index + 1][objectMatchKey] : undefined,
+                };
+            }
+            //* Item was added
+            commands.push({
+                type: 'add',
+                data: {
+                    path: [...basePath, ...path],
+                    value: currentItem,
+                    position,
+                    objectMatchKey,
+                    alternativePathObjectMatchKeys: [...extraAlternativePathObjectMatchKeys, objectMatchKey],
+                },
+            });
+        }
+        else {
+            //* Item exists, check for modifications
+            const previousItem = previousItemsById.get(id).item;
+            if (!deepEqual(previousItem, currentItem)) {
+                //* If it's an object, recurse to find specific changes
+                if (typeof currentItem === 'object' && typeof previousItem === 'object') {
+                    const itemPath = [...path, id];
+                    const nestedCommands = translateJsonDiffToEditCommands({
+                        path: itemPath,
+                        previousObject: previousItem,
+                        currentObject: currentItem,
+                        objectMatchKeys,
+                        basePath,
+                        extraAlternativePathObjectMatchKeys,
+                    });
+                    commands.push(...nestedCommands);
+                }
+                else {
+                    const nestedCommands = translateJsonDiffToEditCommands({
+                        path: [...path, id],
+                        previousObject: previousItem,
+                        currentObject: currentItem,
+                        objectMatchKeys,
+                        basePath,
+                        extraAlternativePathObjectMatchKeys,
+                    });
+                    commands.push(...nestedCommands);
+                }
+            }
+        }
+    });
+    //* Handle items without 'id' field (primitives or objects without id)
+    //* If it's an array of primitives, remove all items present in previousArray that are not in currentArray and vice versa.
+    const isArrayOfPrimitives = previousWithoutId.every((item) => ['string', 'number', 'boolean'].includes(typeof item)) &&
+        currentWithoutId.every((item) => ['string', 'number', 'boolean'].includes(typeof item));
+    if (isArrayOfPrimitives) {
+        const prevPrimitives = new Set(previousWithoutId);
+        const currPrimitives = new Set(currentWithoutId);
+        //* Find removed primitives
+        prevPrimitives.forEach((item) => {
+            if (!currPrimitives.has(item)) {
+                commands.push({
+                    type: 'remove',
+                    data: {
+                        alternativePathObjectMatchKeys: [...extraAlternativePathObjectMatchKeys],
+                        path: [...basePath, ...path, item],
+                        isStringMatch: typeof item === 'string',
+                    },
+                });
+            }
+        });
+        //* Find added primitives
+        currPrimitives.forEach((item) => {
+            if (!prevPrimitives.has(item)) {
+                commands.push({
+                    type: 'add',
+                    data: {
+                        alternativePathObjectMatchKeys: [...extraAlternativePathObjectMatchKeys],
+                        path: [...basePath, ...path],
+                        value: item,
+                    },
+                });
+            }
+        });
+    }
+    else {
+        //* Handle array of objects without a primary key
+        //* Find a unique key in both previous and current arrays to identify items.
+        const previousUniqueKeys = findUniqueKey(previousWithoutId);
+        const currentUniqueKeys = findUniqueKey(currentWithoutId);
+        //* Find the intersection of the two arrays of keys to get common unique keys.
+        const commonUniqueKeys = previousUniqueKeys.filter((key) => currentUniqueKeys.includes(key));
+        const uniqueKey = commonUniqueKeys[0];
+        if (uniqueKey) {
+            //* Prevent infinite recursion: if both arrays without ID have only one element,
+            //* compare them directly instead of using recursion
+            if (previousWithoutId.length === 1 && currentWithoutId.length === 1) {
+                if (!deepEqual(previousWithoutId[0], currentWithoutId[0])) {
+                    commands.push({
+                        type: 'set',
+                        data: { path: [...basePath, ...path], value: currentArray },
+                    });
+                }
+            }
+            else {
+                //* We can identify items in the array by a unique key, so we compare them
+                commands.push(...translateArrayJsonDiffToEditCommands({
+                    previousArray,
+                    currentArray,
+                    path,
+                    objectMatchKeys: { ...objectMatchKeys, [lastPathSegment]: uniqueKey },
+                    basePath,
+                    extraAlternativePathObjectMatchKeys,
+                }));
+            }
+        }
+        else {
+            //* We cannot identify items in the array, as a fallback we treat it as a set of items and update the entire array if it has changed
+            if (!deepEqual(previousArray, currentArray)) {
+                commands.push({
+                    type: 'set',
+                    data: { path: [...basePath, ...path], value: currentArray },
+                });
+            }
+        }
+    }
+    return commands;
+}
+//* Find ancestors of a component (containers only, from root to direct parent)
+export function findAncestorsOfComponent({ components, componentId, }) {
+    const ancestors = [];
+    const currentComponent = components.find((c) => c.id === componentId);
+    if (!currentComponent)
+        return ancestors;
+    const parentId = currentComponent.parent_id;
+    if (parentId) {
+        const parentComponent = components.find((c) => c.id === parentId);
+        if (parentComponent && parentComponent.type === 'Container') {
+            const parentAncestors = findAncestorsOfComponent({
+                components,
+                componentId: parentComponent.id,
+            });
+            ancestors.push(...parentAncestors);
+            ancestors.push(parentComponent);
+        }
+    }
+    return ancestors;
+}
+//* Find next sibling component
+function getNextSiblingComponent({ components, currentComponentId, parentId, globalLocation, isGlobalComponents, }) {
+    const siblings = components.filter((c) => parentId ? c.parent_id === parentId : isGlobalComponents ? c._location === globalLocation : !c.parent_id);
+    const currentIndex = siblings.findIndex((c) => c.id === currentComponentId);
+    if (currentIndex >= 0 && currentIndex < siblings.length - 1) {
+        return siblings[currentIndex + 1];
+    }
+    return null;
+}
+//* Find previous sibling component
+function getPreviousSiblingComponent({ components, currentComponentId, parentId, globalLocation, isGlobalComponents, }) {
+    const siblings = components.filter((c) => parentId ? c.parent_id === parentId : isGlobalComponents ? c._location === globalLocation : !c.parent_id);
+    const currentIndex = siblings.findIndex((c) => c.id === currentComponentId);
+    if (currentIndex > 0)
+        return siblings[currentIndex - 1];
+    return null;
+}
+export function getInsertPositionForComponent({ afterComponentId, beforeComponentId, parentComponentId, globalLocation, components, isGlobalComponents, }) {
+    //* Case 1: I get the afterComponentId
+    if (afterComponentId) {
+        //* Find the afterElement
+        const afterComponent = components.find((c) => c.id === afterComponentId);
+        if (afterComponent) {
+            //* Find the before compoentn (next sibling of after)
+            const beforeElement = getNextSiblingComponent({
+                components,
+                currentComponentId: afterComponentId,
+                parentId: afterComponent.parent_id,
+                globalLocation: afterComponent._location,
+                isGlobalComponents,
+            });
+            //* Get ancestors using our new function
+            const ancestors = findAncestorsOfComponent({ components, componentId: afterComponentId });
+            //* Check if it's global by looking at the last ancestor's _location
+            let isGlobal = false;
+            let detectedGlobalLocation;
+            if (ancestors.length > 0) {
+                //* Get the topmost ancestor (last in the array)
+                const topmostAncestor = ancestors[ancestors.length - 1];
+                if (topmostAncestor._location) {
+                    isGlobal = true;
+                    detectedGlobalLocation = topmostAncestor._location;
+                }
+            }
+            else if (afterComponent._location) {
+                //* If no ancestors but the component itself has _location
+                isGlobal = true;
+                detectedGlobalLocation = afterComponent._location;
+            }
+            //* Build the position
+            const position = { after: afterComponentId };
+            if (beforeElement)
+                position.before = beforeElement.id;
+            if (ancestors.length > 0)
+                position.inside = ancestors.map((ancestor) => ancestor.id);
+            if (isGlobal && detectedGlobalLocation)
+                position.globalLocation = detectedGlobalLocation;
+            return position;
+        }
+    }
+    //* Case 2: I get the beforeComponentId, but no afterComponentId
+    if (beforeComponentId) {
+        const beforeComponent = components.find((c) => c.id === beforeComponentId);
+        if (beforeComponent) {
+            //* Try to find an after component
+            const afterComponent = getPreviousSiblingComponent({
+                components,
+                currentComponentId: beforeComponentId,
+                parentId: beforeComponent.parent_id,
+                globalLocation: beforeComponent._location,
+                isGlobalComponents,
+            });
+            //* Get ancestors using our new function
+            const ancestors = findAncestorsOfComponent({ components, componentId: beforeComponentId });
+            //* Check if it's global by looking at the last ancestor's _location
+            let isGlobal = false;
+            let detectedGlobalLocation;
+            if (ancestors.length > 0) {
+                //* Get the topmost ancestor (last in the array)
+                const topmostAncestor = ancestors[ancestors.length - 1];
+                if (topmostAncestor._location) {
+                    isGlobal = true;
+                    detectedGlobalLocation = topmostAncestor._location;
+                }
+            }
+            else if (beforeComponent._location) {
+                //* If no ancestors but the component itself has _location
+                isGlobal = true;
+                detectedGlobalLocation = beforeComponent._location;
+            }
+            //* Build the position for first position
+            const position = { before: beforeComponentId };
+            if (afterComponent)
+                position.after = afterComponent.id;
+            if (ancestors.length > 0)
+                position.inside = ancestors.map((ancestor) => ancestor.id);
+            if (isGlobal && detectedGlobalLocation)
+                position.globalLocation = detectedGlobalLocation;
+            return position;
+        }
+    }
+    //* Case 3: I get the parentComponentId
+    if (parentComponentId) {
+        const parentComponent = components.find((c) => c.id === parentComponentId);
+        if (parentComponent) {
+            //* Get ancestors of the parent to construct inside and define globalLocation
+            const ancestors = findAncestorsOfComponent({ components, componentId: parentComponentId });
+            //* Check if it's global by looking at the last ancestor's _location
+            let isGlobal = false;
+            let detectedGlobalLocation;
+            if (ancestors.length > 0) {
+                //* Get the topmost ancestor (last in the array)
+                const topmostAncestor = ancestors[ancestors.length - 1];
+                if (topmostAncestor._location) {
+                    isGlobal = true;
+                    detectedGlobalLocation = topmostAncestor._location;
+                }
+            }
+            else if (parentComponent._location) {
+                //* If no ancestors but the parent itself has _location
+                isGlobal = true;
+                detectedGlobalLocation = parentComponent._location;
+            }
+            //* Build the position for insertion inside parent
+            const position = {
+                inside: [...ancestors.map((ancestor) => ancestor.id), parentComponentId],
+            };
+            if (isGlobal && detectedGlobalLocation)
+                position.globalLocation = detectedGlobalLocation;
+            return position;
+        }
+    }
+    //* Case 4: globalLocation provided
+    if (globalLocation)
+        return { globalLocation: globalLocation };
+    return undefined;
+}
+//* -------------------OBJECT FUNCTIONS ------------------- *//
+//* Deep comparison function to check if two objects are equal
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2)
+        return true;
+    if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (let key of keys1) {
+        if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function findUniqueKey(arr) {
+    const uniqueKeys = [];
+    if (!arr.length || typeof arr[0] !== 'object' || arr[0] === null)
+        return uniqueKeys;
+    const keys = Object.keys(arr[0]);
+    for (const key of keys) {
+        const values = new Set();
+        let allHaveKeyAndArePrimitive = true;
+        for (const item of arr) {
+            if (item &&
+                typeof item === 'object' &&
+                key in item &&
+                ['string', 'number', 'boolean'].includes(typeof item[key])) {
+                values.add(item[key]);
+            }
+            else {
+                allHaveKeyAndArePrimitive = false;
+                break;
+            }
+        }
+        if (allHaveKeyAndArePrimitive && values.size === arr.length)
+            uniqueKeys.push(key);
+    }
+    return uniqueKeys;
+}
+//* Find the different paths between two objects
+export function findDifferentPaths(obj1, obj2) {
+    const result = {};
+    //* Helper function to add a path to results
+    function addPath(path) {
+        const topLevel = path.split('.')[0];
+        if (!result[topLevel]) {
+            result[topLevel] = [];
+        }
+        if (!result[topLevel].includes(path)) {
+            result[topLevel].push(path);
+        }
+    }
+    //* Deep compare function to find all differences
+    function deepCompare(a, b, currentPath = '') {
+        //* If objects are strictly equal, no need to check further
+        if (a === b)
+            return;
+        //* Handle case when either value is not an object or is null
+        if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) {
+            addPath(currentPath);
+            return;
+        }
+        //* Get all keys from both objects
+        const allKeys = Array.from(new Set([...Object.keys(a), ...Object.keys(b)]));
+        for (const key of allKeys) {
+            const newPath = currentPath ? `${currentPath}.${key}` : key;
+            //* If key exists only in one object
+            if (!(key in a) || !(key in b)) {
+                addPath(newPath);
+                //* If the key is in b but not a, and it's an object, add all nested paths
+                if (!(key in a) && typeof b[key] === 'object' && b[key] !== null) {
+                    addNestedPaths(b[key], newPath);
+                }
+                //* If the key is in a but not b, and it's an object, add all nested paths
+                else if (!(key in b) && typeof a[key] === 'object' && a[key] !== null) {
+                    addNestedPaths(a[key], newPath);
+                }
+                continue;
+            }
+            //* Recursively check nested properties
+            deepCompare(a[key], b[key], newPath);
+        }
+    }
+    //* Helper function to add all paths in a nested object
+    function addNestedPaths(obj, basePath) {
+        if (typeof obj !== 'object' || obj === null)
+            return;
+        addPath(basePath);
+        for (const key in obj) {
+            const newPath = `${basePath}.${key}`;
+            addPath(newPath);
+            if (typeof obj[key] === 'object' && obj[key] !== null) {
+                addNestedPaths(obj[key], newPath);
+            }
+        }
+    }
+    deepCompare(obj1, obj2);
+    return result;
+}
+//* Get the value of an object by a path
+export function getValueByPath(obj, path) {
+    let current = obj;
+    for (const key of path) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+export function getBreakLineStringFromArray(input) {
+    if (Array.isArray(input))
+        return input.join('\n');
+    return input;
+}
+const DEFAULT_CONTENT_LANGUAGE_KEY = 'en';
+//* Builds a language-prefixed key for multilanguage properties
+//* For default language, returns the base key; for others, returns `lang--{languageKey}--{attributeKey}`
+export function getMultilanguageKey({ attributeKey, languageKey, }) {
+    return languageKey === DEFAULT_CONTENT_LANGUAGE_KEY
+        ? attributeKey
+        : `lang--${languageKey}--${attributeKey}`;
+}
+export function getArrayFromBreakLineString(input) {
+    if (typeof input === 'string')
+        return input.split('\n');
+    return input;
+}

package/dist/helpers/prompt.d.ts

@@ -0,0 +1,15 @@
+import prompts from 'prompts';
+/**
+ * Wrapper around `prompts` that properly handles ESC on all prompt types.
+ *
+ * The `prompts` library has a bug in AutocompletePrompt: pressing ESC triggers
+ * `exit()` which resolves the promise with the currently highlighted value
+ * (acting like a submit), rather than aborting. This wrapper detects the
+ * `exited` state via `onState` and calls `process.exit(0)` so ESC consistently
+ * quits the CLI command.
+ *
+ * For prompt types that already handle ESC correctly (select, confirm, text),
+ * the `onCancel` handler fires normally via the abort path.
+ */
+export declare function prompt(question: prompts.PromptObject<string>, exitCode?: number): Promise<prompts.Answers<string>>;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/helpers/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/helpers/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B;;;;;;;;;;;GAWG;AACH,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,EACtC,QAAQ,GAAE,MAAU,GACnB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CA4BlC"}

package/dist/helpers/prompt.js

@@ -0,0 +1,35 @@
+import prompts from 'prompts';
+/**
+ * Wrapper around `prompts` that properly handles ESC on all prompt types.
+ *
+ * The `prompts` library has a bug in AutocompletePrompt: pressing ESC triggers
+ * `exit()` which resolves the promise with the currently highlighted value
+ * (acting like a submit), rather than aborting. This wrapper detects the
+ * `exited` state via `onState` and calls `process.exit(0)` so ESC consistently
+ * quits the CLI command.
+ *
+ * For prompt types that already handle ESC correctly (select, confirm, text),
+ * the `onCancel` handler fires normally via the abort path.
+ */
+export async function prompt(question, exitCode = 0) {
+    let exited = false;
+    const originalOnState = question.onState;
+    const questionWithState = {
+        ...question,
+        onState: (state) => {
+            if (state.exited) {
+                exited = true;
+            }
+            originalOnState?.(state);
+        },
+    };
+    const response = await prompts(questionWithState, {
+        onCancel: () => {
+            process.exit(exitCode);
+        },
+    });
+    if (exited) {
+        process.exit(exitCode);
+    }
+    return response;
+}

package/dist/helpers/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function generateId(prefix: string): string;
+/**
+ * If the current working directory is inside embeddables/<id>/ (or a subfolder),
+ * returns that embeddable id and the project root (the directory containing the
+ * embeddables/ folder). Otherwise returns null.
+ * When using the inferred id, callers should chdir(projectRoot) so relative
+ * paths like embeddables/<id>/... resolve correctly.
+ */
+export declare function inferEmbeddableFromCwd(): {
+    embeddableId: string;
+    projectRoot: string;
+} | null;
+//# sourceMappingURL=utils.d.ts.map