@embeddables/cli 0.8.0 → 0.8.2

package/dist/compiler/parsePage.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentJson, PageJson } from './types.js';
+export declare function parsePageFromFile(args: {
+    code: string;
+    filePath: string;
+    pageKey: string;
+}): PageJson;
+/**
+ * Parses a global component file and returns the components.
+ * Similar to parsePageFromFile but simpler - no pageKey needed, just returns components.
+ */
+export declare function parseGlobalComponentsFromFile(args: {
+    code: string;
+    filePath: string;
+}): ComponentJson[];
+//# sourceMappingURL=parsePage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parsePage.d.ts","sourceRoot":"","sources":["../../src/compiler/parsePage.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAezD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,QAAQ,CAuHX;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;CACjB,GAAG,aAAa,EAAE,CAqGlB"}

package/dist/compiler/parsePage.js

@@ -0,0 +1,654 @@
+import { parse } from '@babel/parser';
+import traverseImport from '@babel/traverse';
+import { ALLOWED_PRIMITIVES, TYPE_MAP, DEFAULTS_BY_TYPE } from './registry.js';
+import { CompileError } from './errors.js';
+import { evalStatic } from './evalStatic.js';
+const traverse = (traverseImport.default ?? traverseImport);
+export function parsePageFromFile(args) {
+    let ast;
+    try {
+        ast = parse(args.code, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+            sourceFilename: args.filePath,
+        });
+    }
+    catch (error) {
+        // Babel parser errors have loc property with line/column
+        const line = error.loc?.line ?? error.loc?.start?.line;
+        const column = error.loc?.column ?? error.loc?.start?.column;
+        throw new CompileError(error.message || 'Syntax error', {
+            file: args.filePath,
+            line,
+            column,
+            pageKey: args.pageKey,
+        });
+    }
+    // collect static consts in module scope + inside page function (v1: module scope only is fine)
+    const constEnv = new Map();
+    traverse(ast, {
+        VariableDeclarator(path) {
+            const id = path.node.id;
+            const init = path.node.init;
+            if (id.type === 'Identifier' && init) {
+                // only accept if init is statically evaluable
+                try {
+                    const v = evalStatic(init, constEnv, args.filePath);
+                    constEnv.set(id.name, v);
+                }
+                catch {
+                    // ignore non-static consts
+                }
+            }
+        },
+    });
+    // find exported function and its return JSX + collect function declarations for custom_validation_function
+    // Supports both default exports (preferred) and named exports
+    let rootJsx = null;
+    let rootFragment = null;
+    const validationFunctionSource = new Map();
+    // Helper to extract JSX from a function body and collect inner function declarations
+    const extractJsxAndFunctions = (fnBody, code) => {
+        const ret = fnBody.body.find((s) => s.type === 'ReturnStatement');
+        const arg = ret?.argument;
+        if (arg) {
+            if (arg.type === 'JSXElement') {
+                rootJsx = arg;
+            }
+            else if (arg.type === 'JSXFragment') {
+                rootFragment = arg;
+            }
+        }
+        for (const stmt of fnBody.body) {
+            if (stmt.type === 'FunctionDeclaration' && stmt.id?.name) {
+                const start = stmt.start ?? 0;
+                const end = stmt.end ?? code.length;
+                validationFunctionSource.set(stmt.id.name, code.slice(start, end));
+            }
+        }
+    };
+    traverse(ast, {
+        // Handle: export default function PageName() { ... }
+        ExportDefaultDeclaration(path) {
+            const decl = path.node.declaration;
+            if (decl.type === 'FunctionDeclaration') {
+                extractJsxAndFunctions(decl.body, args.code);
+            }
+        },
+        // Handle: export function PageName() { ... } (legacy support)
+        ExportNamedDeclaration(path) {
+            const decl = path.node.declaration;
+            if (!decl)
+                return;
+            if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
+                extractJsxAndFunctions(decl.body, args.code);
+            }
+        },
+    });
+    const components = [];
+    if (rootJsx) {
+        // Single root element
+        const tree = jsxToTree(rootJsx, constEnv, args.filePath, validationFunctionSource);
+        flatten(tree, null, components, args.pageKey, args.filePath);
+    }
+    else if (rootFragment) {
+        // Multiple root elements (fragment) - allow empty fragments for blank pages
+        const fragmentChildren = [];
+        const fragment = rootFragment;
+        for (const c of fragment.children) {
+            if (c.type === 'JSXElement') {
+                fragmentChildren.push(c);
+            }
+        }
+        // Allow blank pages - if fragment has no JSXElement children, components array stays empty
+        for (const child of fragmentChildren) {
+            const tree = jsxToTree(child, constEnv, args.filePath, validationFunctionSource);
+            flatten(tree, null, components, args.pageKey, args.filePath);
+        }
+    }
+    else {
+        // Allow blank pages - if no JSX found, components array stays empty
+        // This handles pages that return null, undefined, or have no return statement
+    }
+    return {
+        key: args.pageKey,
+        showNav: true,
+        tags: [],
+        id: `page_${args.pageKey}`,
+        components,
+    };
+}
+/**
+ * Parses a global component file and returns the components.
+ * Similar to parsePageFromFile but simpler - no pageKey needed, just returns components.
+ */
+export function parseGlobalComponentsFromFile(args) {
+    let ast;
+    try {
+        ast = parse(args.code, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+            sourceFilename: args.filePath,
+        });
+    }
+    catch (error) {
+        // Babel parser errors have loc property with line/column
+        const line = error.loc?.line ?? error.loc?.start?.line;
+        const column = error.loc?.column ?? error.loc?.start?.column;
+        throw new CompileError(error.message || 'Syntax error', {
+            file: args.filePath,
+            line,
+            column,
+        });
+    }
+    // collect static consts in module scope
+    const constEnv = new Map();
+    traverse(ast, {
+        VariableDeclarator(path) {
+            const id = path.node.id;
+            const init = path.node.init;
+            if (id.type === 'Identifier' && init) {
+                try {
+                    const v = evalStatic(init, constEnv, args.filePath);
+                    constEnv.set(id.name, v);
+                }
+                catch {
+                    // ignore non-static consts
+                }
+            }
+        },
+    });
+    // find exported function and its return JSX + collect function declarations for custom_validation_function
+    let rootJsx = null;
+    let rootFragment = null;
+    const validationFunctionSource = new Map();
+    const extractJsxAndFunctions = (fnBody, code) => {
+        const ret = fnBody.body.find((s) => s.type === 'ReturnStatement');
+        const arg = ret?.argument;
+        if (arg) {
+            if (arg.type === 'JSXElement') {
+                rootJsx = arg;
+            }
+            else if (arg.type === 'JSXFragment') {
+                rootFragment = arg;
+            }
+        }
+        for (const stmt of fnBody.body) {
+            if (stmt.type === 'FunctionDeclaration' && stmt.id?.name) {
+                const start = stmt.start ?? 0;
+                const end = stmt.end ?? code.length;
+                validationFunctionSource.set(stmt.id.name, code.slice(start, end));
+            }
+        }
+    };
+    traverse(ast, {
+        ExportDefaultDeclaration(path) {
+            const decl = path.node.declaration;
+            if (decl.type === 'FunctionDeclaration') {
+                extractJsxAndFunctions(decl.body, args.code);
+            }
+        },
+        ExportNamedDeclaration(path) {
+            const decl = path.node.declaration;
+            if (!decl)
+                return;
+            if (decl.type === 'FunctionDeclaration' && decl.id?.name) {
+                extractJsxAndFunctions(decl.body, args.code);
+            }
+        },
+    });
+    const components = [];
+    if (rootJsx) {
+        const tree = jsxToTree(rootJsx, constEnv, args.filePath, validationFunctionSource);
+        flatten(tree, null, components, '', args.filePath);
+    }
+    else if (rootFragment) {
+        const fragmentChildren = [];
+        const fragment = rootFragment;
+        for (const c of fragment.children) {
+            if (c.type === 'JSXElement') {
+                fragmentChildren.push(c);
+            }
+        }
+        for (const child of fragmentChildren) {
+            const tree = jsxToTree(child, constEnv, args.filePath, validationFunctionSource);
+            flatten(tree, null, components, '', args.filePath);
+        }
+    }
+    return components;
+}
+function jsxToTree(el, constEnv, filePath, validationFunctionSource) {
+    const opening = el.openingElement;
+    const tagName = getJsxTagName(opening.name);
+    if (!ALLOWED_PRIMITIVES.has(tagName)) {
+        throw new CompileError(`Unknown/unsupported primitive <${tagName}>.`, loc(filePath, opening));
+    }
+    const jsonType = TYPE_MAP[tagName];
+    const attrs = attrsToProps(opening.attributes, constEnv, filePath, validationFunctionSource);
+    const id = requireString(attrs, 'id', filePath, opening);
+    const key = requireString(attrs, 'key', filePath, opening);
+    const tags = (attrs.tags ?? []);
+    if (!Array.isArray(tags) || tags.some((t) => typeof t !== 'string')) {
+        throw new CompileError(`Prop "tags" must be an array of strings.`, loc(filePath, opening));
+    }
+    delete attrs.id;
+    delete attrs.key;
+    delete attrs.tags;
+    // For CustomHTML, convert all children (including text) to HTML string
+    if (tagName === 'CustomHTML') {
+        // Check if there are any children (including text nodes and fragments)
+        const hasChildren = el.children.some((c) => c.type === 'JSXElement' ||
+            c.type === 'JSXFragment' ||
+            (c.type === 'JSXText' && c.value.trim().length > 0) ||
+            c.type === 'JSXExpressionContainer');
+        if (hasChildren) {
+            // Convert JSX children to HTML string
+            const htmlString = jsxChildrenToHTML(el.children, constEnv, filePath);
+            attrs.text = htmlString;
+        }
+        // Return with empty children array since we've converted them to HTML
+        return {
+            tag: tagName,
+            type: jsonType,
+            id,
+            key,
+            tags,
+            props: attrs,
+            children: [],
+            loc: loc(filePath, opening),
+        };
+    }
+    // children JSXElements only (ignore whitespace text nodes)
+    const children = el.children
+        .filter((c) => c.type === 'JSXElement')
+        .map((c) => jsxToTree(c, constEnv, filePath, validationFunctionSource));
+    // v1 rule: only Container can have children (CustomHTML handled above)
+    if (children.length > 0 && tagName !== 'Container') {
+        throw new CompileError(`<${tagName}> cannot have children. Only <Container> and <CustomHTML> may contain children.`, loc(filePath, opening));
+    }
+    // enforce OptionSelector uses buttons
+    if (tagName === 'OptionSelector' && 'options' in attrs) {
+        throw new CompileError(`OptionSelector does not support prop "options". Use "buttons".`, loc(filePath, opening));
+    }
+    return {
+        tag: tagName,
+        type: jsonType,
+        id,
+        key,
+        tags,
+        props: attrs,
+        children,
+        loc: loc(filePath, opening),
+    };
+}
+function flatten(node, parentId, out, pageKey, filePath) {
+    const base = {
+        type: node.type,
+        id: node.id,
+        key: node.key,
+        tags: node.tags,
+    };
+    if (parentId)
+        base.parent_id = parentId;
+    const defaults = DEFAULTS_BY_TYPE[node.type] ?? {};
+    // Extract extra props from props={...} (round-trip from reverse compiler) and merge into component
+    // Extract languages prop separately to expand into lang-- properties
+    const { props: extraProps, languages, ...restProps } = node.props;
+    const mergedExtra = extraProps != null && typeof extraProps === 'object' && !Array.isArray(extraProps)
+        ? extraProps
+        : {};
+    // Expand languages prop into flat lang--{langCode}--{attrKey} properties
+    const langProps = {};
+    if (languages != null && typeof languages === 'object' && !Array.isArray(languages)) {
+        for (const [langCode, attrs] of Object.entries(languages)) {
+            if (attrs != null && typeof attrs === 'object' && !Array.isArray(attrs)) {
+                for (const [attrKey, value] of Object.entries(attrs)) {
+                    langProps[`lang--${langCode}--${attrKey}`] = value;
+                }
+            }
+        }
+    }
+    const json = {
+        ...base,
+        ...defaults,
+        ...restProps,
+        ...mergedExtra,
+        ...langProps,
+    };
+    // Helper to create errors with component context
+    const createError = (message, loc) => {
+        return new CompileError(message, {
+            ...loc,
+            pageKey,
+            componentId: node.id,
+            componentKey: node.key,
+        });
+    };
+    // Normalize OptionSelector buttons: generate IDs + defaults
+    if (json.type === 'OptionSelector') {
+        const buttons = json.buttons;
+        if (buttons != null) {
+            if (!Array.isArray(buttons)) {
+                throw createError(`OptionSelector requires "buttons" as an array. Got: ${typeof buttons}`, node.loc);
+            }
+            json.buttons = buttons.map((b) => {
+                if (!b || typeof b !== 'object') {
+                    throw createError(`Each button must be an object.`, node.loc);
+                }
+                // key can be string or null, text is optional
+                if (b.key !== null && typeof b.key !== 'string') {
+                    throw createError(`Each button requires "key" to be a string or null. Got: ${typeof b.key}`, node.loc);
+                }
+                if (b.text != null && typeof b.text !== 'string') {
+                    throw createError(`Button "text" must be a string if provided. Got: ${typeof b.text}`, node.loc);
+                }
+                // Preserve all OptionSelectorButton properties from the input
+                // Required properties
+                const result = {
+                    id: typeof b.id === 'string' ? b.id : `option_${b.key}`,
+                    key: b.key,
+                };
+                // Optional properties - only include if present
+                if (b.text != null)
+                    result.text = b.text;
+                if (b.description != null)
+                    result.description = b.description;
+                // triggerEvent defaults to 'no-action' if not provided
+                result.triggerEvent = typeof b.triggerEvent === 'string' ? b.triggerEvent : 'no-action';
+                if (b.conditions != null)
+                    result.conditions = b.conditions;
+                if (b.openUrlInNewTab != null)
+                    result.openUrlInNewTab = b.openUrlInNewTab;
+                if (b.url != null)
+                    result.url = b.url;
+                if (b.single_select != null)
+                    result.single_select = b.single_select;
+                if (b.icon != null)
+                    result.icon = b.icon;
+                if (b.emojiIcon != null)
+                    result.emojiIcon = b.emojiIcon;
+                if (b.imageUrl != null)
+                    result.imageUrl = b.imageUrl;
+                if (b.imageAltText != null)
+                    result.imageAltText = b.imageAltText;
+                if (b.hide != null)
+                    result.hide = b.hide;
+                if (b.is_repeatable_button != null)
+                    result.is_repeatable_button = b.is_repeatable_button;
+                // Expand languages prop into flat lang--{langCode}--{attrKey} properties
+                if (b.languages != null && typeof b.languages === 'object' && !Array.isArray(b.languages)) {
+                    for (const [langCode, attrs] of Object.entries(b.languages)) {
+                        if (attrs != null && typeof attrs === 'object' && !Array.isArray(attrs)) {
+                            for (const [attrKey, value] of Object.entries(attrs)) {
+                                result[`lang--${langCode}--${attrKey}`] = value;
+                            }
+                        }
+                    }
+                }
+                return result;
+            });
+        }
+        // If buttons is null/undefined, leave it as is (optional prop)
+    }
+    out.push(json);
+    for (const child of node.children) {
+        flatten(child, node.id, out, pageKey, filePath);
+    }
+}
+/**
+ * Normalize validation function source for embeddable.json: use name "validate" and strip TS (param types).
+ */
+function normalizeValidationFunctionSource(source) {
+    // 1. Rename function to "validate"
+    let out = source.replace(/function\s+\w+\s*\(/, 'function validate(');
+    // 2. Strip parameter type annotations in the first parameter list (e.g. value: string -> value)
+    const openParen = out.indexOf('(', out.indexOf('function'));
+    if (openParen !== -1) {
+        let depth = 1;
+        let i = openParen + 1;
+        while (depth > 0 && i < out.length) {
+            if (out[i] === '(')
+                depth++;
+            else if (out[i] === ')')
+                depth--;
+            i++;
+        }
+        const params = out.slice(openParen, i);
+        const paramsNoTypes = params.replace(/:\s*[^,)]+/g, '');
+        out = out.slice(0, openParen) + paramsNoTypes + out.slice(i);
+    }
+    return out;
+}
+function attrsToProps(attrs, constEnv, filePath, validationFunctionSource) {
+    const out = {};
+    for (const a of attrs) {
+        if (a.type === 'JSXSpreadAttribute') {
+            throw new CompileError('JSX spread props are not supported.', loc(filePath, a));
+        }
+        const name = a.name.type === 'JSXIdentifier' ? a.name.name : `${a.name.namespace.name}:${a.name.name.name}`;
+        if (!a.value) {
+            // <X disabled />
+            out[name] = true;
+            continue;
+        }
+        if (a.value.type === 'StringLiteral') {
+            out[name] = a.value.value;
+            continue;
+        }
+        if (a.value.type === 'JSXExpressionContainer') {
+            const expr = a.value.expression;
+            // custom_validation_function: resolve to source and normalize to "validate" + JS for embeddable.json
+            if (name === 'custom_validation_function' &&
+                expr.type === 'Identifier' &&
+                validationFunctionSource?.has(expr.name)) {
+                out[name] = normalizeValidationFunctionSource(validationFunctionSource.get(expr.name));
+                continue;
+            }
+            out[name] = evalStatic(expr, constEnv, filePath);
+            continue;
+        }
+        throw new CompileError(`Unsupported JSX attribute value for "${name}".`, loc(filePath, a));
+    }
+    // When validation_formula is not "custom", custom_validation_function is ignored and omitted (removed on save).
+    if (out.validation_formula != null && out.validation_formula !== 'custom' && 'custom_validation_function' in out) {
+        delete out.custom_validation_function;
+    }
+    return out;
+}
+function getJsxTagName(n) {
+    if (n.type === 'JSXIdentifier')
+        return n.name;
+    throw new CompileError('Only simple JSX identifiers are supported (no member expressions).');
+}
+function requireString(obj, prop, filePath, node) {
+    const v = obj[prop];
+    if (typeof v !== 'string' || v.length === 0) {
+        throw new CompileError(`Missing required string prop "${prop}".`, loc(filePath, node));
+    }
+    return v;
+}
+function loc(file, node) {
+    return { file, line: node.loc?.start?.line, column: node.loc?.start?.column };
+}
+/**
+ * Converts JSX children to HTML string.
+ * Handles JSXElements, JSXText, JSXExpressions, and JSXFragments.
+ * @param preserveWhitespace If true, preserves all whitespace (for <style> and <script> tags)
+ */
+function jsxChildrenToHTML(children, constEnv, filePath, preserveWhitespace = false) {
+    let html = '';
+    for (const child of children) {
+        if (child.type === 'JSXElement') {
+            html += jsxElementToHTML(child, constEnv, filePath);
+        }
+        else if (child.type === 'JSXText') {
+            const text = child.value;
+            // For <style> and <script> tags, preserve all whitespace
+            // For other tags, skip whitespace-only text (it's likely indentation)
+            if (preserveWhitespace || text.trim().length > 0) {
+                html += escapeHTML(text);
+            }
+        }
+        else if (child.type === 'JSXExpressionContainer') {
+            // Try to evaluate static expressions
+            try {
+                const value = evalStatic(child.expression, constEnv, filePath);
+                if (typeof value === 'string') {
+                    html += escapeHTML(value);
+                }
+                else if (value != null) {
+                    html += escapeHTML(String(value));
+                }
+            }
+            catch {
+                throw new CompileError('CustomHTML children must be static. Dynamic expressions are not supported.', loc(filePath, child));
+            }
+        }
+        else if (child.type === 'JSXFragment') {
+            // Handle fragments by recursively processing their children
+            html += jsxChildrenToHTML(child.children, constEnv, filePath, preserveWhitespace);
+        }
+        // Ignore JSXSpreadChild and other unsupported types
+    }
+    return html;
+}
+/**
+ * HTML5 void elements - these are the only elements that can be self-closing in HTML.
+ * For all other elements, we must emit explicit closing tags even if they're self-closing in JSX.
+ * See: https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+ */
+const HTML_VOID_ELEMENTS = new Set([
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+/**
+ * Map React/JSX attribute names to HTML attribute names so serialized HTML
+ * uses valid attributes (e.g. class for CSS, not className).
+ */
+function jsxAttrNameToHTMLAttrName(jsxName) {
+    switch (jsxName) {
+        case 'className':
+            return 'class';
+        case 'htmlFor':
+            return 'for';
+        case 'tabIndex':
+            return 'tabindex';
+        default:
+            return jsxName;
+    }
+}
+/**
+ * Converts a JSX element to HTML string.
+ */
+function jsxElementToHTML(el, constEnv, filePath) {
+    const opening = el.openingElement;
+    const tagName = getJsxTagName(opening.name);
+    // Build attributes string (use HTML attribute names so class selectors work)
+    const attrs = [];
+    for (const attr of opening.attributes) {
+        if (attr.type === 'JSXAttribute') {
+            const name = attr.name.type === 'JSXIdentifier'
+                ? attr.name.name
+                : `${attr.name.namespace.name}:${attr.name.name.name}`;
+            const htmlName = jsxAttrNameToHTMLAttrName(name);
+            if (!attr.value) {
+                // Boolean attribute
+                attrs.push(htmlName);
+            }
+            else if (attr.value.type === 'StringLiteral') {
+                attrs.push(`${htmlName}="${escapeHTMLAttribute(attr.value.value)}"`);
+            }
+            else if (attr.value.type === 'JSXExpressionContainer') {
+                try {
+                    const value = evalStatic(attr.value.expression, constEnv, filePath);
+                    if (name === 'style' && typeof value === 'object' && value !== null) {
+                        // Convert style object to CSS string
+                        const cssString = styleObjectToCSS(value);
+                        attrs.push(`${htmlName}="${escapeHTMLAttribute(cssString)}"`);
+                    }
+                    else if (typeof value === 'string') {
+                        attrs.push(`${htmlName}="${escapeHTMLAttribute(value)}"`);
+                    }
+                    else if (typeof value === 'number' || typeof value === 'boolean') {
+                        attrs.push(`${htmlName}="${String(value)}"`);
+                    }
+                }
+                catch {
+                    throw new CompileError('CustomHTML attribute values must be static. Dynamic expressions are not supported.', loc(filePath, attr));
+                }
+            }
+        }
+    }
+    const attrsStr = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
+    // For <style> and <script> tags, preserve all whitespace to maintain CSS/JS formatting
+    const isRawTextTag = tagName.toLowerCase() === 'style' || tagName.toLowerCase() === 'script';
+    const childrenHTML = jsxChildrenToHTML(el.children, constEnv, filePath, isRawTextTag);
+    if (el.closingElement) {
+        return `<${tagName}${attrsStr}>${childrenHTML}</${tagName}>`;
+    }
+    else {
+        // Self-closing in JSX - check if it's an HTML void element
+        const isVoidElement = HTML_VOID_ELEMENTS.has(tagName.toLowerCase());
+        if (isVoidElement) {
+            // Void elements can be self-closing in HTML
+            return `<${tagName}${attrsStr} />`;
+        }
+        else {
+            // Non-void elements MUST have explicit closing tags in HTML
+            // Otherwise browsers interpret <div /> as <div> (unclosed)
+            return `<${tagName}${attrsStr}></${tagName}>`;
+        }
+    }
+}
+/**
+ * Escapes HTML entities in text content.
+ */
+function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+/**
+ * Escapes HTML entities in attribute values.
+ */
+function escapeHTMLAttribute(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Converts a JSX style object to CSS string.
+ * Example: { margin: 0, padding: 0, color: "#171717" } -> "margin: 0; padding: 0; color: #171717;"
+ */
+function styleObjectToCSS(styleObj) {
+    const cssParts = [];
+    for (const [key, value] of Object.entries(styleObj)) {
+        // Preserve CSS custom properties (e.g., --ta, --my-variable) as-is
+        if (key.startsWith('--')) {
+            cssParts.push(`${key}: ${value};`);
+        }
+        else {
+            // Convert camelCase to kebab-case (e.g., lineHeight -> line-height)
+            const cssKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
+            cssParts.push(`${cssKey}: ${value};`);
+        }
+    }
+    return cssParts.join(' ');
+}

package/dist/compiler/registry.d.ts

@@ -0,0 +1,4 @@
+export declare const ALLOWED_PRIMITIVES: Set<string>;
+export declare const TYPE_MAP: Record<string, string>;
+export declare const DEFAULTS_BY_TYPE: Record<string, Record<string, any>>;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/compiler/registry.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,aAoB7B,CAAA;AAGF,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoB3C,CAAA;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM,CAAA"}