@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/strict-lint.js

@@ -0,0 +1,269 @@
+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 member path, which the runtime does not invoke \u2014 it only auto-calls a plain identifier. Call it: @${m[1]}="${value}($event)".`,
+        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" : /\/layouts?\//i.test(filePath) ? "layout" : "view");
+  if (isRuleOn(options.rules, "stx/no-bare-function-ref-in-event"))
+    ruleBareFunctionRef(source, spans, 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/strip-literals.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Blank out comments and string literals, keeping every other character where
+ * it was.
+ *
+ * A name mentioned in a comment or inside a string is not a reference to it.
+ * The server-to-client bridge applies this before deciding what a client block
+ * mentions, and `stx typecheck` has to apply exactly the same rule before
+ * reporting what still crosses implicitly — a second copy that disagreed would
+ * make the warning and the runtime describe different sets (#1868 ask 4).
+ *
+ * Lives in its own module for that reason. It was defined inside
+ * `client-script.ts`, and the editor-facing `stx-virtual-ts.ts` cannot import
+ * that without pulling the bundler in behind it; the alternative was a
+ * second implementation, which is the failure this repo keeps repeating.
+ *
+ * Positions are preserved: every blanked character becomes a space and every
+ * newline stays a newline, so an offset into the result is an offset into the
+ * source.
+ *
+ * @module strip-literals
+ */
+/**
+ * Index of the `}` closing an interpolation whose body starts at `start`.
+ *
+ * Literals and comments are skipped whole, so a brace inside them cannot be
+ * mistaken for structure — `` `${ x ? "}" : y }` `` closes at the right place.
+ */
+export declare function findInterpolationEnd(code: string, start: number): number;
+/**
+ * Blank out comments and string literals, preserving length and line structure
+ * so offsets still line up, so that identifier detection only ever sees code.
+ *
+ * Template-literal INTERPOLATIONS are kept, because `${...}` is code, not text.
+ * Blanking them hid every identifier that appears only inside one — a helper
+ * called as `${formatDate(d)}` looked unused to the auto-import scanner, and a
+ * server value read as `` `/api/users/${userId}` `` looked unreferenced to the
+ * data bridge, which would have withheld it and left the client throwing on an
+ * undefined name.
+ */
+export declare function stripCommentsAndLiterals(code: string): string;

package/dist/strip-literals.js

@@ -0,0 +1,149 @@
+function skipQuoted(code, start) {
+  const quote = code[start];
+  let i = start + 1;
+  while (i < code.length) {
+    if (code[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (code[i] === quote)
+      return i + 1;
+    i++;
+  }
+  return code.length;
+}
+function skipTemplate(code, start) {
+  let i = start + 1;
+  while (i < code.length) {
+    if (code[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (code[i] === "`")
+      return i + 1;
+    if (code[i] === "$" && code[i + 1] === "{") {
+      i = findInterpolationEnd(code, i + 2);
+      if (i < code.length)
+        i++;
+      continue;
+    }
+    i++;
+  }
+  return code.length;
+}
+export function findInterpolationEnd(code, start) {
+  let depth = 1, i = start;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      i = skipQuoted(code, i);
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplate(code, i);
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "/") {
+      while (i < code.length && code[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === "/" && code[i + 1] === "*") {
+      i += 2;
+      while (i < code.length && code.slice(i, i + 2) !== "*/")
+        i++;
+      i += 2;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return code.length;
+}
+export function stripCommentsAndLiterals(code) {
+  let out = "", i = 0;
+  while (i < code.length) {
+    const two = code.slice(i, i + 2);
+    if (two === "//") {
+      while (i < code.length && code[i] !== `
+`)
+        out += " ", i++;
+      continue;
+    }
+    if (two === "/*") {
+      while (i < code.length && code.slice(i, i + 2) !== "*/")
+        out += code[i] === `
+` ? `
+` : " ", i++;
+      out += "  ";
+      i += 2;
+      continue;
+    }
+    const ch = code[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      out += " ";
+      i++;
+      while (i < code.length && code[i] !== quote) {
+        if (code[i] === "\\") {
+          out += "  ";
+          i += 2;
+          continue;
+        }
+        out += code[i] === `
+` ? `
+` : " ";
+        i++;
+      }
+      out += " ";
+      i++;
+      continue;
+    }
+    if (ch === "`") {
+      out += " ";
+      i++;
+      while (i < code.length && code[i] !== "`") {
+        if (code[i] === "\\") {
+          out += "  ";
+          i += 2;
+          continue;
+        }
+        if (code[i] === "$" && code[i + 1] === "{") {
+          const bodyStart = i + 2, bodyEnd = findInterpolationEnd(code, bodyStart);
+          out += "  ";
+          out += stripCommentsAndLiterals(code.slice(bodyStart, bodyEnd));
+          if (bodyEnd < code.length)
+            out += " ";
+          i = bodyEnd + 1;
+          continue;
+        }
+        out += code[i] === `
+` ? `
+` : " ";
+        i++;
+      }
+      out += " ";
+      i++;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}