@frontmcp/ui 0.5.1 → 0.6.1

package/src/renderers/utils/detect.js

@@ -1,267 +0,0 @@
-"use strict";
-/**
- * Template Type Detection Utilities
- *
- * Provides functions to detect whether a template is:
- * - A React component (imported or inline)
- * - A JSX string (needs runtime transpilation)
- * - MDX content
- * - Plain HTML
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReactComponent = isReactComponent;
-exports.isTemplateBuilderFunction = isTemplateBuilderFunction;
-exports.containsJsx = containsJsx;
-exports.containsMdxSyntax = containsMdxSyntax;
-exports.isPlainHtml = isPlainHtml;
-exports.detectTemplateType = detectTemplateType;
-/**
- * Check if a value is a React component (FC or class).
- *
- * Detection heuristics:
- * 1. Has $$typeof symbol (React.memo, React.forwardRef, etc.)
- * 2. Has prototype.isReactComponent (class components)
- * 3. Is a function with 0-1 parameters (function components)
- *
- * @param value - Value to check
- * @returns True if it's a React component
- *
- * @example
- * ```typescript
- * const MyComponent = ({ output }) => <div>{output.name}</div>;
- * isReactComponent(MyComponent); // true
- *
- * const htmlFn = (ctx) => `<div>${ctx.output.name}</div>`;
- * isReactComponent(htmlFn); // false (returns string)
- * ```
- */
-function isReactComponent(value) {
-    if (typeof value !== 'function') {
-        return false;
-    }
-    const fn = value;
-    // Check for React's internal type symbols (memo, forwardRef, lazy)
-    const typeofSymbol = fn.$$typeof;
-    if (typeofSymbol) {
-        const symbolString = typeofSymbol.toString();
-        return (symbolString.includes('react.memo') ||
-            symbolString.includes('react.forward_ref') ||
-            symbolString.includes('react.lazy'));
-    }
-    // Check for class components
-    if (fn.prototype?.isReactComponent) {
-        return true;
-    }
-    // For function components, we can't reliably detect without execution.
-    // Heuristic: functions with 0-1 parameters that aren't template builders
-    // Template builders receive a context object and return a string.
-    // React components receive props and return JSX.Element.
-    // Check if function name suggests a component (PascalCase)
-    if (fn.name && /^[A-Z]/.test(fn.name)) {
-        return true;
-    }
-    // Function with specific parameter count
-    // React FC: (props) => JSX or () => JSX
-    // Template: (ctx) => string
-    // We can't distinguish these without execution or source analysis
-    return false;
-}
-/**
- * Check if a function is likely a template builder (returns string).
- *
- * This is a heuristic based on function characteristics.
- *
- * @param fn - Function to check
- * @returns True if likely a template builder function
- */
-function isTemplateBuilderFunction(fn) {
-    // If it's a React component, it's not a template builder
-    if (isReactComponent(fn)) {
-        return false;
-    }
-    // Template builders typically have lowercase names or no name
-    if (fn.name && /^[A-Z]/.test(fn.name)) {
-        return false;
-    }
-    // At this point, assume it's a template builder
-    return true;
-}
-/**
- * Check if a string contains JSX syntax.
- *
- * Looks for patterns like:
- * - `<Component` - JSX component tags
- * - `</Component>` - JSX closing tags
- * - `<div className=` - JSX attributes
- * - `return (` followed by JSX
- *
- * @param source - String to check
- * @returns True if string contains JSX
- *
- * @example
- * ```typescript
- * containsJsx('<div>Hello</div>'); // false (just HTML)
- * containsJsx('<MyComponent />'); // true (JSX component)
- * containsJsx('function() { return <div /> }'); // true
- * ```
- */
-function containsJsx(source) {
-    // JSX component tag (PascalCase)
-    if (/<[A-Z][a-zA-Z0-9]*(\s|>|\/)/.test(source)) {
-        return true;
-    }
-    // Self-closing JSX with component
-    if (/<[A-Z][a-zA-Z0-9]*[^>]*\/>/.test(source)) {
-        return true;
-    }
-    // JSX with curly braces (expressions)
-    if (/<[a-z]+[^>]*\{[^}]+\}/.test(source)) {
-        return true;
-    }
-    // React-specific attributes (className, onClick, etc.)
-    if (/\s(className|onClick|onChange|onSubmit|htmlFor)=/.test(source)) {
-        return true;
-    }
-    // JSX fragments
-    if (/<>|<\/>|<React\.Fragment>/.test(source)) {
-        return true;
-    }
-    // Arrow function returning JSX
-    if (/=>\s*\(?\s*</.test(source)) {
-        return true;
-    }
-    // Function returning JSX
-    if (/return\s*\(?\s*</.test(source)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Check if a string contains MDX syntax.
- *
- * MDX is Markdown with JSX components. Patterns:
- * - Frontmatter: `---\ntitle: ...\n---`
- * - JSX components: `<Component />`
- * - JSX attributes: `className`, `onClick`, `htmlFor`
- * - JS expressions: `{variable}` or `{items.map(...)}`
- * - Import/export statements
- *
- * @param source - String to check
- * @returns True if string contains MDX syntax
- *
- * @example
- * ```typescript
- * containsMdxSyntax('# Title\n<Card />'); // true
- * containsMdxSyntax('# Title\n{data.name}'); // true
- * containsMdxSyntax('<div className="test">...'); // true (JSX attribute)
- * containsMdxSyntax('# Title\nSome text'); // false (just Markdown)
- * ```
- */
-function containsMdxSyntax(source) {
-    // Has JSX component tags (PascalCase)
-    if (/<[A-Z][a-zA-Z0-9]*/.test(source)) {
-        return true;
-    }
-    // Has import/export statements (ESM)
-    if (/^(import|export)\s/m.test(source)) {
-        return true;
-    }
-    // Has JSX-specific attributes (className, onClick, etc.)
-    // These are only valid in JSX, not in regular HTML
-    if (/\s(className|onClick|onChange|onSubmit|htmlFor|dangerouslySetInnerHTML)=/.test(source)) {
-        return true;
-    }
-    // Has JS expressions in curly braces (not just HTML attributes)
-    // Look for expressions outside of quotes
-    if (/\{[^}"'\n]*\}/.test(source) && !/=\s*["'][^"']*\{/.test(source)) {
-        return true;
-    }
-    // Has frontmatter
-    if (/^---[\s\S]*?---/m.test(source)) {
-        return true;
-    }
-    // Has JSX fragments
-    if (/<>|<\/>/.test(source)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Check if a string is plain HTML (no JSX or MDX).
- *
- * @param source - String to check
- * @returns True if string is plain HTML
- */
-function isPlainHtml(source) {
-    return !containsJsx(source) && !containsMdxSyntax(source);
-}
-/**
- * Detect the type of a template.
- *
- * Priority order:
- * 1. React component (imported, already transpiled)
- * 2. MDX string
- * 3. JSX string (needs transpilation)
- * 4. HTML template function
- * 5. Static HTML string
- *
- * @param template - Template to analyze
- * @returns Detected type and confidence
- */
-function detectTemplateType(template) {
-    // Function templates
-    if (typeof template === 'function') {
-        if (isReactComponent(template)) {
-            return {
-                type: 'react',
-                confidence: 0.9,
-                reason: 'Function detected as React component (PascalCase name or React symbols)',
-            };
-        }
-        return {
-            type: 'html-function',
-            confidence: 0.8,
-            reason: 'Function assumed to be HTML template builder',
-        };
-    }
-    // String templates
-    if (typeof template === 'string') {
-        // Check for MDX first (Markdown + JSX)
-        if (containsMdxSyntax(template)) {
-            // Could be MDX or just JSX string
-            // MDX typically has markdown features (headers, lists, etc.)
-            const hasMarkdown = /^#{1,6}\s|^\*\s|^\d+\.\s|^-\s/m.test(template);
-            if (hasMarkdown) {
-                return {
-                    type: 'mdx',
-                    confidence: 0.9,
-                    reason: 'String contains Markdown with JSX components',
-                };
-            }
-            return {
-                type: 'jsx-string',
-                confidence: 0.8,
-                reason: 'String contains JSX syntax',
-            };
-        }
-        if (containsJsx(template)) {
-            return {
-                type: 'jsx-string',
-                confidence: 0.85,
-                reason: 'String contains JSX component tags or expressions',
-            };
-        }
-        return {
-            type: 'html-string',
-            confidence: 1.0,
-            reason: 'Plain HTML string',
-        };
-    }
-    // Default fallback
-    return {
-        type: 'html-string',
-        confidence: 0.5,
-        reason: 'Unknown template type, defaulting to HTML',
-    };
-}
-//# sourceMappingURL=detect.js.map

package/src/renderers/utils/detect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"detect.js","sourceRoot":"","sources":["../../../../src/renderers/utils/detect.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Template Type Detection Utilities\n *\n * Provides functions to detect whether a template is:\n * - A React component (imported or inline)\n * - A JSX string (needs runtime transpilation)\n * - MDX content\n * - Plain HTML\n */\n\n/**\n * Check if a value is a React component (FC or class).\n *\n * Detection heuristics:\n * 1. Has $$typeof symbol (React.memo, React.forwardRef, etc.)\n * 2. Has prototype.isReactComponent (class components)\n * 3. Is a function with 0-1 parameters (function components)\n *\n * @param value - Value to check\n * @returns True if it's a React component\n *\n * @example\n * ```typescript\n * const MyComponent = ({ output }) => <div>{output.name}</div>;\n * isReactComponent(MyComponent); // true\n *\n * const htmlFn = (ctx) => `<div>${ctx.output.name}</div>`;\n * isReactComponent(htmlFn); // false (returns string)\n * ```\n */\nexport function isReactComponent(value: unknown): boolean {\n  if (typeof value !== 'function') {\n    return false;\n  }\n\n  const fn = value as Function;\n\n  // Check for React's internal type symbols (memo, forwardRef, lazy)\n  const typeofSymbol = (fn as { $$typeof?: symbol }).$$typeof;\n  if (typeofSymbol) {\n    const symbolString = typeofSymbol.toString();\n    return (\n      symbolString.includes('react.memo') ||\n      symbolString.includes('react.forward_ref') ||\n      symbolString.includes('react.lazy')\n    );\n  }\n\n  // Check for class components\n  if (fn.prototype?.isReactComponent) {\n    return true;\n  }\n\n  // For function components, we can't reliably detect without execution.\n  // Heuristic: functions with 0-1 parameters that aren't template builders\n  // Template builders receive a context object and return a string.\n  // React components receive props and return JSX.Element.\n\n  // Check if function name suggests a component (PascalCase)\n  if (fn.name && /^[A-Z]/.test(fn.name)) {\n    return true;\n  }\n\n  // Function with specific parameter count\n  // React FC: (props) => JSX or () => JSX\n  // Template: (ctx) => string\n  // We can't distinguish these without execution or source analysis\n\n  return false;\n}\n\n/**\n * Check if a function is likely a template builder (returns string).\n *\n * This is a heuristic based on function characteristics.\n *\n * @param fn - Function to check\n * @returns True if likely a template builder function\n */\nexport function isTemplateBuilderFunction(fn: Function): boolean {\n  // If it's a React component, it's not a template builder\n  if (isReactComponent(fn)) {\n    return false;\n  }\n\n  // Template builders typically have lowercase names or no name\n  if (fn.name && /^[A-Z]/.test(fn.name)) {\n    return false;\n  }\n\n  // At this point, assume it's a template builder\n  return true;\n}\n\n/**\n * Check if a string contains JSX syntax.\n *\n * Looks for patterns like:\n * - `<Component` - JSX component tags\n * - `</Component>` - JSX closing tags\n * - `<div className=` - JSX attributes\n * - `return (` followed by JSX\n *\n * @param source - String to check\n * @returns True if string contains JSX\n *\n * @example\n * ```typescript\n * containsJsx('<div>Hello</div>'); // false (just HTML)\n * containsJsx('<MyComponent />'); // true (JSX component)\n * containsJsx('function() { return <div /> }'); // true\n * ```\n */\nexport function containsJsx(source: string): boolean {\n  // JSX component tag (PascalCase)\n  if (/<[A-Z][a-zA-Z0-9]*(\\s|>|\\/)/.test(source)) {\n    return true;\n  }\n\n  // Self-closing JSX with component\n  if (/<[A-Z][a-zA-Z0-9]*[^>]*\\/>/.test(source)) {\n    return true;\n  }\n\n  // JSX with curly braces (expressions)\n  if (/<[a-z]+[^>]*\\{[^}]+\\}/.test(source)) {\n    return true;\n  }\n\n  // React-specific attributes (className, onClick, etc.)\n  if (/\\s(className|onClick|onChange|onSubmit|htmlFor)=/.test(source)) {\n    return true;\n  }\n\n  // JSX fragments\n  if (/<>|<\\/>|<React\\.Fragment>/.test(source)) {\n    return true;\n  }\n\n  // Arrow function returning JSX\n  if (/=>\\s*\\(?\\s*</.test(source)) {\n    return true;\n  }\n\n  // Function returning JSX\n  if (/return\\s*\\(?\\s*</.test(source)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check if a string contains MDX syntax.\n *\n * MDX is Markdown with JSX components. Patterns:\n * - Frontmatter: `---\\ntitle: ...\\n---`\n * - JSX components: `<Component />`\n * - JSX attributes: `className`, `onClick`, `htmlFor`\n * - JS expressions: `{variable}` or `{items.map(...)}`\n * - Import/export statements\n *\n * @param source - String to check\n * @returns True if string contains MDX syntax\n *\n * @example\n * ```typescript\n * containsMdxSyntax('# Title\\n<Card />'); // true\n * containsMdxSyntax('# Title\\n{data.name}'); // true\n * containsMdxSyntax('<div className=\"test\">...'); // true (JSX attribute)\n * containsMdxSyntax('# Title\\nSome text'); // false (just Markdown)\n * ```\n */\nexport function containsMdxSyntax(source: string): boolean {\n  // Has JSX component tags (PascalCase)\n  if (/<[A-Z][a-zA-Z0-9]*/.test(source)) {\n    return true;\n  }\n\n  // Has import/export statements (ESM)\n  if (/^(import|export)\\s/m.test(source)) {\n    return true;\n  }\n\n  // Has JSX-specific attributes (className, onClick, etc.)\n  // These are only valid in JSX, not in regular HTML\n  if (/\\s(className|onClick|onChange|onSubmit|htmlFor|dangerouslySetInnerHTML)=/.test(source)) {\n    return true;\n  }\n\n  // Has JS expressions in curly braces (not just HTML attributes)\n  // Look for expressions outside of quotes\n  if (/\\{[^}\"'\\n]*\\}/.test(source) && !/=\\s*[\"'][^\"']*\\{/.test(source)) {\n    return true;\n  }\n\n  // Has frontmatter\n  if (/^---[\\s\\S]*?---/m.test(source)) {\n    return true;\n  }\n\n  // Has JSX fragments\n  if (/<>|<\\/>/.test(source)) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check if a string is plain HTML (no JSX or MDX).\n *\n * @param source - String to check\n * @returns True if string is plain HTML\n */\nexport function isPlainHtml(source: string): boolean {\n  return !containsJsx(source) && !containsMdxSyntax(source);\n}\n\n/**\n * Detect the type of a template.\n *\n * Priority order:\n * 1. React component (imported, already transpiled)\n * 2. MDX string\n * 3. JSX string (needs transpilation)\n * 4. HTML template function\n * 5. Static HTML string\n *\n * @param template - Template to analyze\n * @returns Detected type and confidence\n */\nexport function detectTemplateType(template: unknown): {\n  type: 'react' | 'mdx' | 'jsx-string' | 'html-function' | 'html-string';\n  confidence: number;\n  reason: string;\n} {\n  // Function templates\n  if (typeof template === 'function') {\n    if (isReactComponent(template)) {\n      return {\n        type: 'react',\n        confidence: 0.9,\n        reason: 'Function detected as React component (PascalCase name or React symbols)',\n      };\n    }\n\n    return {\n      type: 'html-function',\n      confidence: 0.8,\n      reason: 'Function assumed to be HTML template builder',\n    };\n  }\n\n  // String templates\n  if (typeof template === 'string') {\n    // Check for MDX first (Markdown + JSX)\n    if (containsMdxSyntax(template)) {\n      // Could be MDX or just JSX string\n      // MDX typically has markdown features (headers, lists, etc.)\n      const hasMarkdown = /^#{1,6}\\s|^\\*\\s|^\\d+\\.\\s|^-\\s/m.test(template);\n\n      if (hasMarkdown) {\n        return {\n          type: 'mdx',\n          confidence: 0.9,\n          reason: 'String contains Markdown with JSX components',\n        };\n      }\n\n      return {\n        type: 'jsx-string',\n        confidence: 0.8,\n        reason: 'String contains JSX syntax',\n      };\n    }\n\n    if (containsJsx(template)) {\n      return {\n        type: 'jsx-string',\n        confidence: 0.85,\n        reason: 'String contains JSX component tags or expressions',\n      };\n    }\n\n    return {\n      type: 'html-string',\n      confidence: 1.0,\n      reason: 'Plain HTML string',\n    };\n  }\n\n  // Default fallback\n  return {\n    type: 'html-string',\n    confidence: 0.5,\n    reason: 'Unknown template type, defaulting to HTML',\n  };\n}\n"]}

package/src/renderers/utils/hash.d.ts

@@ -1,39 +0,0 @@
-/**
- * Hash Utilities for Renderer Caching
- *
- * Fast, non-cryptographic hashing for content-addressable cache keys.
- */
-/**
- * Generate a fast hash string from source content.
- * Uses FNV-1a algorithm for good distribution and speed.
- *
- * @param source - String to hash
- * @returns Base36 encoded hash string
- *
- * @example
- * ```typescript
- * const hash = hashString('function Component() { return <div>Hello</div> }');
- * // Returns something like "1a2b3c4d"
- * ```
- */
-export declare function hashString(source: string): string;
-/**
- * Generate a hash combining multiple values.
- * Useful for creating cache keys from multiple inputs.
- *
- * @param values - Values to combine into a hash
- * @returns Combined hash string
- *
- * @example
- * ```typescript
- * const key = hashCombined('template-source', { location: 'NYC' }, { temp: 72 });
- * ```
- */
-export declare function hashCombined(...values: unknown[]): string;
-/**
- * Check if a string likely represents a hash (short alphanumeric).
- *
- * @param value - Value to check
- * @returns True if it looks like a hash
- */
-export declare function isHash(value: string): boolean;

package/src/renderers/utils/hash.js

@@ -1,75 +0,0 @@
-"use strict";
-/**
- * Hash Utilities for Renderer Caching
- *
- * Fast, non-cryptographic hashing for content-addressable cache keys.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashString = hashString;
-exports.hashCombined = hashCombined;
-exports.isHash = isHash;
-/**
- * Generate a fast hash string from source content.
- * Uses FNV-1a algorithm for good distribution and speed.
- *
- * @param source - String to hash
- * @returns Base36 encoded hash string
- *
- * @example
- * ```typescript
- * const hash = hashString('function Component() { return <div>Hello</div> }');
- * // Returns something like "1a2b3c4d"
- * ```
- */
-function hashString(source) {
-    // FNV-1a hash algorithm - fast and well-distributed
-    let hash = 2166136261; // FNV offset basis
-    for (let i = 0; i < source.length; i++) {
-        hash ^= source.charCodeAt(i);
-        // FNV prime for 32-bit: 16777619
-        hash = (hash * 16777619) >>> 0; // Keep as unsigned 32-bit
-    }
-    return hash.toString(36);
-}
-/**
- * Generate a hash combining multiple values.
- * Useful for creating cache keys from multiple inputs.
- *
- * @param values - Values to combine into a hash
- * @returns Combined hash string
- *
- * @example
- * ```typescript
- * const key = hashCombined('template-source', { location: 'NYC' }, { temp: 72 });
- * ```
- */
-function hashCombined(...values) {
-    const combined = values
-        .map((v) => {
-        if (typeof v === 'string')
-            return v;
-        if (v === null)
-            return 'null';
-        if (v === undefined)
-            return 'undefined';
-        try {
-            return JSON.stringify(v);
-        }
-        catch {
-            return String(v);
-        }
-    })
-        .join('|');
-    return hashString(combined);
-}
-/**
- * Check if a string likely represents a hash (short alphanumeric).
- *
- * @param value - Value to check
- * @returns True if it looks like a hash
- */
-function isHash(value) {
-    // Hash strings from hashString() are typically 6-8 characters of base36
-    return /^[0-9a-z]{5,10}$/i.test(value);
-}
-//# sourceMappingURL=hash.js.map

package/src/renderers/utils/hash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../../../src/renderers/utils/hash.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;AAeH,gCAWC;AAcD,oCAeC;AAQD,wBAGC;AAhED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CAAC,MAAc;IACvC,oDAAoD;IACpD,IAAI,IAAI,GAAG,UAAU,CAAC,CAAC,mBAAmB;IAE1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,IAAI,IAAI,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC7B,iCAAiC;QACjC,IAAI,GAAG,CAAC,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,0BAA0B;IAC5D,CAAC;IAED,OAAO,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,GAAG,MAAiB;IAC/C,MAAM,QAAQ,GAAG,MAAM;SACpB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,IAAI,OAAO,CAAC,KAAK,QAAQ;YAAE,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;QAC9B,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,WAAW,CAAC;QACxC,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;SACD,IAAI,CAAC,GAAG,CAAC,CAAC;IAEb,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,MAAM,CAAC,KAAa;IAClC,wEAAwE;IACxE,OAAO,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACzC,CAAC","sourcesContent":["/**\n * Hash Utilities for Renderer Caching\n *\n * Fast, non-cryptographic hashing for content-addressable cache keys.\n */\n\n/**\n * Generate a fast hash string from source content.\n * Uses FNV-1a algorithm for good distribution and speed.\n *\n * @param source - String to hash\n * @returns Base36 encoded hash string\n *\n * @example\n * ```typescript\n * const hash = hashString('function Component() { return <div>Hello</div> }');\n * // Returns something like \"1a2b3c4d\"\n * ```\n */\nexport function hashString(source: string): string {\n  // FNV-1a hash algorithm - fast and well-distributed\n  let hash = 2166136261; // FNV offset basis\n\n  for (let i = 0; i < source.length; i++) {\n    hash ^= source.charCodeAt(i);\n    // FNV prime for 32-bit: 16777619\n    hash = (hash * 16777619) >>> 0; // Keep as unsigned 32-bit\n  }\n\n  return hash.toString(36);\n}\n\n/**\n * Generate a hash combining multiple values.\n * Useful for creating cache keys from multiple inputs.\n *\n * @param values - Values to combine into a hash\n * @returns Combined hash string\n *\n * @example\n * ```typescript\n * const key = hashCombined('template-source', { location: 'NYC' }, { temp: 72 });\n * ```\n */\nexport function hashCombined(...values: unknown[]): string {\n  const combined = values\n    .map((v) => {\n      if (typeof v === 'string') return v;\n      if (v === null) return 'null';\n      if (v === undefined) return 'undefined';\n      try {\n        return JSON.stringify(v);\n      } catch {\n        return String(v);\n      }\n    })\n    .join('|');\n\n  return hashString(combined);\n}\n\n/**\n * Check if a string likely represents a hash (short alphanumeric).\n *\n * @param value - Value to check\n * @returns True if it looks like a hash\n */\nexport function isHash(value: string): boolean {\n  // Hash strings from hashString() are typically 6-8 characters of base36\n  return /^[0-9a-z]{5,10}$/i.test(value);\n}\n"]}

package/src/renderers/utils/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Renderer Utilities
- *
- * Utility functions for template detection, hashing, and transpilation.
- */
-export { isReactComponent, isTemplateBuilderFunction, containsJsx, containsMdxSyntax, isPlainHtml, detectTemplateType, } from './detect';
-export { hashString, hashCombined, isHash } from './hash';
-export { transpileJsx, isSwcAvailable, executeTranspiledCode, transpileAndExecute } from './transpiler';

package/src/renderers/utils/index.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * Renderer Utilities
- *
- * Utility functions for template detection, hashing, and transpilation.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transpileAndExecute = exports.executeTranspiledCode = exports.isSwcAvailable = exports.transpileJsx = exports.isHash = exports.hashCombined = exports.hashString = exports.detectTemplateType = exports.isPlainHtml = exports.containsMdxSyntax = exports.containsJsx = exports.isTemplateBuilderFunction = exports.isReactComponent = void 0;
-// Detection utilities
-var detect_1 = require("./detect");
-Object.defineProperty(exports, "isReactComponent", { enumerable: true, get: function () { return detect_1.isReactComponent; } });
-Object.defineProperty(exports, "isTemplateBuilderFunction", { enumerable: true, get: function () { return detect_1.isTemplateBuilderFunction; } });
-Object.defineProperty(exports, "containsJsx", { enumerable: true, get: function () { return detect_1.containsJsx; } });
-Object.defineProperty(exports, "containsMdxSyntax", { enumerable: true, get: function () { return detect_1.containsMdxSyntax; } });
-Object.defineProperty(exports, "isPlainHtml", { enumerable: true, get: function () { return detect_1.isPlainHtml; } });
-Object.defineProperty(exports, "detectTemplateType", { enumerable: true, get: function () { return detect_1.detectTemplateType; } });
-// Hash utilities
-var hash_1 = require("./hash");
-Object.defineProperty(exports, "hashString", { enumerable: true, get: function () { return hash_1.hashString; } });
-Object.defineProperty(exports, "hashCombined", { enumerable: true, get: function () { return hash_1.hashCombined; } });
-Object.defineProperty(exports, "isHash", { enumerable: true, get: function () { return hash_1.isHash; } });
-// Transpilation utilities
-var transpiler_1 = require("./transpiler");
-Object.defineProperty(exports, "transpileJsx", { enumerable: true, get: function () { return transpiler_1.transpileJsx; } });
-Object.defineProperty(exports, "isSwcAvailable", { enumerable: true, get: function () { return transpiler_1.isSwcAvailable; } });
-Object.defineProperty(exports, "executeTranspiledCode", { enumerable: true, get: function () { return transpiler_1.executeTranspiledCode; } });
-Object.defineProperty(exports, "transpileAndExecute", { enumerable: true, get: function () { return transpiler_1.transpileAndExecute; } });
-//# sourceMappingURL=index.js.map

package/src/renderers/utils/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/renderers/utils/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,sBAAsB;AACtB,mCAOkB;AANhB,0GAAA,gBAAgB,OAAA;AAChB,mHAAA,yBAAyB,OAAA;AACzB,qGAAA,WAAW,OAAA;AACX,2GAAA,iBAAiB,OAAA;AACjB,qGAAA,WAAW,OAAA;AACX,4GAAA,kBAAkB,OAAA;AAGpB,iBAAiB;AACjB,+BAA0D;AAAjD,kGAAA,UAAU,OAAA;AAAE,oGAAA,YAAY,OAAA;AAAE,8FAAA,MAAM,OAAA;AAEzC,0BAA0B;AAC1B,2CAAwG;AAA/F,0GAAA,YAAY,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,mHAAA,qBAAqB,OAAA;AAAE,iHAAA,mBAAmB,OAAA","sourcesContent":["/**\n * Renderer Utilities\n *\n * Utility functions for template detection, hashing, and transpilation.\n */\n\n// Detection utilities\nexport {\n  isReactComponent,\n  isTemplateBuilderFunction,\n  containsJsx,\n  containsMdxSyntax,\n  isPlainHtml,\n  detectTemplateType,\n} from './detect';\n\n// Hash utilities\nexport { hashString, hashCombined, isHash } from './hash';\n\n// Transpilation utilities\nexport { transpileJsx, isSwcAvailable, executeTranspiledCode, transpileAndExecute } from './transpiler';\n"]}

package/src/renderers/utils/transpiler.d.ts

@@ -1,88 +0,0 @@
-/**
- * Runtime JSX/TSX Transpiler
- *
- * Uses SWC to transpile JSX/TSX strings to executable JavaScript at runtime.
- * This enables dynamic React templates without requiring a build step.
- */
-import type { TranspileResult } from '../types';
-/**
- * SWC transformation options for JSX.
- */
-interface SwcTransformOptions {
-    /** Enable TypeScript syntax */
-    typescript?: boolean;
-    /** Enable JSX syntax */
-    jsx?: boolean;
-    /** JSX runtime mode ('automatic' for React 17+, 'classic' for older) */
-    jsxRuntime?: 'automatic' | 'classic';
-    /** Enable development mode (better error messages) */
-    development?: boolean;
-}
-/**
- * Transpile a JSX/TSX string to executable JavaScript.
- *
- * Uses SWC with React 17+ automatic JSX runtime.
- * Results are cached by content hash.
- *
- * @param source - JSX/TSX source code string
- * @param options - Transpilation options
- * @returns Transpiled result with code and caching metadata
- *
- * @example
- * ```typescript
- * const source = `
- *   function Widget({ output }) {
- *     return <div>{output.name}</div>;
- *   }
- * `;
- *
- * const result = await transpileJsx(source);
- * console.log(result.code); // JavaScript code
- * console.log(result.cached); // Whether from cache
- * ```
- */
-export declare function transpileJsx(source: string, options?: SwcTransformOptions): Promise<TranspileResult>;
-/**
- * Check if SWC is available for runtime transpilation.
- *
- * @returns Promise resolving to true if SWC is available
- */
-export declare function isSwcAvailable(): Promise<boolean>;
-/**
- * Execute transpiled JavaScript code and extract the component.
- *
- * Creates a sandboxed environment with React available,
- * executes the code, and returns the exported component.
- *
- * @param code - Transpiled JavaScript code
- * @param context - Additional context to inject
- * @returns The exported component or default export
- *
- * @example
- * ```typescript
- * const code = `
- *   "use strict";
- *   Object.defineProperty(exports, "__esModule", { value: true });
- *   const jsx_runtime = require("react/jsx-runtime");
- *   function Widget(props) {
- *     return jsx_runtime.jsx("div", { children: props.output.name });
- *   }
- *   exports.default = Widget;
- * `;
- *
- * const Component = await executeTranspiledCode(code);
- * // Component is now a usable React component function
- * ```
- */
-export declare function executeTranspiledCode(code: string, context?: Record<string, any>): Promise<any>;
-/**
- * Transpile and execute a JSX string, returning the component.
- *
- * Convenience function that combines transpileJsx and executeTranspiledCode.
- *
- * @param source - JSX/TSX source code
- * @param context - Additional context for execution
- * @returns The component function
- */
-export declare function transpileAndExecute(source: string, context?: Record<string, any>): Promise<any>;
-export {};