@stacksjs/stx 0.2.94 → 0.2.96

package/dist/craft-entry.js

@@ -1,2 +1,5 @@
-// @bun
-import{Ao as E,yo as C,zo as D}from"./chunk-b5zc9y0y.js";import{Co as d,Do as g,Eo as h}from"./chunk-957amb71.js";import{Go as i,Ho as j,Io as k,Jo as l,Ko as n,Lo as q}from"./chunk-268adc7r.js";import{No as s,Oo as u,Po as v,Qo as w,Ro as y,So as z,To as A,Uo as B}from"./chunk-jt98jhpt.js";import{Wo as t,Xo as x,Yo as a,Zo as b,_o as c}from"./chunk-5p568px4.js";import"./chunk-3jm3snz8.js";export{u as renderSSR,n as registerCraftComponent,b as processCraftDirective,l as processCraftComponents,w as prerenderForCraft,a as isCraftEnvironment,c as injectCraftBridge,B as getSSRCacheStats,q as getCraftComponents,D as getAvailableTargets,E as getAvailableFormats,v as generateCraftOptimizations,x as generateCraftBridgeScript,h as createHotReloadServer,g as compileToNative,s as compileTemplate,y as clearTemplateCache,z as clearRenderCache,A as clearAllCaches,C as buildNative,d as NATIVE_COMPONENTS,j as CRAFT_COMPONENT_STYLES,k as CRAFT_COMPONENT_RUNTIME,i as CRAFT_COMPONENTS,t as CRAFT_BRIDGE_SCRIPT};
+export * from "./craft-bridge.js";
+export * from "./craft-compiler.js";
+export * from "./craft-components.js";
+export * from "./craft-ssr.js";
+export * from "./native-build.js";

package/dist/craft-ssr.js

@@ -1,2 +1,559 @@
-// @bun
-import{No as a,Oo as b,Po as c,Qo as d,Ro as e,So as f,To as g,Uo as h,Vo as i}from"./chunk-jt98jhpt.js";import"./chunk-3jm3snz8.js";export{b as renderSSR,d as prerenderForCraft,h as getSSRCacheStats,c as generateCraftOptimizations,i as default,a as compileTemplate,e as clearTemplateCache,f as clearRenderCache,g as clearAllCaches};
+const templateCache = new Map, renderCache = new Map;
+export function compileTemplate(template, options) {
+  const id = options?.id || generateTemplateId(template), hash = generateHash(template), cached = templateCache.get(id);
+  if (cached && cached.hash === hash)
+    return cached;
+  const tree = parseTemplateToTree(template), scripts = extractScripts(template), styles = extractStyles(template), metadata = analyzeTemplate(tree), { staticParts, dynamicParts } = partitionContent(tree), dependencies = extractDependencies(template), compiled = {
+    id,
+    hash,
+    tree,
+    scripts,
+    styles,
+    staticParts,
+    dynamicParts,
+    dependencies,
+    metadata
+  };
+  templateCache.set(id, compiled);
+  return compiled;
+}
+export async function renderSSR(compiled, context = {}, config = {}) {
+  const startTime = performance.now();
+  if (config.cache) {
+    const cacheKey = `${compiled.id}:${JSON.stringify(context)}`, cached = renderCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < (config.cacheTTL || 60000))
+      return {
+        html: cached.html,
+        styles: compiled.styles.join(`
+`),
+        scripts: compiled.scripts.join(`
+`),
+        metadata: {
+          renderTime: 0,
+          cacheHit: !0,
+          totalSize: cached.html.length,
+          componentCount: compiled.metadata.componentCount
+        }
+      };
+  }
+  let html;
+  if (config.streaming)
+    html = await renderTreeStreaming(compiled.tree, context);
+  else
+    html = renderTreeToHTML(compiled.tree, context);
+  let hydrationData;
+  if (config.hydrate) {
+    const result = addHydrationMarkers(html, compiled, context);
+    html = result.html;
+    hydrationData = result.data;
+  }
+  if (config.minify)
+    html = minifyHTML(html);
+  if (config.cache) {
+    const cacheKey = `${compiled.id}:${JSON.stringify(context)}`;
+    renderCache.set(cacheKey, { html, timestamp: Date.now() });
+  }
+  const renderTime = performance.now() - startTime;
+  return {
+    html,
+    styles: compiled.styles.join(`
+`),
+    scripts: compiled.scripts.join(`
+`),
+    hydrationData,
+    metadata: {
+      renderTime,
+      cacheHit: !1,
+      totalSize: html.length,
+      componentCount: compiled.metadata.componentCount
+    }
+  };
+}
+export function generateCraftOptimizations(compiled, _config) {
+  const nativeComponents = [], staticHTML = [], dynamicParts = [], eventHandlers = new Map, nativeWidgets = [];
+  walkTree(compiled.tree, (node, _path) => {
+    if (node.type === "component" && node.componentName) {
+      if (isCraftComponent(node.componentName))
+        nativeComponents.push(node.componentName);
+    }
+    if (node.type === "element" && node.tag) {
+      const suggestion = suggestNativeWidget(node);
+      if (suggestion)
+        nativeWidgets.push(suggestion);
+      if (node.props) {
+        for (const [key, value] of Object.entries(node.props))
+          if (key.startsWith("on") && typeof value === "string") {
+            const handlerId = `handler_${eventHandlers.size}`;
+            eventHandlers.set(handlerId, value);
+          }
+      }
+    }
+    if (node.isStatic && node.type === "element")
+      staticHTML.push(renderNodeToHTML(node));
+    else if (!node.isStatic && node.type !== "text")
+      dynamicParts.push(node.tag || node.componentName || "unknown");
+  });
+  return {
+    nativeComponents,
+    staticHTML,
+    dynamicParts,
+    eventHandlers,
+    nativeWidgets
+  };
+}
+export function prerenderForCraft(template, context = {}) {
+  const compiled = compileTemplate(template), staticHTML = renderStaticParts(compiled, context), dynamicPlaceholders = new Map, craftComponents = [];
+  walkTree(compiled.tree, (node) => {
+    if (node.type === "component" && node.componentName) {
+      if (isCraftComponent(node.componentName)) {
+        craftComponents.push(node.componentName);
+        const placeholder = `<!--craft:${node.componentName}:${node.hydrationKey || "default"}-->`;
+        dynamicPlaceholders.set(node.hydrationKey || node.componentName, placeholder);
+      }
+    }
+  });
+  return {
+    staticHTML,
+    dynamicPlaceholders,
+    craftComponents
+  };
+}
+function parseTemplateToTree(template) {
+  const root = {
+    type: "fragment",
+    children: []
+  };
+  let current = root;
+  const stack = [root];
+  let remaining = template;
+  const selfClosing = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  while (remaining.length > 0) {
+    const openMatch = remaining.match(/^<(@?[\w-]+)([^>]*)>/);
+    if (openMatch) {
+      const [full, tag, attrsStr] = openMatch, props = parseAttributes(attrsStr), isCraft = tag.startsWith("@craft-"), normalizedTag = isCraft ? tag : tag.toLowerCase(), node = {
+        type: isCraft ? "component" : "element",
+        tag: normalizedTag,
+        props,
+        children: [],
+        componentName: isCraft ? normalizedTag.slice(1) : void 0,
+        isStatic: !hasExpression(attrsStr),
+        hydrationKey: generateHydrationKey()
+      };
+      current.children = current.children || [];
+      current.children.push(node);
+      if (!selfClosing.has(normalizedTag) && !attrsStr.endsWith("/")) {
+        stack.push(node);
+        current = node;
+      }
+      remaining = remaining.slice(full.length);
+      continue;
+    }
+    const closeMatch = remaining.match(/^<\/(@?[\w-]+)>/);
+    if (closeMatch) {
+      const [full, tag] = closeMatch, normalizedTag = tag.startsWith("@craft-") ? tag : tag.toLowerCase();
+      while (stack.length > 1) {
+        const popped = stack.pop();
+        current = stack[stack.length - 1];
+        if (popped.tag === normalizedTag)
+          break;
+      }
+      remaining = remaining.slice(full.length);
+      continue;
+    }
+    const textMatch = remaining.match(/^[^<]+/);
+    if (textMatch) {
+      const text = textMatch[0];
+      if (text.trim()) {
+        const textNode = {
+          type: "text",
+          text,
+          isStatic: !hasExpression(text)
+        };
+        current.children = current.children || [];
+        current.children.push(textNode);
+      }
+      remaining = remaining.slice(text.length);
+      continue;
+    }
+    remaining = remaining.slice(1);
+  }
+  return root;
+}
+function parseAttributes(attrsStr) {
+  const props = {}, attrRegex = /([\w-:@]+)(?:=(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+  let match;
+  while ((match = attrRegex.exec(attrsStr)) !== null) {
+    const [, name, doubleQuoted, singleQuoted, unquoted] = match, value = doubleQuoted ?? singleQuoted ?? unquoted ?? !0;
+    props[name] = value;
+  }
+  return props;
+}
+function walkTree(node, callback, path = []) {
+  callback(node, path);
+  if (node.children)
+    node.children.forEach((child, index) => {
+      walkTree(child, callback, [...path, `${index}`]);
+    });
+}
+function renderTreeToHTML(node, context) {
+  switch (node.type) {
+    case "text":
+      return interpolateExpressions(node.text || "", context);
+    case "element":
+    case "component": {
+      const tag = node.tag || "div", attrs = renderAttributes(node.props || {}, context), children = (node.children || []).map((child) => renderTreeToHTML(child, context)).join("");
+      if (!node.children || node.children.length === 0) {
+        if (["input", "br", "hr", "img", "meta", "link"].includes(tag))
+          return `<${tag}${attrs} />`;
+      }
+      return `<${tag}${attrs}>${children}</${tag}>`;
+    }
+    case "fragment":
+      return (node.children || []).map((child) => renderTreeToHTML(child, context)).join("");
+    case "slot":
+      return `<!--slot:${node.slotName || "default"}-->`;
+    default:
+      return "";
+  }
+}
+function renderNodeToHTML(node) {
+  if (node.type === "text")
+    return node.text || "";
+  const tag = node.tag || "div", attrs = renderAttributes(node.props || {}, {});
+  return `<${tag}${attrs}></${tag}>`;
+}
+function renderAttributes(props, context) {
+  const attrs = [];
+  for (const [key, value] of Object.entries(props))
+    if (value === !0)
+      attrs.push(` ${key}`);
+    else if (value !== !1 && value !== null && value !== void 0) {
+      const strValue = interpolateExpressions(String(value), context);
+      attrs.push(` ${key}="${escapeHTML(strValue)}"`);
+    }
+  return attrs.join("");
+}
+async function renderTreeStreaming(node, context) {
+  return renderTreeToHTML(node, context);
+}
+function renderStaticParts(compiled, context) {
+  const parts = [];
+  walkTree(compiled.tree, (node) => {
+    if (node.isStatic)
+      parts.push(renderTreeToHTML(node, context));
+  });
+  return parts.join("");
+}
+function addHydrationMarkers(html, compiled, context) {
+  const data = {
+    templateId: compiled.id,
+    context,
+    dynamicParts: Array.from(compiled.dynamicParts.entries())
+  }, hydrationScript = `
+<script data-craft-hydration>
+  window.__CRAFT_HYDRATION__ = ${JSON.stringify(data)};
+</script>`;
+  return {
+    html: html + hydrationScript,
+    data
+  };
+}
+function analyzeTemplate(tree) {
+  let hasSlots = !1, hasDynamicContent = !1, hasEventHandlers = !1, hasAsyncContent = !1, componentCount = 0, maxDepth = 0;
+  function analyze(node, depth) {
+    maxDepth = Math.max(maxDepth, depth);
+    if (node.type === "slot")
+      hasSlots = !0;
+    if (node.type === "component")
+      componentCount++;
+    if (!node.isStatic)
+      hasDynamicContent = !0;
+    if (node.props)
+      for (const key of Object.keys(node.props)) {
+        if (key.startsWith("on"))
+          hasEventHandlers = !0;
+        if (key === "@async" || key === "data-async")
+          hasAsyncContent = !0;
+      }
+    if (node.children)
+      node.children.forEach((child) => analyze(child, depth + 1));
+  }
+  analyze(tree, 0);
+  return {
+    hasSlots,
+    hasDynamicContent,
+    hasEventHandlers,
+    hasAsyncContent,
+    componentCount,
+    maxDepth,
+    estimatedSize: JSON.stringify(tree).length
+  };
+}
+function partitionContent(tree) {
+  const staticParts = new Map, dynamicParts = new Map;
+  walkTree(tree, (node, path) => {
+    const key = path.join(".");
+    if (node.isStatic)
+      staticParts.set(key, renderNodeToHTML(node));
+    else
+      dynamicParts.set(key, node.tag || node.componentName || "dynamic");
+  });
+  return { staticParts, dynamicParts };
+}
+function extractScripts(template) {
+  const scripts = [], scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = scriptRegex.exec(template)) !== null)
+    scripts.push(match[1]);
+  return scripts;
+}
+function extractStyles(template) {
+  const styles = [], styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
+  let match;
+  while ((match = styleRegex.exec(template)) !== null)
+    styles.push(match[1]);
+  return styles;
+}
+function extractDependencies(template) {
+  const deps = [], includeRegex = /@include\s*\(\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = includeRegex.exec(template)) !== null)
+    deps.push(match[1]);
+  const componentRegex = /@component\s*\(\s*['"]([^'"]+)['"]/g;
+  while ((match = componentRegex.exec(template)) !== null)
+    deps.push(match[1]);
+  const craftRegex = /<@craft-[\w-]+/g;
+  while ((match = craftRegex.exec(template)) !== null)
+    deps.push(match[0].slice(2));
+  return [...new Set(deps)];
+}
+function hasExpression(str) {
+  return /\{\{.*?\}\}|\{\!\!.*?\!\!\}/.test(str);
+}
+function interpolateExpressions(str, context) {
+  let result = str.replace(/\{\{\s*(.+?)\s*\}\}/g, (_match, expr) => {
+    try {
+      const value = evaluateExpression(expr.trim(), context);
+      return escapeHTML(String(value ?? ""));
+    } catch {
+      return "";
+    }
+  });
+  result = result.replace(/\{!!\s*(.+?)\s*!!\}/g, (_match, expr) => {
+    try {
+      const value = evaluateExpression(expr.trim(), context);
+      return String(value ?? "");
+    } catch {
+      return "";
+    }
+  });
+  return result;
+}
+function evaluateExpression(expr, context) {
+  if (/^[\w.]+$/.test(expr)) {
+    const parts = expr.split(".");
+    let value = context;
+    for (const part of parts)
+      if (value && typeof value === "object" && part in value)
+        value = value[part];
+      else
+        return;
+    return value;
+  }
+  try {
+    return Function(...Object.keys(context), `return ${expr}`)(...Object.values(context));
+  } catch {
+    return;
+  }
+}
+function escapeHTML(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function minifyHTML(html) {
+  return html.replace(/\s+/g, " ").replace(/>\s+</g, "><").replace(/\s+>/g, ">").replace(/<\s+/g, "<").trim();
+}
+function generateTemplateId(template) {
+  let hash = 0;
+  for (let i = 0;i < template.length; i++) {
+    const char = template.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `tpl_${Math.abs(hash).toString(36)}`;
+}
+function generateHash(content) {
+  let hash = 0;
+  for (let i = 0;i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+let hydrationKeyCounter = 0;
+function generateHydrationKey() {
+  return `h_${++hydrationKeyCounter}`;
+}
+function isCraftComponent(name) {
+  return [
+    "craft-button",
+    "craft-text-input",
+    "craft-textarea",
+    "craft-checkbox",
+    "craft-radio",
+    "craft-select",
+    "craft-slider",
+    "craft-toggle",
+    "craft-date-picker",
+    "craft-time-picker",
+    "craft-color-picker",
+    "craft-file-input",
+    "craft-modal",
+    "craft-alert",
+    "craft-toast",
+    "craft-progress",
+    "craft-spinner",
+    "craft-avatar",
+    "craft-badge",
+    "craft-card",
+    "craft-accordion",
+    "craft-tabs",
+    "craft-tooltip",
+    "craft-popover",
+    "craft-dropdown",
+    "craft-context-menu",
+    "craft-data-table",
+    "craft-virtual-list",
+    "craft-tree-view",
+    "craft-map",
+    "craft-chart",
+    "craft-video",
+    "craft-audio",
+    "craft-webview",
+    "craft-canvas",
+    "craft-image-viewer",
+    "craft-pdf-viewer",
+    "craft-code-editor",
+    "craft-rich-editor"
+  ].includes(name);
+}
+function suggestNativeWidget(node) {
+  const tag = node.tag?.toLowerCase(), type = node.props?.type, suggestions = {
+    button: {
+      component: "craft-button",
+      confidence: 0.95,
+      reason: "Native button provides better touch feedback"
+    },
+    "input:text": {
+      component: "craft-text-input",
+      confidence: 0.9,
+      reason: "Native text input has better keyboard handling"
+    },
+    "input:checkbox": {
+      component: "craft-checkbox",
+      confidence: 0.95,
+      reason: "Native checkbox follows platform conventions"
+    },
+    "input:range": {
+      component: "craft-slider",
+      confidence: 0.9,
+      reason: "Native slider provides smooth interaction"
+    },
+    "input:date": {
+      component: "craft-date-picker",
+      confidence: 0.95,
+      reason: "Native date picker provides platform-specific UI"
+    },
+    "input:time": {
+      component: "craft-time-picker",
+      confidence: 0.95,
+      reason: "Native time picker provides platform-specific UI"
+    },
+    "input:color": {
+      component: "craft-color-picker",
+      confidence: 0.9,
+      reason: "Native color picker provides platform-specific UI"
+    },
+    textarea: {
+      component: "craft-textarea",
+      confidence: 0.85,
+      reason: "Native textarea handles multiline input better"
+    },
+    select: {
+      component: "craft-select",
+      confidence: 0.9,
+      reason: "Native select provides platform dropdown UI"
+    },
+    progress: {
+      component: "craft-progress",
+      confidence: 0.95,
+      reason: "Native progress bar matches platform style"
+    },
+    video: {
+      component: "craft-video",
+      confidence: 0.95,
+      reason: "Native video provides hardware acceleration"
+    },
+    audio: {
+      component: "craft-audio",
+      confidence: 0.95,
+      reason: "Native audio provides system integration"
+    },
+    dialog: {
+      component: "craft-modal",
+      confidence: 0.9,
+      reason: "Native modal provides proper layering and focus"
+    }
+  }, key = type ? `${tag}:${type}` : tag, suggestion = suggestions[key || ""] || suggestions[tag || ""];
+  if (suggestion)
+    return {
+      htmlSelector: key || tag || "",
+      nativeComponent: suggestion.component,
+      confidence: suggestion.confidence,
+      reason: suggestion.reason
+    };
+  return null;
+}
+export function clearTemplateCache() {
+  templateCache.clear();
+}
+export function clearRenderCache() {
+  renderCache.clear();
+}
+export function clearAllCaches() {
+  clearTemplateCache();
+  clearRenderCache();
+}
+export function getSSRCacheStats() {
+  return {
+    templateCacheSize: templateCache.size,
+    renderCacheSize: renderCache.size,
+    totalEntries: templateCache.size + renderCache.size
+  };
+}
+const craftSSR = {
+  compileTemplate,
+  renderSSR,
+  generateCraftOptimizations,
+  prerenderForCraft,
+  clearTemplateCache,
+  clearRenderCache,
+  clearAllCaches,
+  getSSRCacheStats
+};
+export default craftSSR;