@stacksjs/stx 0.2.94 → 0.2.96

package/dist/suspense.js

@@ -1,2 +1,398 @@
-// @bun
-import{Gf as a,Hf as b,If as c,Jf as d,Kf as e}from"./chunk-fs0qezn5.js";import"./chunk-3jm3snz8.js";export{c as renderSSRSuspense,a as processSuspenseDirectives,e as generateSuspenseRuntime,d as generateSuspenseCSS,b as createSSRSuspense};
+let suspenseIdCounter = 0;
+function generateSuspenseId() {
+  return `suspense-${++suspenseIdCounter}-${Date.now().toString(36)}`;
+}
+export function processSuspenseDirectives(template, _context = {}, _filePath) {
+  const suspenseRegex = /@suspense(?:\s*\(([^)]*)\))?\s*([\s\S]*?)@fallback\s*([\s\S]*?)@endsuspense/gi;
+  return template.replace(suspenseRegex, (_match, optionsStr, content, fallback) => {
+    const suspenseId = generateSuspenseId(), options = parseSuspenseOptions(optionsStr || "");
+    return generateSuspenseHtml(suspenseId, content.trim(), fallback.trim(), options);
+  });
+}
+function parseSuspenseOptions(optionsStr) {
+  const options = {}, keyValueRegex = /(\w+)\s*:\s*(?:'([^']*)'|"([^"]*)"|(\d+)|(\w+))/g;
+  let match;
+  while ((match = keyValueRegex.exec(optionsStr)) !== null) {
+    const key = match[1], strValue = match[2] || match[3], numValue = match[4];
+    switch (key) {
+      case "id":
+        options.id = strValue;
+        break;
+      case "timeout":
+        options.timeout = numValue ? parseInt(numValue, 10) : void 0;
+        break;
+    }
+  }
+  return options;
+}
+function generateSuspenseHtml(suspenseId, content, fallback, options) {
+  const timeout = options.timeout || 30000, customId = options.id || suspenseId;
+  return `
+<div class="stx-suspense" data-suspense-id="${suspenseId}" data-custom-id="${customId}" data-status="pending">
+  <div class="stx-suspense-fallback" data-suspense-fallback="${suspenseId}">
+    ${fallback}
+  </div>
+  <div class="stx-suspense-content" data-suspense-content="${suspenseId}" style="display: none;">
+    ${content}
+  </div>
+</div>
+<script>
+(function() {
+  const suspenseId = '${suspenseId}';
+  const customId = '${customId}';
+  const timeout = ${timeout};
+
+  const container = document.querySelector('[data-suspense-id="' + suspenseId + '"]');
+  const fallbackEl = document.querySelector('[data-suspense-fallback="' + suspenseId + '"]');
+  const contentEl = document.querySelector('[data-suspense-content="' + suspenseId + '"]');
+
+  if (!container || !fallbackEl || !contentEl) return;
+
+  // State
+  const pending = new Set();
+  const resolved = new Set();
+  let status = 'pending';
+  let error = null;
+  let timeoutTimer = null;
+
+  // Update UI based on state
+  function updateUI() {
+    container.setAttribute('data-status', status);
+
+    if (status === 'resolved') {
+      fallbackEl.style.display = 'none';
+      contentEl.style.display = '';
+    }
+else if (status === 'rejected') {
+      fallbackEl.style.display = 'none';
+      contentEl.style.display = '';
+      // Show error in content area if needed
+    }
+else {
+      fallbackEl.style.display = '';
+      contentEl.style.display = 'none';
+    }
+  }
+
+  // Check if all children are resolved
+  function checkResolved() {
+    if (pending.size === 0 && resolved.size > 0) {
+      clearTimeout(timeoutTimer);
+      status = 'resolved';
+      updateUI();
+
+      container.dispatchEvent(new CustomEvent('stx:suspense:resolved', {
+        detail: { suspenseId: suspenseId, customId: customId },
+        bubbles: true
+      }));
+    }
+  }
+
+  // Register an async child
+  function register(childId) {
+    if (status === 'resolved') {
+      // Reset if we get a new child after resolution
+      status = 'pending';
+      updateUI();
+    }
+    pending.add(childId);
+
+    // Start timeout on first registration
+    if (pending.size === 1 && !timeoutTimer) {
+      timeoutTimer = setTimeout(function() {
+        if (status === 'pending') {
+          error = new Error('Suspense timeout after ' + timeout + 'ms');
+          status = 'rejected';
+          updateUI();
+
+          container.dispatchEvent(new CustomEvent('stx:suspense:timeout', {
+            detail: { suspenseId: suspenseId, customId: customId, pending: Array.from(pending) },
+            bubbles: true
+          }));
+        }
+      }, timeout);
+    }
+  }
+
+  // Resolve a child
+  function resolve(childId) {
+    pending.delete(childId);
+    resolved.add(childId);
+    checkResolved();
+  }
+
+  // Reject a child
+  function reject(childId, err) {
+    pending.delete(childId);
+    error = err;
+    status = 'rejected';
+    clearTimeout(timeoutTimer);
+    updateUI();
+
+    container.dispatchEvent(new CustomEvent('stx:suspense:error', {
+      detail: { suspenseId: suspenseId, customId: customId, error: err, childId: childId },
+      bubbles: true
+    }));
+  }
+
+  // Reset the boundary
+  function reset() {
+    pending.clear();
+    resolved.clear();
+    status = 'pending';
+    error = null;
+    clearTimeout(timeoutTimer);
+    timeoutTimer = null;
+    updateUI();
+  }
+
+  // Expose API globally for async components to use
+  window.STX = window.STX || {};
+  window.STX.suspense = window.STX.suspense || {
+    boundaries: {},
+    // Find the nearest suspense boundary for a child
+    findBoundary: function(element) {
+      const boundary = element.closest('[data-suspense-id]');
+      if (boundary) {
+        return boundary.getAttribute('data-suspense-id');
+      }
+      return null;
+    },
+    register: function(childId, boundaryId) {
+      if (!boundaryId) {
+        // Find nearest boundary
+        const asyncEl = document.querySelector('[data-async-id="' + childId + '"]');
+        if (asyncEl) {
+          boundaryId = this.findBoundary(asyncEl);
+        }
+      }
+      if (boundaryId && this.boundaries[boundaryId]) {
+        this.boundaries[boundaryId].register(childId);
+      }
+    },
+    resolve: function(childId, boundaryId) {
+      if (!boundaryId) {
+        const asyncEl = document.querySelector('[data-async-id="' + childId + '"]');
+        if (asyncEl) {
+          boundaryId = this.findBoundary(asyncEl);
+        }
+      }
+      if (boundaryId && this.boundaries[boundaryId]) {
+        this.boundaries[boundaryId].resolve(childId);
+      }
+    },
+    reject: function(childId, error, boundaryId) {
+      if (!boundaryId) {
+        const asyncEl = document.querySelector('[data-async-id="' + childId + '"]');
+        if (asyncEl) {
+          boundaryId = this.findBoundary(asyncEl);
+        }
+      }
+      if (boundaryId && this.boundaries[boundaryId]) {
+        this.boundaries[boundaryId].reject(childId, error);
+      }
+    }
+  };
+
+  // Register this boundary
+  window.STX.suspense.boundaries[suspenseId] = {
+    id: suspenseId,
+    customId: customId,
+    getStatus: function() { return status; },
+    getPending: function() { return Array.from(pending); },
+    getResolved: function() { return Array.from(resolved); },
+    getError: function() { return error; },
+    register: register,
+    resolve: resolve,
+    reject: reject,
+    reset: reset
+  };
+
+  // Initial state - if no async children register within a tick, show content
+  setTimeout(function() {
+    if (pending.size === 0 && resolved.size === 0) {
+      status = 'resolved';
+      updateUI();
+    }
+  }, 0);
+})();
+</script>
+`;
+}
+export function createSSRSuspense(id, contentPromise, fallback) {
+  return {
+    id,
+    fallback,
+    content: contentPromise
+  };
+}
+export async function renderSSRSuspense(boundaries) {
+  const initial = boundaries.map((b) => `
+<div id="stx-ssr-suspense-${b.id}" class="stx-ssr-suspense">
+  ${b.fallback}
+</div>
+`).join(`
+`);
+  async function* streamContent() {
+    for (const boundary of boundaries)
+      try {
+        const content = await boundary.content;
+        yield `
+<script>
+(function() {
+  const el = document.getElementById('stx-ssr-suspense-${boundary.id}');
+  if (el) {
+    el.innerHTML = ${JSON.stringify(content)};
+    el.classList.add('stx-ssr-suspense-resolved');
+  }
+})();
+</script>
+`;
+      } catch (error) {
+        yield `
+<script>
+(function() {
+  const el = document.getElementById('stx-ssr-suspense-${boundary.id}');
+  if (el) {
+    el.classList.add('stx-ssr-suspense-error');
+    console.error('SSR Suspense error for ${boundary.id}:', ${JSON.stringify(String(error))});
+  }
+})();
+</script>
+`;
+      }
+  }
+  return {
+    initial,
+    streaming: streamContent()
+  };
+}
+export function generateSuspenseCSS() {
+  return `
+/* STX Suspense Styles */
+.stx-suspense {
+  position: relative;
+}
+
+.stx-suspense[data-status="pending"] .stx-suspense-fallback {
+  display: block;
+}
+
+.stx-suspense[data-status="pending"] .stx-suspense-content {
+  display: none;
+}
+
+.stx-suspense[data-status="resolved"] .stx-suspense-fallback {
+  display: none;
+}
+
+.stx-suspense[data-status="resolved"] .stx-suspense-content {
+  display: block;
+}
+
+/* SSR Suspense */
+.stx-ssr-suspense {
+  transition: opacity 0.3s ease;
+}
+
+.stx-ssr-suspense-resolved {
+  animation: stx-suspense-fade-in 0.3s ease;
+}
+
+@keyframes stx-suspense-fade-in {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+/* Skeleton fallback helper */
+.stx-suspense-skeleton {
+  background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
+  background-size: 200% 100%;
+  animation: stx-suspense-shimmer 1.5s infinite;
+  border-radius: 0.25rem;
+}
+
+@keyframes stx-suspense-shimmer {
+  0% { background-position: 200% 0; }
+  100% { background-position: -200% 0; }
+}
+
+/* Dark mode */
+@media (prefers-color-scheme: dark) {
+  .stx-suspense-skeleton {
+    background: linear-gradient(90deg, #374151 25%, #4b5563 50%, #374151 75%);
+    background-size: 200% 100%;
+  }
+}
+`;
+}
+export function generateSuspenseRuntime() {
+  return `
+// STX Suspense Runtime
+(function() {
+  if (typeof window === 'undefined') return;
+
+  window.STX = window.STX || {};
+
+  // Suspense boundary management is set up per-boundary in the HTML
+  // This just provides additional utilities
+
+  window.STX.suspense = window.STX.suspense || {
+    boundaries: {},
+    findBoundary: function(element) {
+      const boundary = element.closest('[data-suspense-id]');
+      return boundary ? boundary.getAttribute('data-suspense-id') : null;
+    },
+    register: function(childId, boundaryId) {},
+    resolve: function(childId, boundaryId) {},
+    reject: function(childId, error, boundaryId) {}
+  };
+
+  // Wait for all suspense boundaries to resolve
+  window.STX.suspense.waitForAll = function() {
+    return new Promise(function(resolve, reject) {
+      const boundaries = Object.values(window.STX.suspense.boundaries);
+      if (boundaries.length === 0) {
+        resolve();
+        return;
+      }
+
+      let resolved = 0;
+      let rejected = false;
+
+      boundaries.forEach(function(boundary) {
+        if (boundary.getStatus() === 'resolved') {
+          resolved++;
+          if (resolved === boundaries.length) resolve();
+        }
+else if (boundary.getStatus() === 'rejected') {
+          if (!rejected) {
+            rejected = true;
+            reject(boundary.getError());
+          }
+        }
+else {
+          // Listen for resolution
+          const container = document.querySelector('[data-suspense-id="' + boundary.id + '"]');
+          if (container) {
+            container.addEventListener('stx:suspense:resolved', function() {
+              resolved++;
+              if (resolved === boundaries.length && !rejected) resolve();
+            }, { once: true });
+
+            container.addEventListener('stx:suspense:error', function(e) {
+              if (!rejected) {
+                rejected = true;
+                reject(e.detail.error);
+              }
+            }, { once: true });
+          }
+        }
+      });
+    });
+  };
+
+  console.log('[stx] Suspense runtime initialized');
+})();
+`;
+}

package/dist/teleport.js

@@ -1,2 +1,109 @@
-// @bun
-import{Lf as a,Mf as b}from"./chunk-0m9tdm7t.js";import"./chunk-3jm3snz8.js";export{a as processTeleportDirectives,b as ensureTeleportTargets};
+let teleportCounter = 0;
+function generateTeleportId() {
+  return `stx-teleport-${++teleportCounter}`;
+}
+function parseTeleportArgs(args) {
+  const parts = args.split(",").map((p) => p.trim()), target = parts[0].replace(/['"]/g, "");
+  let disabled;
+  for (let i = 1;i < parts.length; i++) {
+    const disabledMatch = parts[i].match(/disabled:\s*(.+)/);
+    if (disabledMatch)
+      disabled = disabledMatch[1].trim();
+  }
+  return { target, disabled };
+}
+function generateTeleportScript(id, target) {
+  return `
+    <script>
+    (function() {
+      const source = document.getElementById('${id}');
+      if (!source) return;
+
+      // Get the content template up-front so we can hold a reference for the
+      // retry path. (template.content is moved out by cloneNode below.)
+      const template = source.querySelector('template');
+      if (!template) return;
+
+      function mount(targetEl) {
+        // Clone the template content and wrap it for tracking.
+        const content = template.content.cloneNode(true);
+        const wrapper = document.createElement('div');
+        wrapper.setAttribute('data-teleport-from', '${id}');
+        wrapper.appendChild(content);
+
+        targetEl.appendChild(wrapper);
+
+        // Remove the source placeholder
+        source.remove();
+
+        wrapper.dispatchEvent(new CustomEvent('teleport:mounted', {
+          bubbles: true,
+          detail: { sourceId: '${id}', target: '${target}' }
+        }));
+      }
+
+      // The teleport script runs inline at the position it's emitted. If the
+      // target is declared later in the same render pass (e.g. by a layout
+      // shell whose onMount creates the portal root), the first lookup
+      // misses. Pre-fix (stacksjs/stx#1728) the script bailed with a warning
+      // and never tried again. Now retry once via requestAnimationFrame so
+      // targets that land in the same paint cycle still work. A second
+      // miss is still a warning \u2014 we don't loop forever.
+      const firstEl = document.querySelector('${target}');
+      if (firstEl) { mount(firstEl); return; }
+
+      requestAnimationFrame(function() {
+        const retryEl = document.querySelector('${target}');
+        if (retryEl) { mount(retryEl); return; }
+        console.warn('[stx] Teleport target not found: ${target}');
+      });
+    })();
+    </script>
+  `;
+}
+export function processTeleportDirectives(template, context, _filePath) {
+  teleportCounter = 0;
+  const teleportRegex = /@teleport\s*\(([^)]+)\)\s*([\s\S]*?)@endteleport/g;
+  return template.replace(teleportRegex, (fullMatch, args, body) => {
+    const id = generateTeleportId(), { target, disabled } = parseTeleportArgs(args), content = body.trim();
+    if (disabled)
+      try {
+        let isDisabled = !1;
+        if (disabled === "true")
+          isDisabled = !0;
+        else if (disabled === "false")
+          isDisabled = !1;
+        else if (disabled in context)
+          isDisabled = Boolean(context[disabled]);
+        if (isDisabled)
+          return `<div class="stx-teleport-inline" data-teleport-disabled>${content}</div>`;
+      } catch {}
+    const script = generateTeleportScript(id, target);
+    return `
+      <div id="${id}" class="stx-teleport-source" style="display: none;">
+        <template>${content}</template>
+      </div>
+      ${script}
+    `;
+  });
+}
+export function ensureTeleportTargets() {
+  return `
+    <script>
+    (function() {
+      // Common teleport targets
+      const targets = ['#stx-modals', '#stx-tooltips', '#stx-notifications'];
+
+      targets.forEach(selector => {
+        const id = selector.slice(1); // Remove #
+        if (!document.getElementById(id)) {
+          const el = document.createElement('div');
+          el.id = id;
+          el.setAttribute('data-teleport-container', '');
+          document.body.appendChild(el);
+        }
+      });
+    })();
+    </script>
+  `;
+}

package/dist/template-compiler.js

@@ -1,2 +1,63 @@
-// @bun
-import{Ci as a}from"./chunk-bjnjpsgn.js";import"./chunk-ncnfa8ae.js";import"./chunk-6djgb0hr.js";import"./chunk-w01y57f5.js";import"./chunk-x1hjv24z.js";import"./chunk-0g4gece6.js";import"./chunk-nap11ntr.js";import"./chunk-03c26pjz.js";import"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-ghrx0hn1.js";import"./chunk-82t27pvd.js";import"./chunk-fhawx87n.js";import"./chunk-gc84b1d2.js";import"./chunk-yr1gdceh.js";import"./chunk-baa7h4yz.js";import"./chunk-kdxa9epn.js";import"./chunk-g2hekckm.js";import"./chunk-x39sfpvm.js";import"./chunk-tr0z0e1g.js";import"./chunk-4j188175.js";import"./chunk-eds0f8f1.js";import"./chunk-dyjnn5k8.js";import"./chunk-8fgwhhb8.js";import"./chunk-tj6zfxeb.js";import"./chunk-7xcfy2fn.js";import"./chunk-9yz5d003.js";import"./chunk-fms20x0n.js";import"./chunk-fe7r1mq1.js";import"./chunk-rb1e4cnb.js";import"./chunk-j4s5qwd7.js";import"./chunk-b0cyc09a.js";import"./chunk-0tatqxj2.js";import"./chunk-bykjk6vj.js";import"./chunk-7b0xdy5h.js";import"./chunk-ywkrxp2h.js";import"./chunk-y25pr13j.js";import"./chunk-q6h6yvzb.js";import"./chunk-qdc3aav1.js";import"./chunk-6wn85hn6.js";import"./chunk-qd5461tt.js";import"./chunk-77tga15w.js";import"./chunk-rv002yn0.js";import"./chunk-hke99a0v.js";import"./chunk-mwbng54r.js";import"./chunk-wxvyj65q.js";import"./chunk-yw2fzq86.js";import"./chunk-mrehzhxv.js";import"./chunk-1zgsgk4b.js";import"./chunk-48cw2nde.js";import"./chunk-jjvp4t5w.js";import"./chunk-94g3cahw.js";import"./chunk-ht4j68cs.js";import"./chunk-fch9tk1k.js";import"./chunk-cz25azze.js";import"./chunk-q60knhjf.js";import"./chunk-hrampcrj.js";import"./chunk-t37dp99j.js";import"./chunk-5kt3ay7x.js";import"./chunk-95w08s8v.js";import"./chunk-ceg2c2q2.js";import"./chunk-04mvcmcr.js";import"./chunk-n46a5g1g.js";import"./chunk-vv9wfz1c.js";import"./chunk-dzw95th7.js";import"./chunk-46mkpbkk.js";import"./chunk-3rh7va1z.js";import"./chunk-2xen423s.js";import"./chunk-cp3kwv17.js";import"./chunk-hpqr9e3x.js";import"./chunk-adqh2m9z.js";import"./chunk-8qbax8xn.js";import"./chunk-x64kb787.js";import"./chunk-gcf5v18y.js";import"./chunk-pc31m5x5.js";import"./chunk-3jm3snz8.js";export{a as compileTemplate};
+import path from "node:path";
+import { processDirectives } from "./process.js";
+import { defaultConfig, loadStxConfig } from "./config.js";
+import { extractVariables } from "./variable-extractor.js";
+import { createPlaceholder, resetPlaceholders, getPlaceholderRegistry } from "./placeholder.js";
+import { stripDocumentWrapper } from "./app-shell.js";
+import { createHash } from "node:crypto";
+function createRecordingContext(baseContext = {}) {
+  const accessedKeys = new Set;
+  return { context: new Proxy(baseContext, {
+    get(target, prop) {
+      if (prop in target)
+        return target[prop];
+      if (typeof prop === "string" && !prop.startsWith("__"))
+        accessedKeys.add(prop);
+      return;
+    },
+    has(target, prop) {
+      if (prop in target)
+        return !0;
+      if (typeof prop === "string" && !prop.startsWith("__"))
+        accessedKeys.add(prop);
+      return !1;
+    }
+  }), accessedKeys };
+}
+export async function compileTemplate(filePath, route, options = {}) {
+  const absolutePath = path.resolve(filePath), content = await Bun.file(absolutePath).text(), contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+  resetPlaceholders();
+  let projectConfig = {};
+  try {
+    projectConfig = await loadStxConfig();
+  } catch {}
+  const serverScriptContent = [], scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+  let scriptMatch;
+  while ((scriptMatch = scriptRegex.exec(content)) !== null) {
+    const attrs = scriptMatch[1];
+    if (/\bserver\b/.test(attrs))
+      serverScriptContent.push(scriptMatch[2]);
+  }
+  const { context } = createRecordingContext({
+    __filename: absolutePath,
+    __dirname: path.dirname(absolutePath)
+  }), dependencies = new Set, opts = {
+    ...defaultConfig,
+    ...projectConfig,
+    ...options,
+    buildMode: "compile",
+    strict: !1
+  }, html = await processDirectives(content, context, absolutePath, opts, dependencies), fragment = stripDocumentWrapper(html), placeholders = getPlaceholderRegistry();
+  return {
+    route,
+    sourceFile: filePath,
+    html,
+    fragment,
+    placeholders,
+    hasServerScripts: serverScriptContent.length > 0,
+    serverScriptContent,
+    dependencies: Array.from(dependencies),
+    contentHash,
+    streamTemplates: context.__streamTemplates
+  };
+}

package/dist/template-hydrator.js

@@ -1,2 +1,82 @@
-// @bun
-import{Li as a,Mi as b,Ni as c}from"./chunk-qfwzdffx.js";import"./chunk-w01y57f5.js";import"./chunk-x1hjv24z.js";import"./chunk-0g4gece6.js";import"./chunk-nap11ntr.js";import"./chunk-03c26pjz.js";import"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-ghrx0hn1.js";import"./chunk-82t27pvd.js";import"./chunk-fhawx87n.js";import"./chunk-gc84b1d2.js";import"./chunk-yr1gdceh.js";import"./chunk-baa7h4yz.js";import"./chunk-kdxa9epn.js";import"./chunk-g2hekckm.js";import"./chunk-x39sfpvm.js";import"./chunk-tr0z0e1g.js";import"./chunk-4j188175.js";import"./chunk-eds0f8f1.js";import"./chunk-dyjnn5k8.js";import"./chunk-8fgwhhb8.js";import"./chunk-tj6zfxeb.js";import"./chunk-7xcfy2fn.js";import"./chunk-9yz5d003.js";import"./chunk-fms20x0n.js";import"./chunk-fe7r1mq1.js";import"./chunk-rb1e4cnb.js";import"./chunk-j4s5qwd7.js";import"./chunk-b0cyc09a.js";import"./chunk-0tatqxj2.js";import"./chunk-bykjk6vj.js";import"./chunk-7b0xdy5h.js";import"./chunk-ywkrxp2h.js";import"./chunk-y25pr13j.js";import"./chunk-q6h6yvzb.js";import"./chunk-qdc3aav1.js";import"./chunk-6wn85hn6.js";import"./chunk-qd5461tt.js";import"./chunk-77tga15w.js";import"./chunk-rv002yn0.js";import"./chunk-hke99a0v.js";import"./chunk-mwbng54r.js";import"./chunk-wxvyj65q.js";import"./chunk-yw2fzq86.js";import"./chunk-mrehzhxv.js";import"./chunk-1zgsgk4b.js";import"./chunk-48cw2nde.js";import"./chunk-jjvp4t5w.js";import"./chunk-94g3cahw.js";import"./chunk-ht4j68cs.js";import"./chunk-fch9tk1k.js";import"./chunk-cz25azze.js";import"./chunk-q60knhjf.js";import"./chunk-hrampcrj.js";import"./chunk-t37dp99j.js";import"./chunk-5kt3ay7x.js";import"./chunk-95w08s8v.js";import"./chunk-ceg2c2q2.js";import"./chunk-04mvcmcr.js";import"./chunk-n46a5g1g.js";import"./chunk-vv9wfz1c.js";import"./chunk-dzw95th7.js";import"./chunk-46mkpbkk.js";import"./chunk-3rh7va1z.js";import"./chunk-2xen423s.js";import"./chunk-cp3kwv17.js";import"./chunk-hpqr9e3x.js";import"./chunk-adqh2m9z.js";import"./chunk-8qbax8xn.js";import"./chunk-x64kb787.js";import"./chunk-gcf5v18y.js";import"./chunk-pc31m5x5.js";import"./chunk-3jm3snz8.js";export{b as hydrateTemplateStream,a as hydrateTemplate,c as hydrateFragment};
+import { extractVariables } from "./variable-extractor.js";
+import { evaluateExpression, escapeHtml } from "./expressions.js";
+import { replacePlaceholders, hasPlaceholders } from "./placeholder.js";
+export async function hydrateTemplate(compiled, requestContext = {}) {
+  return (await runHydration(compiled, requestContext)).html;
+}
+export async function hydrateTemplateStream(compiled, requestContext = {}) {
+  const { html, context } = await runHydration(compiled, requestContext), { extractStreamBoundaries } = await import("./streaming.js");
+  let boundaries = extractStreamBoundaries(context);
+  const templates = compiled.streamTemplates;
+  if (templates && Object.keys(templates).length > 0) {
+    const { processDirectives } = await import("./process.js"), { defaultConfig } = await import("./config.js"), dataFns = context.streamBoundaries || {}, fragmentConfig = { ...defaultConfig, autoShell: !1 }, tplBoundaries = Object.keys(templates).map((id) => ({
+      id,
+      render: async () => {
+        const data = typeof dataFns[id] === "function" ? await dataFns[id]() : void 0;
+        return processDirectives(templates[id], { ...context, $boundary: data }, compiled.sourceFile, fragmentConfig, new Set);
+      }
+    })), tplIds = new Set(tplBoundaries.map((b) => b.id));
+    boundaries = [...(boundaries || []).filter((b) => !tplIds.has(b.id)), ...tplBoundaries];
+  }
+  return { html, boundaries: boundaries && boundaries.length > 0 ? boundaries : void 0 };
+}
+async function runHydration(compiled, requestContext) {
+  const context = {
+    __filename: compiled.sourceFile,
+    __dirname: compiled.sourceFile.replace(/[/\\][^/\\]+$/, ""),
+    ...requestContext
+  };
+  if (!compiled.hasServerScripts && !hasPlaceholders(compiled.html))
+    return { html: compiled.html, context };
+  for (const scriptContent of compiled.serverScriptContent)
+    try {
+      await extractVariables(scriptContent, context, compiled.sourceFile);
+    } catch (error) {
+      console.warn(`[stx] Server script error in ${compiled.sourceFile}:`, error);
+    }
+  if (!hasPlaceholders(compiled.html))
+    return { html: compiled.html, context };
+  const values = new Map;
+  for (const [token, info] of Object.entries(compiled.placeholders))
+    if (info.expression)
+      try {
+        const value = evaluateExpression(info.expression, context);
+        if (info.type === "raw")
+          values.set(token, value !== void 0 && value !== null ? String(value) : "");
+        else
+          values.set(token, value !== void 0 && value !== null ? escapeHtml(String(value)) : "");
+      } catch {
+        values.set(token, "");
+      }
+  return { html: replacePlaceholders(compiled.html, values), context };
+}
+export async function hydrateFragment(compiled, requestContext = {}) {
+  if (!compiled.hasServerScripts && !hasPlaceholders(compiled.fragment))
+    return compiled.fragment;
+  const context = {
+    __filename: compiled.sourceFile,
+    __dirname: compiled.sourceFile.replace(/[/\\][^/\\]+$/, ""),
+    ...requestContext
+  };
+  for (const scriptContent of compiled.serverScriptContent)
+    try {
+      await extractVariables(scriptContent, context, compiled.sourceFile);
+    } catch (error) {
+      console.warn(`[stx] Server script error in ${compiled.sourceFile}:`, error);
+    }
+  if (!hasPlaceholders(compiled.fragment))
+    return compiled.fragment;
+  const values = new Map;
+  for (const [token, info] of Object.entries(compiled.placeholders))
+    if (info.expression)
+      try {
+        const value = evaluateExpression(info.expression, context);
+        if (info.type === "raw")
+          values.set(token, value !== void 0 && value !== null ? String(value) : "");
+        else
+          values.set(token, value !== void 0 && value !== null ? escapeHtml(String(value)) : "");
+      } catch {
+        values.set(token, "");
+      }
+  return replacePlaceholders(compiled.fragment, values);
+}