@stacksjs/stx 0.2.94 → 0.2.96

package/dist/strict-lint.js

@@ -1,2 +1,288 @@
-// @bun
-import{fg as a}from"./chunk-epj957jf.js";import"./chunk-3jm3snz8.js";export{a as lintStxStrict};
+const DIRECTIVE_ATTR_NAMES = new Set([
+  "if",
+  "else",
+  "elseif",
+  "else-if",
+  "for",
+  "foreach",
+  "show",
+  "model",
+  "html",
+  "text",
+  "bind",
+  "key",
+  "ref",
+  "once",
+  "memo",
+  "slot",
+  "teleport",
+  "cloak",
+  "pre",
+  "effect",
+  "init"
+]), VOID_TAGS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function rawTextSpans(src) {
+  const spans = [], re = /<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+  let m;
+  while ((m = re.exec(src)) !== null)
+    spans.push([m.index, m.index + m[0].length]);
+  return spans;
+}
+function inSpans(spans, i) {
+  for (const [s, e] of spans)
+    if (i >= s && i < e)
+      return !0;
+  return !1;
+}
+function offsetToLineCol(src, offset) {
+  let line = 1, lineStart = 0;
+  for (let i = 0;i < offset && i < src.length; i++)
+    if (src[i] === `
+`) {
+      line++;
+      lineStart = i + 1;
+    }
+  return { line, column: offset - lineStart + 1 };
+}
+function elementEnd(src, tag, startTagEnd) {
+  const lower = tag.toLowerCase(), len = src.length;
+  let depth = 1, i = startTagEnd;
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1)
+      return -1;
+    i = lt;
+    if (src.startsWith("<!--", i)) {
+      const c = src.indexOf("-->", i + 4);
+      if (c === -1)
+        return -1;
+      i = c + 3;
+      continue;
+    }
+    if (src[i + 1] === "/") {
+      const m = /^<\/([a-z][\w-]*)\s*>/i.exec(src.slice(i, i + 64));
+      if (!m) {
+        i++;
+        continue;
+      }
+      if (m[1].toLowerCase() === lower) {
+        depth--;
+        i += m[0].length;
+        if (depth === 0)
+          return i;
+        continue;
+      }
+      i += m[0].length;
+      continue;
+    }
+    const om = /^<([a-z][\w-]*)\b/i.exec(src.slice(i, i + 64));
+    if (!om) {
+      i++;
+      continue;
+    }
+    const gt = src.indexOf(">", i);
+    if (gt === -1)
+      return -1;
+    if (om[1].toLowerCase() === lower && src[gt - 1] !== "/")
+      depth++;
+    i = gt + 1;
+  }
+  return -1;
+}
+function ruleBareFunctionRef(src, spans, out) {
+  const re = /@([a-z][\w:-]*)((?:\.[a-z][\w-]*)*)\s*=\s*"([^"]*)"/gi;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    if (inSpans(spans, m.index))
+      continue;
+    const base = m[1].toLowerCase().split(":")[0];
+    if (DIRECTIVE_ATTR_NAMES.has(base))
+      continue;
+    const value = m[3].trim();
+    if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(value)) {
+      const at = src.indexOf(m[3], m.index), { line, column } = offsetToLineCol(src, at < 0 ? m.index : at);
+      out.push({
+        ruleId: "stx/no-bare-function-ref-in-event",
+        message: `Event handler @${m[1]}="${value}" is a bare reference and will not fire. Call it: @${m[1]}="${value}()".`,
+        line,
+        column,
+        severity: "error"
+      });
+    }
+  }
+}
+function ruleViewLevelScriptClient(src, fileKind, out) {
+  if (fileKind !== "view")
+    return;
+  const re = /<script\b([^>]*)>/gi;
+  let m;
+  while ((m = re.exec(src)) !== null)
+    if (/(?:^|\s)client(?=[\s/=]|$)/i.test(m[1])) {
+      const { line, column } = offsetToLineCol(src, m.index);
+      out.push({
+        ruleId: "stx/no-view-level-script-client",
+        message: "<script client> at the top level of a view is silently dropped \u2014 only components get client scopes. Move it into a component, or use <script> (server).",
+        line,
+        column,
+        severity: "error"
+      });
+    }
+}
+function normalizePath(p) {
+  const parts = p.split("/"), out = [];
+  for (const seg of parts) {
+    if (seg === "" || seg === ".")
+      continue;
+    if (seg === "..")
+      out.pop();
+    else
+      out.push(seg);
+  }
+  return out.join("/");
+}
+function ruleStoreValueImports(src, filePath, out) {
+  const norm = filePath.replace(/\\/g, "/"), storesIdx = norm.indexOf("resources/stores/");
+  if (storesIdx === -1)
+    return;
+  const storesRoot = norm.slice(0, storesIdx + 16), fileDir = norm.slice(0, norm.lastIndexOf("/")), re = /\b(import|export)\s+(type\s+)?([^'"]*?)\s*from\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    if (m[2])
+      continue;
+    const kind = m[1], spec = m[4];
+    let outside;
+    if (spec.startsWith("."))
+      outside = !normalizePath(`${fileDir}/${spec}`).startsWith(normalizePath(storesRoot));
+    else
+      outside = !0;
+    if (outside) {
+      const { line, column } = offsetToLineCol(src, m.index), verb = kind === "export" ? "Value re-export" : "Value import";
+      out.push({
+        ruleId: "stx/store-value-imports-must-be-local",
+        message: `${verb} from "${spec}" is outside resources/stores/ and will be stripped from the store bundle. Use \`${kind} type\`, or move the value into the stores dir.`,
+        line,
+        column,
+        severity: "error"
+      });
+    }
+  }
+}
+function forIterationVars(expr) {
+  const e = expr.trim(), idents = (s) => {
+    const found = s.match(/[A-Za-z_$][\w$]*/g);
+    return found ? found : [];
+  }, asM = /\bas\s+(.+)$/.exec(e);
+  if (asM) {
+    const rhs = asM[1].trim(), arrow = /^([A-Za-z_$][\w$]*)\s*=>\s*([A-Za-z_$][\w$]*)/.exec(rhs);
+    if (arrow)
+      return [arrow[1], arrow[2]];
+    const paren = /^\(([^)]*)\)/.exec(rhs);
+    if (paren)
+      return idents(paren[1]);
+    const bare = /^([A-Za-z_$][\w$]*)/.exec(rhs);
+    return bare ? [bare[1]] : [];
+  }
+  const paren = /^\(([^)]*)\)\s+(?:in|of)\s+/.exec(e);
+  if (paren)
+    return idents(paren[1]);
+  const jsM = /^([A-Za-z_$][\w$]*)\s+(?:in|of)\s+/.exec(e);
+  return jsM ? [jsM[1]] : [];
+}
+function ruleSignalCallInForVar(src, out) {
+  const re = /(?::for|x-for|@for)\s*=\s*"([^"]*)"/gi;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const vars = forIterationVars(m[1]);
+    if (vars.length === 0)
+      continue;
+    const tagStart = src.lastIndexOf("<", m.index);
+    if (tagStart === -1)
+      continue;
+    const tagM = /^<([a-z][\w-]*)/i.exec(src.slice(tagStart, tagStart + 64));
+    if (!tagM)
+      continue;
+    const startTagEnd = src.indexOf(">", m.index);
+    if (startTagEnd === -1)
+      continue;
+    const end = src[startTagEnd - 1] === "/" || VOID_TAGS.has(tagM[1].toLowerCase()) ? startTagEnd + 1 : elementEnd(src, tagM[1], startTagEnd + 1), regionEnd = end === -1 ? startTagEnd + 1 : end, forValStart = src.indexOf(m[1], m.index);
+    let region = src.slice(tagStart, regionEnd);
+    if (forValStart >= 0 && forValStart + m[1].length <= regionEnd) {
+      const rel = forValStart - tagStart;
+      region = region.slice(0, rel) + " ".repeat(m[1].length) + region.slice(rel + m[1].length);
+    }
+    for (const v of vars) {
+      const callRe = new RegExp(`(?<![.\\w$])${escapeRegExp(v)}\\s*\\(`, "g");
+      let c;
+      while ((c = callRe.exec(region)) !== null) {
+        const abs = tagStart + c.index, { line, column } = offsetToLineCol(src, abs);
+        out.push({
+          ruleId: "stx/no-signal-call-in-for-iteration-var",
+          message: `"${v}" is a :for iteration variable, not a signal \u2014 calling it as "${v}()" leaves it as a function and silently breaks comparisons. Use "${v}" directly.`,
+          line,
+          column,
+          severity: "error"
+        });
+      }
+    }
+  }
+}
+function ruleBackticksInHtmlComments(src, out) {
+  const re = /<!--([\s\S]*?)-->/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const tick = m[1].indexOf("`");
+    if (tick !== -1) {
+      const abs = m.index + 4 + tick, { line, column } = offsetToLineCol(src, abs);
+      out.push({
+        ruleId: "stx/no-backticks-in-html-comments",
+        message: "Backtick inside an HTML comment leaks into the merged setup function and flips the JS parser into template-literal mode. Remove it or rephrase the comment.",
+        line,
+        column,
+        severity: "error"
+      });
+    }
+  }
+}
+function isRuleOn(rules, id) {
+  return rules?.[id] !== !1;
+}
+export function lintStxStrict(source, options = {}) {
+  const out = [], spans = rawTextSpans(source), filePath = (options.filePath ?? "").replace(/\\/g, "/"), fileKind = options.fileKind ?? (/\/components?\//i.test(filePath) ? "component" : "view");
+  if (isRuleOn(options.rules, "stx/no-bare-function-ref-in-event"))
+    ruleBareFunctionRef(source, spans, out);
+  if (isRuleOn(options.rules, "stx/no-view-level-script-client"))
+    ruleViewLevelScriptClient(source, fileKind, out);
+  if (filePath && isRuleOn(options.rules, "stx/store-value-imports-must-be-local"))
+    ruleStoreValueImports(source, filePath, out);
+  if (isRuleOn(options.rules, "stx/no-signal-call-in-for-iteration-var"))
+    ruleSignalCallInForVar(source, out);
+  if (isRuleOn(options.rules, "stx/no-backticks-in-html-comments"))
+    ruleBackticksInHtmlComments(source, out);
+  out.sort((a, b) => a.line - b.line || a.column - b.column);
+  const seen = new Set;
+  return out.filter((d) => {
+    const k = `${d.ruleId}:${d.line}:${d.column}`;
+    if (seen.has(k))
+      return !1;
+    seen.add(k);
+    return !0;
+  });
+}

package/dist/style-scoping.js

@@ -1,2 +1,50 @@
-// @bun
-import{mt as a}from"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-3jm3snz8.js";export{a as processScopedStyles};
+import { generateComponentId, scopeCss } from "./web-components/css-scoping.js";
+export function processScopedStyles(template, filePath) {
+  if (!/<style\s+[^>]*\bscoped\b/i.test(template))
+    return { html: template, hasScoped: !1 };
+  const componentId = generateComponentId(filePath), scopeAttr = `data-v-${componentId}`;
+  let output = template;
+  const scopedStyleRegex = /<style\s+([^>]*\bscoped\b[^>]*)>([\s\S]*?)<\/style>/gi;
+  let hasScoped = !1;
+  output = output.replace(scopedStyleRegex, (_match, attrs, cssContent) => {
+    hasScoped = !0;
+    const scopedCss = scopeCssWithAttribute(cssContent, scopeAttr), cleanAttrs = attrs.replace(/\bscoped\b/gi, "").trim(), attrStr = cleanAttrs ? ` ${cleanAttrs}` : "";
+    return `<style data-stx-scoped="${componentId}"${attrStr}>${scopedCss}</style>`;
+  });
+  if (!hasScoped)
+    return { html: template, hasScoped: !1 };
+  output = addScopeAttribute(output, scopeAttr);
+  return { html: output, hasScoped: !0 };
+}
+function scopeCssWithAttribute(css, scopeAttr) {
+  return scopeCss(css, "__SCOPE_PLACEHOLDER__", { preserveHost: !1 }).replace(/\.(__SCOPE_PLACEHOLDER__) /g, `[${scopeAttr}] `).replace(/\.(__SCOPE_PLACEHOLDER__)/g, `[${scopeAttr}]`);
+}
+function addScopeAttribute(html, scopeAttr) {
+  const skipTags = new Set([
+    "script",
+    "style",
+    "template",
+    "html",
+    "head",
+    "body",
+    "meta",
+    "link",
+    "title",
+    "base",
+    "!doctype",
+    "!DOCTYPE"
+  ]);
+  return html.replace(/<([a-zA-Z][a-zA-Z0-9-]*)(\s[^>]*)?\/?>/g, (match, tagName, attrs) => {
+    if (skipTags.has(tagName.toLowerCase()))
+      return match;
+    if (match.includes(scopeAttr))
+      return match;
+    if (tagName.toLowerCase() === "style" || tagName.toLowerCase() === "script")
+      return match;
+    if (attrs)
+      return match.replace(`<${tagName}${attrs}`, `<${tagName} ${scopeAttr}${attrs}`);
+    if (match.endsWith("/>"))
+      return `<${tagName} ${scopeAttr} />`;
+    return `<${tagName} ${scopeAttr}>`;
+  });
+}