@stacksjs/stx 0.2.95 → 0.2.97

package/dist/app-shell.js

@@ -1,2 +1,220 @@
-// @bun
-import{Iq as a,Jq as b,Kq as c,Lq as d,Mq as e,Nq as f,Oq as g}from"./chunk-d0zjtdw4.js";import"./chunk-mhgk632d.js";import"./chunk-xv34zbp4.js";export{d as stripDocumentWrapper,b as processShell,e as isSpaNavigation,g as extractLayoutMetadata,f as extractContainerContent,a as detectShell,c as composeShellWithPage};
+var {require}=import.meta;import path from "node:path";
+import { classifyAllScripts } from "./script-classifier.js";
+export { extractLayoutMetadata } from "stx-router/layout-metadata";
+const PAGE_HEAD_MARKER = "stx-page-head:", PAGE_HEAD_MARKER_RE = /<!--stx-page-head:([A-Za-z0-9+/=]+)-->\n?/;
+let _cachedRouterScript = null;
+function getRouterScriptCached() {
+  if (_cachedRouterScript !== null)
+    return _cachedRouterScript;
+  try {
+    const { getRouterScript } = require("stx-router");
+    _cachedRouterScript = `<script>${getRouterScript()}</script>`;
+  } catch {
+    _cachedRouterScript = "";
+  }
+  return _cachedRouterScript;
+}
+export async function detectShell(appDir, shellConfig) {
+  if (shellConfig === !1)
+    return null;
+  if (shellConfig && typeof shellConfig === "string") {
+    const shellPath = path.resolve(appDir, shellConfig);
+    if (await Bun.file(shellPath).exists())
+      return shellPath;
+    return null;
+  }
+  const defaultShellPath = path.join(appDir, "app.stx");
+  if (await Bun.file(defaultShellPath).exists())
+    return defaultShellPath;
+  return null;
+}
+export async function processShell(shellPath, options) {
+  try {
+    const content = await Bun.file(shellPath).text();
+    let shellTemplate = content;
+    const templateMatch = content.match(/<template\b[^>]*>([\s\S]*?)<\/template>/i);
+    if (templateMatch)
+      shellTemplate = templateMatch[1].trim();
+    const classified = classifyAllScripts(content), shellScripts = [
+      ...classified.client.map((s) => s.fullTag),
+      ...classified.signals.map((s) => s.fullTag)
+    ], shellStyles = [], styleRegex = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+    let styleMatch;
+    while ((styleMatch = styleRegex.exec(content)) !== null)
+      shellStyles.push(styleMatch[0]);
+    let cleanTemplate = shellTemplate;
+    for (const s of classified.server)
+      cleanTemplate = cleanTemplate.replace(s.fullTag, "");
+    for (const s of classified.client)
+      cleanTemplate = cleanTemplate.replace(s.fullTag, "");
+    cleanTemplate = cleanTemplate.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+    const SLOT_PLACEHOLDER = "<!--__STX_PAGE_SLOT__-->";
+    cleanTemplate = cleanTemplate.replace(/<slot\s*\/>/gi, SLOT_PLACEHOLDER).replace(/<slot\s*>\s*<\/slot>/gi, SLOT_PLACEHOLDER);
+    if (!cleanTemplate.includes(SLOT_PLACEHOLDER)) {
+      console.warn(`[stx] Shell ${shellPath} has no <slot /> \u2014 pages won't be injected`);
+      return null;
+    }
+    const { processDirectives, extractVariables, defaultConfig, loadStxConfig } = await import("./index.js"), projectConfig = await loadStxConfig(), shellContext = {
+      __filename: shellPath,
+      __dirname: path.dirname(shellPath)
+    };
+    for (const script of shellScripts) {
+      const scriptContent = script.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+      if (scriptContent && !script.includes("client") && !script.includes('type="module"'))
+        await extractVariables(scriptContent[1], shellContext, shellPath);
+    }
+    const processedShell = await processDirectives(cleanTemplate, shellContext, shellPath, { ...defaultConfig, ...projectConfig, ...options }, new Set), slotIndex = processedShell.indexOf(SLOT_PLACEHOLDER);
+    if (slotIndex === -1) {
+      console.warn("[stx] Shell slot placeholder lost during processing");
+      return null;
+    }
+    return {
+      beforeSlot: processedShell.substring(0, slotIndex),
+      afterSlot: processedShell.substring(slotIndex + SLOT_PLACEHOLDER.length),
+      filePath: shellPath,
+      shellScripts,
+      shellStyles
+    };
+  } catch (error) {
+    console.error(`[stx] Error processing shell ${shellPath}:`, error);
+    return null;
+  }
+}
+export function composeShellWithPage(shell, pageContent, pageTitle) {
+  let hoistedTitle, hoistedHead = "";
+  const markerMatch = pageContent.match(PAGE_HEAD_MARKER_RE);
+  if (markerMatch) {
+    pageContent = pageContent.replace(markerMatch[0], "");
+    try {
+      const tags = Buffer.from(markerMatch[1], "base64").toString("utf8"), titleMatch = tags.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+      if (titleMatch)
+        hoistedTitle = titleMatch[1].trim();
+      hoistedHead = tags.replace(/<title[^>]*>[\s\S]*?<\/title>/i, "").trim();
+    } catch {}
+  }
+  const title = pageTitle || hoistedTitle || "stx App", routerScript = getRouterScriptCached(), routerConfig = "<script>window.__stxRouterConfig={container:'[data-stx-content]'};</script>";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+${hoistedHead ? `  ${hoistedHead}
+` : ""}  ${shell.shellStyles.join(`
+  `)}
+</head>
+<body>
+${shell.beforeSlot}
+<div data-stx-content>${pageContent}</div>
+${shell.afterSlot}
+${shell.shellScripts.filter((s) => !s.includes("server")).join(`
+`)}
+${routerConfig}
+${routerScript}
+</body>
+</html>`;
+}
+export function stripDocumentWrapper(html, options = {}) {
+  const trimmed = html.trim();
+  if (!/<!DOCTYPE\b/i.test(trimmed) && !/^<html[\s>]/i.test(trimmed))
+    return html;
+  const headStyles = [], headMatch = trimmed.match(/<head\b[^>]*>([\s\S]*?)<\/head>/i);
+  if (headMatch) {
+    const headContent = headMatch[1], styleRegex = /<style\b[^>]*>[\s\S]*?<\/style>/gi;
+    let m;
+    while ((m = styleRegex.exec(headContent)) !== null)
+      headStyles.push(m[0]);
+  }
+  if (options.preserveHead && headMatch) {
+    const headTags = [], tagRegex = /<title\b[^>]*>[\s\S]*?<\/title>|<meta\b[^>]*>|<link\b[^>]*>/gi;
+    let m;
+    while ((m = tagRegex.exec(headMatch[1])) !== null) {
+      if (/<meta\b[^>]*(?:\bcharset|name="viewport")/i.test(m[0]))
+        continue;
+      headTags.push(m[0]);
+    }
+    if (headTags.length > 0)
+      headStyles.unshift(`<!--${PAGE_HEAD_MARKER}${Buffer.from(headTags.join(`
+`), "utf8").toString("base64")}-->`);
+  }
+  const bodyOpenMatch = trimmed.match(/<body\b[^>]*>/i), bodyCloseIdx = trimmed.lastIndexOf("</body>");
+  if (bodyOpenMatch && bodyCloseIdx !== -1) {
+    const bodyStart = bodyOpenMatch.index + bodyOpenMatch[0].length, bodyContent = trimmed.slice(bodyStart, bodyCloseIdx).trim();
+    if (headStyles.length > 0)
+      return headStyles.join(`
+`) + `
+` + bodyContent;
+    return bodyContent;
+  }
+  let result = trimmed;
+  result = result.replace(/<!DOCTYPE\b[^>]*>/i, "");
+  result = result.replace(/<html\b[^>]*>/i, "");
+  result = result.replace(/<\/html\s*>/i, "");
+  if (headMatch)
+    result = result.replace(/<head\b[^>]*>[\s\S]*?<\/head>/i, headStyles.join(`
+`));
+  result = result.replace(/<body\b[^>]*>/i, "");
+  result = result.replace(/<\/body\s*>/i, "");
+  return result.trim();
+}
+export function isSpaNavigation(request) {
+  return request.headers.get("X-STX-Router") === "true";
+}
+export function extractContainerContent(html, containerSelector = "main") {
+  const trimmed = html.trim(), headStyles = [], headMatch = trimmed.match(/<head\b[^>]*>([\s\S]*?)<\/head>/i);
+  if (headMatch) {
+    const headContent = headMatch[1], styleRegex = /<style\b[^>]*>[\s\S]*?<\/style>/gi;
+    let m;
+    while ((m = styleRegex.exec(headContent)) !== null)
+      headStyles.push(m[0]);
+  }
+  const tag = containerSelector.replace(/^[.#]/, "").toLowerCase(), openRe = new RegExp(`<${tag}\\b[^>]*>`, "i"), openMatch = trimmed.match(openRe);
+  if (!openMatch || openMatch.index === void 0)
+    return stripDocumentWrapper(html);
+  const openEnd = openMatch.index + openMatch[0].length, openTagRe = new RegExp(`<${tag}\\b[^>]*>`, "gi"), closeTagRe = new RegExp(`</${tag}\\s*>`, "gi");
+  openTagRe.lastIndex = openEnd;
+  closeTagRe.lastIndex = openEnd;
+  let depth = 1, closeIdx = -1;
+  while (depth > 0) {
+    const nextOpen = openTagRe.exec(trimmed), nextClose = closeTagRe.exec(trimmed);
+    if (!nextClose)
+      break;
+    if (nextOpen && nextOpen.index < nextClose.index) {
+      depth++;
+      closeTagRe.lastIndex = nextOpen.index + nextOpen[0].length;
+    } else {
+      depth--;
+      closeIdx = nextClose.index;
+      if (depth > 0)
+        openTagRe.lastIndex = nextClose.index + nextClose[0].length;
+    }
+  }
+  if (closeIdx === -1)
+    return stripDocumentWrapper(html);
+  const innerContent = trimmed.slice(openEnd, closeIdx).trim(), bodyScripts = [], bodyOpenMatch = trimmed.match(/<body\b[^>]*>/i), bodyCloseIdx = trimmed.lastIndexOf("</body>");
+  if (bodyOpenMatch && bodyOpenMatch.index !== void 0 && bodyCloseIdx !== -1) {
+    const regions = [
+      [bodyOpenMatch.index + bodyOpenMatch[0].length, openMatch.index],
+      [closeIdx + `</${tag}>`.length, bodyCloseIdx]
+    ], scriptRe = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
+    for (const [start, end] of regions) {
+      if (start >= end)
+        continue;
+      const region = trimmed.slice(start, end);
+      let sm;
+      scriptRe.lastIndex = 0;
+      while ((sm = scriptRe.exec(region)) !== null)
+        bodyScripts.push(sm[0]);
+    }
+  }
+  const parts = [];
+  if (headStyles.length > 0)
+    parts.push(headStyles.join(`
+`));
+  if (bodyScripts.length > 0)
+    parts.push(bodyScripts.join(`
+`));
+  parts.push(innerContent);
+  return parts.join(`
+`);
+}

package/dist/app.js

@@ -1,2 +1,79 @@
-// @bun
-import{Rq as a,Sq as b}from"./chunk-avx8aydt.js";import"./chunk-r0jcmpv6.js";import"./chunk-xv34zbp4.js";export{b as defineCustomElement,a as createApp};
+import { setGlobalProvide } from "./composition-api.js";
+export function createApp(_rootComponent, _rootProps) {
+  const installedPlugins = new Set, components = new Map, directives = new Map, config = {
+    globalProperties: {},
+    performance: !1,
+    compilerOptions: {}
+  }, app = {
+    config,
+    _components: components,
+    _directives: directives,
+    _installedPlugins: installedPlugins,
+    use(plugin, ...options) {
+      if (installedPlugins.has(plugin))
+        return app;
+      installedPlugins.add(plugin);
+      if (typeof plugin === "function")
+        plugin(app, ...options);
+      else if (typeof plugin.install === "function")
+        plugin.install(app, ...options);
+      return app;
+    },
+    provide(key, value) {
+      setGlobalProvide(key, value);
+      return app;
+    },
+    component(name, definition) {
+      if (!definition)
+        return components.get(name);
+      components.set(name, definition);
+      return app;
+    },
+    directive(name, definition) {
+      if (!definition)
+        return directives.get(name);
+      directives.set(name, definition);
+      return app;
+    },
+    mount(_rootContainer) {
+      if (typeof document < "u") {
+        const globalObj = globalThis.__stx_globals || (globalThis.__stx_globals = {});
+        Object.assign(globalObj, config.globalProperties);
+        document.querySelectorAll("[v-cloak]").forEach((el) => {
+          el.removeAttribute("v-cloak");
+        });
+      }
+      return app;
+    },
+    unmount() {
+      components.clear();
+      directives.clear();
+      installedPlugins.clear();
+    }
+  };
+  return app;
+}
+export function defineCustomElement(component) {
+  return class extends HTMLElement {
+    _component;
+    _shadow;
+    constructor() {
+      super();
+      this._shadow = this.attachShadow({ mode: "open" });
+      this._component = component;
+    }
+    connectedCallback() {
+      if (this._component?.render) {
+        const result = this._component.render();
+        if (typeof result === "string")
+          this._shadow.innerHTML = result;
+      } else if (this._component?.template)
+        this._shadow.innerHTML = this._component.template;
+      else if (typeof this._component === "string")
+        this._shadow.innerHTML = this._component;
+    }
+    disconnectedCallback() {
+      this._shadow.innerHTML = "";
+    }
+  };
+}

package/dist/assets.js

@@ -1,2 +1,155 @@
-// @bun
-import{Xr as a,Yr as b,Zr as c}from"./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{b as readMarkdownFile,c as processMarkdownFileDirectives,a as markdownCache};
+import fs from "node:fs";
+import path from "node:path";
+import { createHighlighter } from "ts-syntax-highlighter";
+import { config } from "./config.js";
+import { parseFrontmatter, parseMarkdown } from "./internal-markdown.js";
+import { createDetailedErrorMessage, fileExists } from "./utils.js";
+export const markdownCache = new Map;
+export async function readMarkdownFile(filePath, options = {}) {
+  try {
+    if (!await fileExists(filePath))
+      throw Error(`Markdown file not found: ${filePath}`);
+    const mtime = (await fs.promises.stat(filePath)).mtime.getTime();
+    if (options.cache && markdownCache.has(filePath)) {
+      const cached = markdownCache.get(filePath);
+      if (cached.updatedAt >= mtime)
+        return {
+          content: cached.content,
+          data: cached.data
+        };
+    }
+    const fileContent = await Bun.file(filePath).text(), { data, content: markdownContent } = parseFrontmatter(fileContent), markdownConfig = options.markdown || config.markdown || {
+      enabled: !0,
+      syntaxHighlighting: {
+        enabled: !0,
+        serverSide: !0,
+        defaultTheme: "github-dark",
+        highlightUnknownLanguages: !0
+      }
+    };
+    let htmlContent = parseMarkdown(markdownContent, { gfm: !0 });
+    if (markdownConfig.syntaxHighlighting?.enabled && markdownConfig.syntaxHighlighting?.serverSide)
+      htmlContent = await applyCodeHighlighting(htmlContent, markdownConfig.syntaxHighlighting?.defaultTheme || "github-dark", markdownConfig.syntaxHighlighting?.highlightUnknownLanguages || !1);
+    const parsedResult = {
+      content: htmlContent,
+      data: data || {}
+    };
+    if (options.cache)
+      markdownCache.set(filePath, {
+        ...parsedResult,
+        updatedAt: mtime
+      });
+    return parsedResult;
+  } catch (error) {
+    if (options.debug)
+      console.error(`Error reading/parsing markdown file ${filePath}:`, error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: createDetailedErrorMessage("Markdown File", `Error reading/parsing markdown file: ${errorMessage}`, filePath, "", 0, ""),
+      data: {}
+    };
+  }
+}
+let highlighterCache = null;
+async function applyCodeHighlighting(html, theme, highlightUnknown) {
+  const codeRegex = /<pre><code( class="language-([^"]+)")?>([^<]+)<\/code><\/pre>/g;
+  if (!highlighterCache)
+    try {
+      highlighterCache = await createHighlighter({
+        theme: theme || "github-dark",
+        cache: !0
+      });
+    } catch (err) {
+      console.error("Failed to initialize ts-syntax-highlighter:", err);
+      return html;
+    }
+  const processCodeBlock = async (match, languageClass, language, code) => {
+    const decodedCode = code.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'"), langToUse = language || (highlightUnknown ? "text" : "");
+    if (!langToUse)
+      return match;
+    try {
+      if (!highlighterCache.getSupportedLanguages().includes(langToUse))
+        return match;
+      return (await highlighterCache.highlight(decodedCode, langToUse, {
+        theme
+      })).html;
+    } catch (err) {
+      console.error(`Error highlighting code block with language ${language}:`, err);
+    }
+    return match;
+  };
+  let result = html;
+  const matches = html.matchAll(codeRegex);
+  for (const match of matches) {
+    const [fullMatch, languageClass, language, code] = match, highlightedBlock = await processCodeBlock(fullMatch, languageClass, language, code);
+    result = result.replace(fullMatch, highlightedBlock);
+  }
+  return result;
+}
+export async function processMarkdownFileDirectives(template, context, filePath = "", options = {}) {
+  return await replaceAsync(template, /@markdown-file\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\}))?\)/g, async (match, mdFilePath, contextStr, offset) => {
+    try {
+      let resolvedPath = mdFilePath;
+      if (!path.isAbsolute(mdFilePath))
+        resolvedPath = path.resolve(path.dirname(filePath), mdFilePath);
+      let additionalContext = {};
+      if (contextStr)
+        try {
+          try {
+            additionalContext = JSON.parse(contextStr);
+          } catch {
+            if (options.debug)
+              console.warn("Using safer alternative for parsing JS object literal");
+            const entries = contextStr.replace(/^\s*\{|\}\s*$/g, "").trim().split(/,(?=\s*\w+\s*:)/);
+            for (const entry of entries) {
+              const colonIndex = entry.indexOf(":");
+              if (colonIndex > 0) {
+                const key = entry.substring(0, colonIndex).trim();
+                let value = entry.substring(colonIndex + 1).trim();
+                const hasDoubleQuotes = value.startsWith('"') && value.endsWith('"'), hasSingleQuotes = value.startsWith("'") && value.endsWith("'");
+                if (hasDoubleQuotes || hasSingleQuotes)
+                  value = value.substring(1, value.length - 1);
+                additionalContext[key] = value;
+              }
+            }
+          }
+        } catch (contextError) {
+          if (options.debug)
+            console.error("Error parsing context in @markdown-file directive:", contextError);
+        }
+      const { content, data } = await readMarkdownFile(resolvedPath, options), mergedContext = {
+        ...context,
+        ...data,
+        ...additionalContext
+      };
+      let processedContent = content;
+      const expressionRegex = /\{\{([^}]+)\}\}/g;
+      processedContent = processedContent.replace(expressionRegex, (exprMatch, exprKey) => {
+        const trimmedKey = exprKey.trim();
+        return mergedContext[trimmedKey] !== void 0 ? String(mergedContext[trimmedKey]) : exprMatch;
+      });
+      return processedContent;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return createDetailedErrorMessage("Markdown File", `Error including markdown file: ${errorMessage}`, filePath, template, offset, match);
+    }
+  });
+}
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    const matchText = match[0], matchIndex = match.index, args = match;
+    promises.push(asyncFn(...args).then((replacement) => ({
+      match: matchText,
+      replacement,
+      index: matchIndex
+    })));
+  }
+  const results = await Promise.all(promises);
+  results.sort((a, b) => b.index - a.index);
+  let result = str;
+  for (const { match, replacement } of results)
+    result = result.replace(match, () => replacement);
+  return result;
+}