fastscript 1.0.0 → 3.0.0

package/src/fs-linter.mjs

@@ -0,0 +1,274 @@
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { parseFastScript } from "./fs-parser.mjs";
+
+function walk(dir) {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) out.push(...walk(full));
+    else if (st.isFile()) out.push(full);
+  }
+  return out;
+}
+
+function spanFromNode(node, sourceLength) {
+  const start = Math.max(0, Math.min(sourceLength, Number(node?.fsRange?.[0] ?? node?.start ?? 0)));
+  const end = Math.max(start, Math.min(sourceLength, Number(node?.fsRange?.[1] ?? node?.end ?? start)));
+  return { start, end };
+}
+
+function createIssue({ file, source, lineStarts, code, severity, message, span, fix = null }) {
+  const start = Math.max(0, Math.min(source.length, span?.start ?? 0));
+  const end = Math.max(start, Math.min(source.length, span?.end ?? start + 1));
+  const loc = lineFromOffset(lineStarts, start);
+  return {
+    file,
+    line: loc.line,
+    column: loc.column,
+    span: { start, end },
+    code,
+    severity,
+    message,
+    fix,
+  };
+}
+
+function createLineStarts(source) {
+  const out = [0];
+  for (let i = 0; i < source.length; i += 1) {
+    if (source[i] === "\n") out.push(i + 1);
+  }
+  return out;
+}
+
+function lineFromOffset(lineStarts, offset) {
+  let lo = 0;
+  let hi = lineStarts.length - 1;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const start = lineStarts[mid];
+    const next = lineStarts[mid + 1] ?? Number.POSITIVE_INFINITY;
+    if (offset < start) hi = mid - 1;
+    else if (offset >= next) lo = mid + 1;
+    else return { line: mid + 1, column: offset - start + 1 };
+  }
+  return { line: 1, column: 1 };
+}
+
+function traverse(node, visitor, parent = null) {
+  if (!node || typeof node !== "object") return;
+  visitor(node, parent);
+  for (const value of Object.values(node)) {
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object") traverse(item, visitor, node);
+      }
+    } else if (typeof value === "object" && typeof value.type === "string") {
+      traverse(value, visitor, node);
+    }
+  }
+}
+
+function collectReassignedNames(estree) {
+  const names = new Set();
+  traverse(estree, (node) => {
+    if (node.type === "AssignmentExpression" && node.left?.type === "Identifier") {
+      names.add(node.left.name);
+    }
+    if (node.type === "UpdateExpression" && node.argument?.type === "Identifier") {
+      names.add(node.argument.name);
+    }
+  });
+  return names;
+}
+
+function declarationKeywordFixSpan(source, declaration, keyword) {
+  const span = spanFromNode(declaration, source.length);
+  const window = source.slice(span.start, Math.min(span.end, span.start + 64));
+  const pattern = new RegExp(`\\b${keyword}\\b`);
+  const match = pattern.exec(window);
+  if (!match) return null;
+  return {
+    start: span.start + match.index,
+    end: span.start + match.index + keyword.length,
+  };
+}
+
+function applyFixes(source, fixes) {
+  if (!fixes.length) return source;
+  const sorted = [...fixes]
+    .filter((fix) => fix && Number.isFinite(fix.start) && Number.isFinite(fix.end) && fix.start <= fix.end)
+    .sort((a, b) => {
+      if (a.start !== b.start) return a.start - b.start;
+      return a.end - b.end;
+    });
+
+  const nonOverlapping = [];
+  let cursor = -1;
+  for (const fix of sorted) {
+    if (fix.start < cursor) continue;
+    nonOverlapping.push(fix);
+    cursor = fix.end;
+  }
+
+  let output = source;
+  for (let i = nonOverlapping.length - 1; i >= 0; i -= 1) {
+    const fix = nonOverlapping[i];
+    output = `${output.slice(0, fix.start)}${fix.text}${output.slice(fix.end)}`;
+  }
+  return output;
+}
+
+function lintSource(source, { file }) {
+  const text = String(source ?? "");
+  const lineStarts = createLineStarts(text);
+  const parsed = parseFastScript(text, { file, mode: "lenient", recover: true });
+  const issues = [];
+  const fixes = [];
+
+  for (const diagnostic of parsed.diagnostics) {
+    issues.push(
+      createIssue({
+        file,
+        source: text,
+        lineStarts,
+        code: diagnostic.code,
+        severity: diagnostic.severity || "error",
+        message: diagnostic.message,
+        span: diagnostic.span,
+      }),
+    );
+  }
+
+  const todoPattern = /\bTODO_ERROR\b/g;
+  for (const match of text.matchAll(todoPattern)) {
+    const start = match.index ?? 0;
+    issues.push(
+      createIssue({
+        file,
+        source: text,
+        lineStarts,
+        code: "FS3001",
+        severity: "error",
+        message: "Remove TODO_ERROR token.",
+        span: { start, end: start + match[0].length },
+      }),
+    );
+  }
+
+  if (!parsed.estree) return { issues, fixes };
+
+  const reassignedNames = collectReassignedNames(parsed.estree);
+  traverse(parsed.estree, (node) => {
+    if (node.type === "VariableDeclaration") {
+      if (node.kind === "var") {
+        const fixSpan = declarationKeywordFixSpan(text, node, "var");
+        const fix = fixSpan ? { ...fixSpan, text: "let" } : null;
+        issues.push(
+          createIssue({
+            file,
+            source: text,
+            lineStarts,
+            code: "FS3002",
+            severity: "warning",
+            message: "Prefer `let` or `const` over `var`.",
+            span: spanFromNode(node, text.length),
+            fix,
+          }),
+        );
+        if (fix) fixes.push(fix);
+      }
+
+      if (node.kind === "let") {
+        const names = [];
+        for (const declaration of node.declarations || []) {
+          if (declaration.id?.type === "Identifier") names.push(declaration.id.name);
+        }
+        if (names.length > 0 && names.every((name) => !reassignedNames.has(name))) {
+          const fixSpan = declarationKeywordFixSpan(text, node, "let");
+          const fix = fixSpan ? { ...fixSpan, text: "const" } : null;
+          issues.push(
+            createIssue({
+              file,
+              source: text,
+              lineStarts,
+              code: "FS3004",
+              severity: "warning",
+              message: "Binding can be `const`.",
+              span: spanFromNode(node, text.length),
+              fix,
+            }),
+          );
+          if (fix) fixes.push(fix);
+        }
+      }
+    }
+
+    if (node.type === "TemplateElement" && /<script[\s>]/i.test(node.value?.raw || "")) {
+      issues.push(
+        createIssue({
+          file,
+          source: text,
+          lineStarts,
+          code: "FS3003",
+          severity: "warning",
+          message: "Avoid inline <script> tags in template literals.",
+          span: spanFromNode(node, text.length),
+        }),
+      );
+    }
+  });
+
+  return { issues, fixes };
+}
+
+export async function runLint(args = []) {
+  let target = "app";
+  let mode = "fail";
+  let fix = false;
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--path") target = args[i + 1] || target;
+    if (args[i] === "--mode") mode = (args[i + 1] || mode).toLowerCase();
+    if (args[i] === "--fix") fix = true;
+  }
+
+  const base = resolve(target);
+  const files = walk(base).filter((file) => extname(file) === ".fs");
+  const issues = [];
+
+  for (const file of files) {
+    const source = readFileSync(file, "utf8");
+    const result = lintSource(source, { file });
+    let next = source;
+    if (fix && result.fixes.length > 0) {
+      next = applyFixes(source, result.fixes);
+      if (next !== source) writeFileSync(file, next, "utf8");
+    }
+    issues.push(...result.issues);
+  }
+
+  issues.sort((a, b) => {
+    if (a.file !== b.file) return a.file.localeCompare(b.file);
+    if (a.span.start !== b.span.start) return a.span.start - b.span.start;
+    if (a.code !== b.code) return a.code.localeCompare(b.code);
+    return a.message.localeCompare(b.message);
+  });
+
+  for (const issue of issues) {
+    console.log(`${issue.file}:${issue.line}:${issue.column} ${issue.code} ${issue.severity} ${issue.message}`);
+  }
+
+  const blocking = issues.filter((issue) => issue.severity === "error");
+  if (blocking.length > 0 && mode !== "pass") {
+    const error = new Error(`lint failed: ${blocking.length} blocking issue(s)`);
+    error.status = 1;
+    error.details = blocking;
+    throw error;
+  }
+
+  console.log(`lint complete: ${files.length} file(s), ${issues.length} issue(s), mode=${mode}, fix=${fix}`);
+}

package/src/fs-normalize.mjs

@@ -1,232 +1,21 @@
-const reactiveDeclPattern = /^(\s*)~([A-Za-z_$][\w$]*)(\s*=\s*.*)$/;
-const stateDeclPattern = /^(\s*)state\s+([A-Za-z_$][\w$]*)(\s*=\s*.*)$/;
-const fnDeclPattern = /^(\s*)(export\s+)?fn\s+([A-Za-z_$][\w$]*)\s*\(/;
-const reactiveStartPattern = /^\s*~/;
-const stateStartPattern = /^\s*state\b/;
-const emptyImportClausePattern = /^\s*import\s*\{\s*\}\s*from\s*["'][^"']+["']/;
-const invalidFnPattern = /^\s*(export\s+)?fn\b(?!\s+[A-Za-z_$][\w$]*\s*\()/;
-const relativeJsImportPattern = /from\s+["'](\.?\.?\/[^"']+)\.(js|jsx|ts|tsx)["']/;
-
-function nowMs() {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
-
-function toDiag(severity, line, col, code, message, fix = null) {
-  return { severity, line, col, code, message, fix };
-}
-
-function normalizeFastScriptInternal(source, stats) {
-  const lines = source.split(/\r?\n/);
-  const out = [];
-
-  for (const line of lines) {
-    const m = line.match(reactiveDeclPattern);
-    if (m) {
-      stats.reactiveToLet += 1;
-      out.push(`${m[1]}let ${m[2]}${m[3]}`);
-      continue;
-    }
-    const s = line.match(stateDeclPattern);
-    if (s) {
-      stats.stateToLet += 1;
-      out.push(`${s[1]}let ${s[2]}${s[3]}`);
-      continue;
-    }
-    const f = line.match(fnDeclPattern);
-    if (f) {
-      stats.fnToFunction += 1;
-      out.push(line.replace(fnDeclPattern, `${f[1]}${f[2] ?? ""}function ${f[3]}(`));
-      continue;
-    }
-    out.push(line);
-  }
-
-  return out.join("\n");
-}
-
-export function analyzeFastScriptSource(source, { filename = "input.fs" } = {}) {
-  const lines = source.split(/\r?\n/);
-  const diagnostics = [];
-  const declaredState = new Map();
-  const isFs = /\.fs$/i.test(filename);
-
-  for (let i = 0; i < lines.length; i += 1) {
-    const lineNo = i + 1;
-    const line = lines[i];
-
-    if (!line.trim()) continue;
-
-    const reactive = line.match(reactiveDeclPattern);
-    if (reactive) {
-      const name = reactive[2];
-      const first = declaredState.get(name);
-      if (first !== undefined) {
-        diagnostics.push(
-          toDiag(
-            "warning",
-            lineNo,
-            Math.max(1, line.indexOf(name) + 1),
-            "FS_DUP_STATE",
-            `Duplicate reactive/state declaration "${name}" (first seen on line ${first})`,
-            "Rename one declaration to avoid shadowing confusion.",
-          ),
-        );
-      } else {
-        declaredState.set(name, lineNo);
-      }
-      continue;
-    }
-
-    const state = line.match(stateDeclPattern);
-    if (state) {
-      const name = state[2];
-      const first = declaredState.get(name);
-      if (first !== undefined) {
-        diagnostics.push(
-          toDiag(
-            "warning",
-            lineNo,
-            Math.max(1, line.indexOf(name) + 1),
-            "FS_DUP_STATE",
-            `Duplicate reactive/state declaration "${name}" (first seen on line ${first})`,
-            "Rename one declaration to avoid shadowing confusion.",
-          ),
-        );
-      } else {
-        declaredState.set(name, lineNo);
-      }
-      continue;
-    }
-
-    if (reactiveStartPattern.test(line)) {
-      diagnostics.push(
-        toDiag(
-          "warning",
-          lineNo,
-          Math.max(1, line.indexOf("~") + 1),
-          "FS_BAD_REACTIVE",
-          "Reactive declaration expected format: ~name = value",
-          "Use: ~count = 0",
-        ),
-      );
-    }
-
-    if (stateStartPattern.test(line) && !stateDeclPattern.test(line)) {
-      diagnostics.push(
-        toDiag(
-          "warning",
-          lineNo,
-          Math.max(1, line.indexOf("state") + 1),
-          "FS_BAD_STATE",
-          "State declaration expected format: state name = value",
-          "Use: state count = 0",
-        ),
-      );
-    }
-
-    if (emptyImportClausePattern.test(line)) {
-      diagnostics.push(
-        toDiag(
-          "error",
-          lineNo,
-          Math.max(1, line.indexOf("import") + 1),
-          "FS_EMPTY_IMPORT",
-          "Empty import clause is invalid.",
-          'Remove import or import at least one symbol: import { x } from "./mod.fs"',
-        ),
-      );
-    }
-
-    if (invalidFnPattern.test(line)) {
-      diagnostics.push(
-        toDiag(
-          "warning",
-          lineNo,
-          Math.max(1, line.indexOf("fn") + 1),
-          "FS_BAD_FN",
-          'Function shorthand expected format: fn name(args) { ... }',
-          "Use: fn run(input) { ... }",
-        ),
-      );
-    }
-
-    if (isFs && relativeJsImportPattern.test(line)) {
-      diagnostics.push(
-        toDiag(
-          "warning",
-          lineNo,
-          Math.max(1, line.indexOf("from") + 1),
-          "FS_RELATIVE_JS_IMPORT",
-          "Relative .js/.ts import inside .fs can hinder migration portability.",
-          "Prefer extensionless imports or .fs extension for local modules.",
-        ),
-      );
-    }
-  }
-
-  return diagnostics;
-}
-
-export function formatFastScriptDiagnostics(
-  diagnostics,
-  { filename = "input.fs", includeWarnings = true } = {},
-) {
-  const filtered = includeWarnings ? diagnostics : diagnostics.filter((d) => d.severity === "error");
-  if (filtered.length === 0) return "";
-  const lines = filtered.map((d) => {
-    const sev = d.severity.toUpperCase();
-    const fix = d.fix ? `\n  fix: ${d.fix}` : "";
-    return `[${sev}] ${d.code} ${filename}:${d.line}:${d.col}\n  ${d.message}${fix}`;
+import { compileFastScript } from "./fs-parser.mjs";
+
+export function normalizeFastScript(source, options = {}) {
+  const { code } = compileFastScript(source, {
+    file: options.file || "",
+    mode: options.mode || "lenient",
+    recover: options.recover !== false,
+    inlineSourceMap: options.sourceMap === "inline",
   });
-  return lines.join("\n");
-}
-
-export function createFastScriptDiagnosticError(
-  diagnostics,
-  { filename = "input.fs", includeWarnings = false } = {},
-) {
-  const printable = formatFastScriptDiagnostics(diagnostics, { filename, includeWarnings });
-  const error = new Error(printable || `FastScript diagnostics failed for ${filename}`);
-  error.code = "FASTSCRIPT_DIAGNOSTICS";
-  error.diagnostics = diagnostics;
-  return error;
-}
-
-export function normalizeFastScriptWithTelemetry(source, { filename = "input.fs", strict = false } = {}) {
-  const startedAt = nowMs();
-  const diagnostics = analyzeFastScriptSource(source, { filename });
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  if (strict && errors.length > 0) {
-    throw createFastScriptDiagnosticError(errors, { filename, includeWarnings: false });
-  }
-
-  const transformStats = {
-    reactiveToLet: 0,
-    stateToLet: 0,
-    fnToFunction: 0,
-  };
-  const code = normalizeFastScriptInternal(source, transformStats);
-  const durationMs = nowMs() - startedAt;
-
-  return {
-    code,
-    diagnostics,
-    stats: {
-      lineCount: source.split(/\r?\n/).length,
-      durationMs,
-      ...transformStats,
-    },
-  };
+  return code;
 }
 
-export function normalizeFastScript(source) {
-  return normalizeFastScriptInternal(source, {
-    reactiveToLet: 0,
-    stateToLet: 0,
-    fnToFunction: 0,
+export function normalizeFastScriptWithMetadata(source, options = {}) {
+  return compileFastScript(source, {
+    file: options.file || "",
+    mode: options.mode || "lenient",
+    recover: options.recover !== false,
+    inlineSourceMap: options.sourceMap === "inline",
   });
 }
 
@@ -253,52 +42,76 @@ export function stripTypeScriptHints(source) {
 
     if (/^\s*interface\s+[A-Za-z_$][\w$]*\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      skippingBlock = true;
       const opens = (next.match(/{/g) || []).length;
       const closes = (next.match(/}/g) || []).length;
-      const depth = opens - closes;
-      if (depth > 0) {
-        skippingBlock = true;
-        blockDepth = depth;
-      }
+      blockDepth = Math.max(1, opens - closes);
       continue;
     }
 
     if (/^\s*type\s+[A-Za-z_$][\w$]*\s*=/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
       if (!next.includes(";") && next.includes("{")) {
+        skippingBlock = true;
+        const opens = (next.match(/{/g) || []).length;
+        const closes = (next.match(/}/g) || []).length;
+        blockDepth = Math.max(1, opens - closes);
+      }
+      continue;
+    }
+
+    if (/^\s*declare\s+(global|module|namespace)\b/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      if (next.includes("{")) {
+        skippingBlock = true;
         const opens = (next.match(/{/g) || []).length;
         const closes = (next.match(/}/g) || []).length;
-        const depth = opens - closes;
-        if (depth > 0) {
-          skippingBlock = true;
-          blockDepth = depth;
-        }
+        blockDepth = Math.max(1, opens - closes);
       }
       continue;
     }
 
+    if (/^\s*declare\s+/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      continue;
+    }
+
     next = next.replace(/\bimport\s+type\b/g, "import");
     next = next.replace(/\bexport\s+type\b/g, "export");
+    next = next.replace(/\btype\s+([A-Za-z_$][\w$]*)\s+as\s+/g, "$1 as ");
+    next = next.replace(/\b(?:public|private|protected|readonly|declare|override|abstract)\s+/g, "");
+    next = next.replace(/\s+implements\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]+/g, "");
+    next = next.replace(/([A-Za-z_$][\w$]*)!([?:;=,\)])/g, "$1$2");
 
     next = next.replace(
       /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*([^=;]+)([=;].*)$/,
       "$1$2 $3 $5",
     );
+    next = next.replace(
+      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*=\s*/,
+      "$1$2 $3 = ",
+    );
 
-    if (/\bfunction\b/.test(next) || /\)\s*=>/.test(next)) {
+    if (/\bfunction\b/.test(next) || /\bfn\b/.test(next) || /\)\s*=>/.test(next)) {
       next = next.replace(/\(([^)]*)\)/, (_, params) => {
         const cleaned = params.replace(
-          /([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$<>\[\]\|& ?. ]*)/g,
+          /([A-Za-z_$][\w$]*)(\?)?\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)/g,
           "$1",
         );
         return `(${cleaned})`;
       });
-      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|& ?. ]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*=>/g, ") =>");
       next = next.replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
+      next = next.replace(/\bfn\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "fn $1(");
+      next = next.replace(/=\s*async\s*<[^>]+>\s*\(/g, "= async (");
+      next = next.replace(/=\s*<[^>]+>\s*\(/g, "= (");
     }
 
     next = next.replace(/^\s*<([A-Za-z_$][\w$,\s]*)>\s*\(/, "(");
     next = next.replace(/\)\s*=>\s*<[A-Za-z_$][\w$<>\[\]\|&, ?.]*>/g, ") =>");
+    next = next.replace(/\s+as\s+const\b/g, "");
+    next = next.replace(/\s+as\s+[A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*/g, "");
     next = next.replace(/\sas\s+const\b/g, "");
     next = next.replace(/\s+satisfies\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]*/g, "");
     out.push(next);

package/src/fs-parser.mjs

@@ -0,0 +1 @@
+export * from "@fastscript/core-private/parser";