@embeddables/cli 0.7.13 → 0.7.15

package/dist/helpers/json.js

@@ -1,622 +0,0 @@
-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/utils.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/helpers/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,UAIxC;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAc7F"}

package/dist/helpers/utils.js

@@ -1,28 +0,0 @@
-import path from 'node:path';
-export function generateId(prefix) {
-    const randomString = Math.random().toString(20).slice(2) + Math.random().toString(20).slice(2);
-    return prefix ? `${prefix}_${randomString}` : `_${randomString}`;
-}
-/**
- * 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 function inferEmbeddableFromCwd() {
-    let current = path.resolve(process.cwd());
-    for (;;) {
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        if (path.basename(parent) === 'embeddables') {
-            return {
-                embeddableId: path.basename(current),
-                projectRoot: path.dirname(parent),
-            };
-        }
-        current = parent;
-    }
-    return null;
-}

package/dist/logger.d.ts

@@ -1,11 +0,0 @@
-type LogContext = Record<string, string | number | boolean | null | undefined>;
-export interface Logger {
-    info(message: string, ctx?: LogContext): void;
-    warn(message: string, ctx?: LogContext): void;
-    error(message: string, ctx?: LogContext): void;
-}
-export declare function createLogger(fn: string): Logger;
-export declare function captureException(error: unknown): void;
-export declare function exit(code: number): Promise<never>;
-export {};
-//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;AAE9E,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAC7C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CAC/C;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAY/C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAErD;AAED,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAGvD"}