@embeddables/cli 0.8.0 → 0.8.2

package/dist/compiler/errors.js

@@ -0,0 +1,35 @@
+import pc from 'picocolors';
+export class CompileError extends Error {
+    info;
+    constructor(message, info) {
+        super(message);
+        this.info = info;
+    }
+}
+export function formatError(e) {
+    if (e instanceof CompileError) {
+        const parts = [];
+        // File location
+        if (e.info?.file && e.info?.line != null) {
+            parts.push(`${pc.cyan(e.info.file)}:${pc.yellow(String(e.info.line))}:${pc.yellow(String(e.info.column ?? 0))}`);
+        }
+        // Page context
+        if (e.info?.pageKey) {
+            parts.push(`page: ${pc.magenta(e.info.pageKey)}`);
+        }
+        // Component context
+        if (e.info?.componentId || e.info?.componentKey) {
+            const componentParts = [];
+            if (e.info.componentId) {
+                componentParts.push(`id=${pc.cyan(e.info.componentId)}`);
+            }
+            if (e.info.componentKey) {
+                componentParts.push(`key=${pc.cyan(e.info.componentKey)}`);
+            }
+            parts.push(`component (${componentParts.join(', ')})`);
+        }
+        const where = parts.length > 0 ? parts.join(' | ') : '';
+        return `${pc.red('Error')} ${where}\n${e.message}`;
+    }
+    return String(e);
+}

package/dist/compiler/evalStatic.d.ts

@@ -0,0 +1,3 @@
+import type * as t from '@babel/types';
+export declare function evalStatic(node: t.Node, constEnv: Map<string, any>, file: string): any;
+//# sourceMappingURL=evalStatic.d.ts.map

package/dist/compiler/evalStatic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evalStatic.d.ts","sourceRoot":"","sources":["../../src/compiler/evalStatic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAA;AAEtC,wBAAgB,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CA+DtF"}

package/dist/compiler/evalStatic.js

@@ -0,0 +1,57 @@
+import { CompileError } from './errors.js';
+export function evalStatic(node, constEnv, file) {
+    switch (node.type) {
+        case 'StringLiteral':
+            return node.value;
+        case 'TemplateLiteral': {
+            // Support template literals with {{variable}} syntax (templating system)
+            // These are written as {`{{variable}}`} in JSX and should be converted to plain strings
+            // Note: {{variable}} is just a string pattern, not a JavaScript expression
+            // Template literals with actual expressions (${...}) are not supported
+            if (node.expressions.length > 0) {
+                throw new CompileError('Template literals with expressions are not supported. Use plain strings only.', loc(file, node));
+            }
+            // For simple template literals (no expressions), concatenate all quasis
+            // Use cooked value if available, otherwise fall back to raw
+            // This handles {`{{first_name}}'s plan`} → "{{first_name}}'s plan"
+            return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join('');
+        }
+        case 'NumericLiteral':
+            return node.value;
+        case 'BooleanLiteral':
+            return node.value;
+        case 'NullLiteral':
+            return null;
+        case 'ArrayExpression':
+            return node.elements.map((el) => {
+                if (!el)
+                    return null;
+                return evalStatic(el, constEnv, file);
+            });
+        case 'ObjectExpression': {
+            const out = {};
+            for (const prop of node.properties) {
+                if (prop.type !== 'ObjectProperty') {
+                    throw new CompileError('Only plain object literals are supported.', loc(file, node));
+                }
+                if (prop.key.type !== 'Identifier' && prop.key.type !== 'StringLiteral') {
+                    throw new CompileError('Only identifier/string keys supported in objects.', loc(file, node));
+                }
+                const k = prop.key.type === 'Identifier' ? prop.key.name : prop.key.value;
+                out[k] = evalStatic(prop.value, constEnv, file);
+            }
+            return out;
+        }
+        case 'Identifier': {
+            if (!constEnv.has(node.name)) {
+                throw new CompileError(`Unknown identifier "${node.name}" (must be a static const).`, loc(file, node));
+            }
+            return constEnv.get(node.name);
+        }
+        default:
+            throw new CompileError(`Unsupported expression "${node.type}". Use literals/arrays/objects/static const identifiers only.`, loc(file, node));
+    }
+}
+function loc(file, node) {
+    return { file, line: node.loc?.start?.line, column: node.loc?.start?.column };
+}

package/dist/compiler/helpers/duplicateIds.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared helpers for deduplicating component/button IDs in forward and reverse compilers.
+ */
+/**
+ * Generates a new unique ID based on component/button type, e.g. plaintext_abcdefghij,
+ * button_abcdef, option_abcde. Used when deduplicating IDs in forward and reverse compilers.
+ */
+export declare function generateRandomIdByType(componentType: string, isOptionButton: boolean, existingIds: Set<string>, alsoExclude: Iterable<string>): string;
+//# sourceMappingURL=duplicateIds.d.ts.map

package/dist/compiler/helpers/duplicateIds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicateIds.d.ts","sourceRoot":"","sources":["../../../src/compiler/helpers/duplicateIds.ts"],"names":[],"mappings":"AAAA;;GAEG;AAwDH;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,OAAO,EACvB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC5B,MAAM,CAaR"}

package/dist/compiler/helpers/duplicateIds.js

@@ -0,0 +1,71 @@
+/**
+ * Shared helpers for deduplicating component/button IDs in forward and reverse compilers.
+ */
+const ID_RANDOM_CHARS = 'abcdefghijklmnopqrstuvwxyz';
+/**
+ * Returns { prefix, suffixLen } for type-based ID generation.
+ * OptionSelector buttons use prefix "option" and length 5; components use a switch over type.
+ */
+function getIdPrefixAndLength(componentType, isOptionButton) {
+    if (isOptionButton) {
+        return { prefix: 'option', suffixLen: 12 };
+    }
+    switch (componentType) {
+        case 'PlainText':
+            return { prefix: 'text', suffixLen: 12 };
+        case 'CustomButton':
+            return { prefix: 'button', suffixLen: 12 };
+        case 'Container':
+            return { prefix: 'container', suffixLen: 12 };
+        case 'RichTextMarkdown':
+            return { prefix: 'richtext', suffixLen: 12 };
+        case 'CustomHTML':
+            return { prefix: 'html', suffixLen: 12 };
+        case 'InputBox':
+            return { prefix: 'input', suffixLen: 12 };
+        case 'OptionSelector':
+            return { prefix: 'optionselector', suffixLen: 12 };
+        case 'StripeCheckout2':
+            return { prefix: 'stripe', suffixLen: 12 };
+        case 'PaypalCheckout':
+            return { prefix: 'paypal', suffixLen: 12 };
+        case 'MediaImage':
+            return { prefix: 'image', suffixLen: 12 };
+        case 'MediaEmbed':
+            return { prefix: 'embed', suffixLen: 12 };
+        case 'Lottie':
+            return { prefix: 'lottie', suffixLen: 12 };
+        case 'Rive':
+            return { prefix: 'rive', suffixLen: 12 };
+        case 'ProgressBar':
+            return { prefix: 'progressbar', suffixLen: 12 };
+        case 'FileUpload':
+            return { prefix: 'fileupload', suffixLen: 12 };
+        case 'BookMeeting':
+            return { prefix: 'bookmeeting', suffixLen: 12 };
+        case 'Chart':
+            return { prefix: 'chart', suffixLen: 12 };
+        default:
+            return { prefix: componentType.toLowerCase(), suffixLen: 12 };
+    }
+}
+/**
+ * Generates a new unique ID based on component/button type, e.g. plaintext_abcdefghij,
+ * button_abcdef, option_abcde. Used when deduplicating IDs in forward and reverse compilers.
+ */
+export function generateRandomIdByType(componentType, isOptionButton, existingIds, alsoExclude) {
+    const { prefix, suffixLen } = getIdPrefixAndLength(componentType, isOptionButton);
+    const excluded = new Set(existingIds);
+    for (const id of alsoExclude)
+        excluded.add(id);
+    for (;;) {
+        let suffix = '';
+        for (let i = 0; i < suffixLen; i++) {
+            suffix += ID_RANDOM_CHARS[Math.floor(Math.random() * ID_RANDOM_CHARS.length)];
+        }
+        const candidate = `${prefix}_${suffix}`;
+        if (!excluded.has(candidate))
+            return candidate;
+        excluded.add(candidate); // avoid retrying same value
+    }
+}

package/dist/compiler/helpers/numericLeadingKeys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Keys and IDs must not start with a digit (invalid in JS/JSON).
+ * This helper produces a safe key by prefixing when needed.
+ */
+/** Returns a key safe for use (prefix applied if key starts with a digit). */
+export declare function normalizeKeyIfStartsWithDigit(key: string | null, prefix: string): string | null;
+export declare function keyOrIdStartsWithDigit(value: string | null | undefined): boolean;
+//# sourceMappingURL=numericLeadingKeys.d.ts.map

package/dist/compiler/helpers/numericLeadingKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numericLeadingKeys.d.ts","sourceRoot":"","sources":["../../../src/compiler/helpers/numericLeadingKeys.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,8EAA8E;AAC9E,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI/F;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAIhF"}

package/dist/compiler/helpers/numericLeadingKeys.js

@@ -0,0 +1,17 @@
+/**
+ * Keys and IDs must not start with a digit (invalid in JS/JSON).
+ * This helper produces a safe key by prefixing when needed.
+ */
+/** Returns a key safe for use (prefix applied if key starts with a digit). */
+export function normalizeKeyIfStartsWithDigit(key, prefix) {
+    if (key === null || typeof key !== 'string' || key === '')
+        return key;
+    if (!/^\d/.test(key))
+        return key;
+    return `${prefix}_${key}`;
+}
+export function keyOrIdStartsWithDigit(value) {
+    if (value === null || value === undefined || typeof value !== 'string' || value === '')
+        return false;
+    return /^\d/.test(value);
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns a copy of newVal with object key order (recursively) matching oldVal
+ * where possible. Keeps existing keys in old order; appends new keys at the end.
+ * Arrays are not reordered; we recurse into elements by index for nested objects.
+ * Used so embeddable.json diffs show only actual changes, not reordering noise.
+ */
+export declare function reorderObjectKeysToMatch(oldVal: unknown, newVal: unknown): unknown;
+export declare function compileAllPages(opts: {
+    pagesGlob: string;
+    outPath: string;
+    pageKeyFrom: 'filename' | 'export';
+    stylesDir?: string;
+    embeddableId?: string;
+    configPath?: string;
+    /** When true, apply lint fixes (duplicate IDs, keys/IDs starting with a digit). When 'prompt', ask user to fix. */
+    fixLint?: true | 'prompt';
+}): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compiler/index.ts"],"names":[],"mappings":"AAkDA;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CA2DlF;AA6BD,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAA;IAClC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,mHAAmH;IACnH,OAAO,CAAC,EAAE,IAAI,GAAG,QAAQ,CAAA;CAC1B,iBAseA"}