@stacksjs/stx 0.2.95 → 0.2.97

package/dist/serve.js

@@ -1,2 +1,237 @@
-// @bun
-import{jh as a,kh as b,lh as c,mh as d,nh as e}from"./chunk-y6xsqe9a.js";import"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{c as serveFile,b as serve,a as htmlResponse,e as createRoute,d as createMiddleware};
+import { serve as bunServe } from "bun";
+import fs from "node:fs";
+import path from "node:path";
+import { readMarkdownFile } from "./assets.js";
+import { processDirectives } from "./process.js";
+import { extractVariables } from "./utils.js";
+export function htmlResponse(html, status = 200, headers = {}) {
+  return new Response(html, {
+    status,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...headers
+    }
+  });
+}
+export async function serve(options = {}) {
+  const {
+    port = 3000,
+    root = ".",
+    stxOptions = {},
+    watch = !0,
+    onRequest,
+    routes = {},
+    middleware = [],
+    on404,
+    onError
+  } = options, rootDir = path.resolve(root), fileCache = new Map;
+  async function processStxFile(filePath) {
+    const stats = fs.statSync(filePath), cacheKey = `${filePath}:${stats.mtimeMs}`, cached = fileCache.get(cacheKey);
+    if (cached)
+      return cached.content;
+    for (const key of fileCache.keys())
+      if (key.startsWith(`${filePath}:`) && key !== cacheKey)
+        fileCache.delete(key);
+    let content = await Bun.file(filePath).text(), workingContent = content;
+    const templateOpenMatch = content.match(/<template\b(?![^>]*(?:\b(?:id|x-for|x-if|@for|@if|:for|:if)\s*=|\s#[\w-]|\bv-slot|\bslot\s*=))[^>]*>/i);
+    if (templateOpenMatch && templateOpenMatch.index !== void 0) {
+      const contentStart = templateOpenMatch.index + templateOpenMatch[0].length;
+      let depth = 1, pos = contentStart;
+      while (pos < content.length && depth > 0) {
+        const openIdx = content.indexOf("<template", pos), closeIdx = content.indexOf("</template>", pos);
+        if (closeIdx === -1)
+          break;
+        if (openIdx !== -1 && openIdx < closeIdx) {
+          depth++;
+          pos = openIdx + 9;
+        } else {
+          depth--;
+          if (depth === 0) {
+            workingContent = content.substring(contentStart, closeIdx).trim();
+            break;
+          }
+          pos = closeIdx + 11;
+        }
+      }
+    }
+    const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi, clientScripts = [], serverScripts = [];
+    let scriptMatch;
+    while ((scriptMatch = scriptRegex.exec(content)) !== null) {
+      const attrs = scriptMatch[1], scriptContent = scriptMatch[2], fullScript = scriptMatch[0];
+      if (attrs.includes("server"))
+        serverScripts.push(scriptContent);
+      else
+        clientScripts.push(fullScript);
+    }
+    const styleMatches = content.match(/<style\b[^>]*>[\s\S]*?<\/style>/gi) || [];
+    let templateContent = workingContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+    const context = {
+      __filename: filePath,
+      __dirname: path.dirname(filePath)
+    };
+    for (const scriptContent of serverScripts)
+      await extractVariables(scriptContent, context, filePath);
+    let output = await processDirectives(templateContent, context, filePath, stxOptions, new Set);
+    if (styleMatches.length > 0) {
+      const stylesHtml = styleMatches.join(`
+`);
+      if (output.match(/(<\/head>)/i))
+        output = output.replace(/(<\/head>)/i, `${stylesHtml}
+$1`);
+    }
+    if (clientScripts.length > 0) {
+      const { interpolateScriptsInTemplate } = await import("./expressions.js"), scriptsHtml = interpolateScriptsInTemplate(clientScripts.join(`
+`), context);
+      if (output.match(/(<\/body>)/i))
+        output = output.replace(/(<\/body>)/i, `${scriptsHtml}
+$1`);
+      else
+        output += `
+${scriptsHtml}`;
+    }
+    fileCache.set(cacheKey, { content: output, mtime: stats.mtimeMs });
+    return output;
+  }
+  async function processMarkdownFile(filePath) {
+    const stats = fs.statSync(filePath), cacheKey = `${filePath}:${stats.mtimeMs}`, cached = fileCache.get(cacheKey);
+    if (cached)
+      return cached.content;
+    const { content } = await readMarkdownFile(filePath, stxOptions);
+    fileCache.set(cacheKey, { content, mtime: stats.mtimeMs });
+    return content;
+  }
+  function resolveRequestPath(pathname) {
+    const relPath = pathname.startsWith("/") ? pathname.slice(1) : pathname, possiblePaths = [
+      relPath,
+      `${relPath}.stx`,
+      `${relPath}.md`,
+      `${relPath}.html`,
+      path.join(relPath, "index.stx"),
+      path.join(relPath, "index.md"),
+      path.join(relPath, "index.html")
+    ];
+    for (const possiblePath of possiblePaths) {
+      const fullPath = path.join(rootDir, possiblePath);
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile())
+        return fullPath;
+    }
+    return null;
+  }
+  async function handleRequest(request) {
+    const url = new URL(request.url);
+    let next = async () => {
+      if (routes[url.pathname])
+        return await routes[url.pathname](request);
+      if (onRequest) {
+        const customResponse = await onRequest(request);
+        if (customResponse)
+          return customResponse;
+      }
+      const filePath = resolveRequestPath(url.pathname);
+      if (!filePath) {
+        if (on404)
+          return await on404(request);
+        return new Response("Not Found", { status: 404 });
+      }
+      try {
+        let content, contentType = "text/html";
+        if (filePath.endsWith(".stx"))
+          content = await processStxFile(filePath);
+        else if (filePath.endsWith(".md"))
+          content = await processMarkdownFile(filePath);
+        else if (filePath.endsWith(".html"))
+          content = await Bun.file(filePath).text();
+        else if (filePath.endsWith(".css")) {
+          content = await Bun.file(filePath).text();
+          contentType = "text/css";
+        } else if (filePath.endsWith(".js")) {
+          content = await Bun.file(filePath).text();
+          contentType = "text/javascript";
+        } else if (filePath.endsWith(".json")) {
+          content = await Bun.file(filePath).text();
+          contentType = "application/json";
+        } else
+          return new Response(Bun.file(filePath));
+        return new Response(content, {
+          headers: { "Content-Type": contentType }
+        });
+      } catch (error) {
+        if (onError)
+          return await onError(error, request);
+        const msg = error instanceof Error ? error.message : String(error), body = stxOptions?.debug === !0 ? `<h1>Error</h1><pre>${msg}
+${error instanceof Error ? error.stack : ""}</pre>` : "<h1>Internal Server Error</h1><p>An error occurred while processing your request.</p>";
+        return new Response(body, {
+          status: 500,
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+    };
+    for (let i = middleware.length - 1;i >= 0; i--) {
+      const mw = middleware[i], currentNext = next;
+      next = async () => await mw(request, currentNext);
+    }
+    return await next();
+  }
+  const server = bunServe({
+    port,
+    fetch: handleRequest
+  });
+  let watcher = null;
+  if (watch)
+    watcher = fs.watch(rootDir, { recursive: !0 }, (eventType, filename) => {
+      if (filename && (filename.endsWith(".stx") || filename.endsWith(".md") || filename.endsWith(".html")))
+        fileCache.clear();
+    });
+  return {
+    server,
+    url: server.url.toString(),
+    stop() {
+      if (watcher)
+        watcher.close();
+      server.stop();
+    }
+  };
+}
+export async function serveFile(filePath, options = {}) {
+  const absolutePath = path.resolve(filePath);
+  if (!await Bun.file(absolutePath).exists())
+    throw Error(`File not found: ${absolutePath}`);
+  const isMarkdown = absolutePath.endsWith(".md"), isStx = absolutePath.endsWith(".stx");
+  if (!isMarkdown && !isStx)
+    throw Error(`Unsupported file type: ${absolutePath}. Only .stx and .md files are supported.`);
+  return await serve({
+    ...options,
+    root: path.dirname(absolutePath),
+    routes: {
+      "/": async () => {
+        let content;
+        if (isMarkdown) {
+          const { content: md } = await readMarkdownFile(absolutePath, options.stxOptions);
+          content = md;
+        } else {
+          const fileContent = await Bun.file(absolutePath).text(), serverScriptContents = [], scriptRe = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+          let scriptM;
+          while ((scriptM = scriptRe.exec(fileContent)) !== null)
+            if (scriptM[1].includes("server"))
+              serverScriptContents.push(scriptM[2]);
+          const scriptContent = serverScriptContents.join(`
+`), templateContent = fileContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ""), context = {};
+          if (scriptContent.trim())
+            await extractVariables(scriptContent, context, absolutePath);
+          const dependencies = new Set;
+          content = await processDirectives(templateContent, context, absolutePath, options.stxOptions || {}, dependencies);
+        }
+        return new Response(content, {
+          headers: { "Content-Type": "text/html" }
+        });
+      },
+      ...options.routes
+    }
+  });
+}
+export function createMiddleware(handler) {
+  return handler;
+}
+export function createRoute(handler) {
+  return handler;
+}

package/dist/server-bindings.js

@@ -1,2 +1,108 @@
-// @bun
-import{It as a}from"./chunk-ejh8fyak.js";import"./chunk-xv34zbp4.js";export{a as processServerBindings};
+const BOOLEAN_ATTRS = new Set([
+  "disabled",
+  "checked",
+  "readonly",
+  "required",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "default",
+  "defer",
+  "formnovalidate",
+  "hidden",
+  "ismap",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "reversed",
+  "selected"
+]);
+function resolveClassBinding(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.filter(Boolean).map((v) => resolveClassBinding(v)).join(" ");
+  if (value && typeof value === "object")
+    return Object.entries(value).filter(([, active]) => active).map(([className]) => className).join(" ");
+  return value ? String(value) : "";
+}
+export function processServerBindings(template, context) {
+  if (!/:[\w-]+=/.test(template))
+    return template;
+  let output = template;
+  const scriptStyleRegex = /<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, protectedRanges = [];
+  let match;
+  while ((match = scriptStyleRegex.exec(template)) !== null)
+    protectedRanges.push([match.index, match.index + match[0].length]);
+  function isProtected(pos) {
+    return protectedRanges.some(([start, end]) => pos >= start && pos < end);
+  }
+  const tagRegex = /<([a-zA-Z][a-zA-Z0-9-]*)((?:\s+(?:[^>"']|"[^"]*"|'[^']*'))*)\s*\/?>/g, replacements = [];
+  while ((match = tagRegex.exec(output)) !== null) {
+    if (isProtected(match.index))
+      continue;
+    const fullTag = match[0], attrs = match[2];
+    if (!attrs || !attrs.includes(":"))
+      continue;
+    const bindingRegex = /\s:([a-zA-Z_][\w-]*)\s*=\s*"([^"]*)"/g;
+    let attrMatch, newAttrs = attrs, hadReplacement = !1;
+    while ((attrMatch = bindingRegex.exec(attrs)) !== null) {
+      const attrName = attrMatch[1], expression = attrMatch[2];
+      if (expression.includes("()") && !expression.includes(".get(") || expression.includes("$store") || expression.includes("$ref"))
+        continue;
+      try {
+        const contextKeys = Object.keys(context), contextValues = Object.values(context), identMatch = expression.match(/^([a-zA-Z_$][\w$]*)/);
+        if (identMatch && !contextKeys.includes(identMatch[1]) && !["true", "false", "null", "undefined", "Math", "JSON", "String", "Number", "Array", "Object", "Date", "parseInt", "parseFloat"].includes(identMatch[1]))
+          continue;
+        const value = Function(...contextKeys, `return (${expression})`)(...contextValues);
+        if (attrName === "class") {
+          const classStr = resolveClassBinding(value);
+          if (classStr) {
+            const existingClassMatch = newAttrs.match(/\sclass="([^"]*)"/);
+            if (existingClassMatch)
+              newAttrs = newAttrs.replace(existingClassMatch[0], ` class="${existingClassMatch[1]} ${classStr}"`);
+            else
+              newAttrs = newAttrs.replace(attrMatch[0], ` class="${classStr}"`);
+          } else
+            newAttrs = newAttrs.replace(attrMatch[0], "");
+          hadReplacement = !0;
+          continue;
+        }
+        if (BOOLEAN_ATTRS.has(attrName)) {
+          if (value)
+            newAttrs = newAttrs.replace(attrMatch[0], ` ${attrName}`);
+          else
+            newAttrs = newAttrs.replace(attrMatch[0], "");
+          hadReplacement = !0;
+          continue;
+        }
+        if (value === null || value === void 0 || value === !1)
+          newAttrs = newAttrs.replace(attrMatch[0], "");
+        else {
+          const escaped = String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+          newAttrs = newAttrs.replace(attrMatch[0], ` ${attrName}="${escaped}"`);
+        }
+        hadReplacement = !0;
+      } catch {
+        continue;
+      }
+    }
+    if (hadReplacement) {
+      const selfClose = fullTag.endsWith("/>") ? " /" : "", newTag = `<${match[1]}${newAttrs}${selfClose}>`;
+      replacements.push({
+        start: match.index,
+        end: match.index + fullTag.length,
+        replacement: newTag
+      });
+    }
+  }
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const { start, end, replacement } = replacements[i];
+    output = output.slice(0, start) + replacement + output.slice(end);
+  }
+  return output;
+}