fastscript 1.0.0 → 2.0.0

package/node_modules/@fastscript/core-private/src/env.mjs

@@ -0,0 +1,118 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { importSourceModule } from "./module-loader.mjs";
+
+function parseDotEnv(raw) {
+  const out = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx <= 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let val = trimmed.slice(idx + 1).trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
+    out[key] = val;
+  }
+  return out;
+}
+
+export function loadEnv({ root = process.cwd(), mode = process.env.NODE_ENV || "development" } = {}) {
+  const profile = process.env.FASTSCRIPT_PROFILE || mode;
+  const files = [
+    ".env",
+    `.env.${mode}`,
+    profile !== mode ? `.env.${profile}` : null,
+    mode === "production" ? ".env.local" : null,
+  ].filter(Boolean);
+  const merged = {};
+  const configPath = join(root, "fastscript.config.json");
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      Object.assign(merged, config?.profiles?.[profile] || {});
+    } catch {}
+  }
+  for (const file of files) {
+    const path = join(root, file);
+    if (!existsSync(path)) continue;
+    Object.assign(merged, parseDotEnv(readFileSync(path, "utf8")));
+  }
+  for (const [k, v] of Object.entries(merged)) if (process.env[k] === undefined) process.env[k] = v;
+  return { mode, profile, values: merged };
+}
+
+export function validateEnv(schema = {}, env = process.env) {
+  const errors = [];
+  const out = {};
+  for (const [key, ruleRaw] of Object.entries(schema || {})) {
+    const rule = typeof ruleRaw === "string" ? { type: ruleRaw } : { ...(ruleRaw || {}) };
+    const type = String(rule.type || "string").replace(/\?$/, "");
+    const optional = String(rule.type || "").endsWith("?") || rule.optional === true;
+    const value = env[key];
+    if (value === undefined || value === "") {
+      if (!optional) errors.push(`${key} is required`);
+      continue;
+    }
+    if (type === "int") {
+      const n = Number(value);
+      if (!Number.isInteger(n)) errors.push(`${key} must be int`); else out[key] = n;
+      continue;
+    }
+    if (type === "float" || type === "number") {
+      const n = Number(value);
+      if (!Number.isFinite(n)) errors.push(`${key} must be number`); else out[key] = n;
+      continue;
+    }
+    if (type === "bool" || type === "boolean") {
+      if (!["true", "false", true, false].includes(value)) errors.push(`${key} must be boolean`);
+      else out[key] = value === true || value === "true";
+      continue;
+    }
+    out[key] = String(value);
+  }
+  if (errors.length) {
+    const error = new Error(`Env validation failed: ${errors.join("; ")}`);
+    error.status = 500;
+    error.details = errors;
+    throw error;
+  }
+  return out;
+}
+
+export async function validateAppEnv({ root = process.cwd() } = {}) {
+  const fsSchema = join(root, "app", "env.schema.fs");
+  const jsSchema = join(root, "app", "env.schema.js");
+  const schemaPath = existsSync(fsSchema) ? fsSchema : jsSchema;
+  if (!existsSync(schemaPath)) return null;
+  const mod = schemaPath.endsWith('.fs')
+    ? await importSourceModule(schemaPath, { platform: "node" })
+    : await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
+  const schema = mod.schema || mod.default || {};
+  return validateEnv(schema, process.env);
+}
+
+export function ensureEnvExample() {
+  const example = join(process.cwd(), ".env.example");
+  if (existsSync(example)) return;
+  writeFileSync(example, "# FastScript env template\nSESSION_SECRET=change_me\n", "utf8");
+}
+
+export function appendEnvIfMissing(key, value) {
+  const path = join(process.cwd(), ".env");
+  const current = existsSync(path) ? readFileSync(path, "utf8") : "";
+  if (current.includes(`${key}=`)) return;
+  appendFileSync(path, `${key}=${value}\n`, "utf8");
+}
+
+export function listConfigProfiles({ root = process.cwd() } = {}) {
+  const path = join(root, "fastscript.config.json");
+  if (!existsSync(path)) return [];
+  try {
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    return Object.keys(config.profiles || {});
+  } catch {
+    return [];
+  }
+}

package/node_modules/@fastscript/core-private/src/export.mjs

@@ -0,0 +1,83 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+
+const VALID_TARGETS = new Set(["js", "ts"]);
+
+function walk(dir) {
+  const out = [];
+  if (!existsSync(dir)) return out;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walk(full));
+    else if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+
+function rewriteImportsForTarget(source, to) {
+  let out = source
+    .replace(/from\s+["'](\.\/[^"']+)\.fs["']/g, `from "$1.${to}"`)
+    .replace(/from\s+["'](\.\.\/[^"']+)\.fs["']/g, `from "$1.${to}"`)
+    .replace(/import\(\s*["'](\.\/[^"']+)\.fs["']\s*\)/g, `import("$1.${to}")`)
+    .replace(/import\(\s*["'](\.\.\/[^"']+)\.fs["']\s*\)/g, `import("$1.${to}")`);
+  out = out
+    .replace(/require\(\s*["'](\.\/[^"']+)\.fs["']\s*\)/g, `require("$1.${to}")`)
+    .replace(/require\(\s*["'](\.\.\/[^"']+)\.fs["']\s*\)/g, `require("$1.${to}")`);
+  return out;
+}
+
+function toTargetPath(file, to) {
+  if (extname(file) === ".fs") return file.replace(/\.fs$/, `.${to}`);
+  return file;
+}
+
+export async function runExport(args = []) {
+  let to = "js";
+  let out = "exported-app";
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--to") to = (args[i + 1] || "").toLowerCase();
+    if (arg === "--out") out = args[i + 1] || out;
+  }
+
+  if (!VALID_TARGETS.has(to)) {
+    throw new Error('Invalid export target. Use: fastscript export --to js|ts');
+  }
+
+  const appDir = resolve("app");
+  const outDir = resolve(out);
+  if (!existsSync(appDir)) throw new Error("Missing app directory.");
+
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  // Copy non-page assets/directories first.
+  for (const entry of readdirSync(appDir, { withFileTypes: true })) {
+    if (entry.name === "pages") continue;
+    const src = join(appDir, entry.name);
+    const dest = join(outDir, entry.name);
+    if (entry.isDirectory()) cpSync(src, dest, { recursive: true });
+    else cpSync(src, dest);
+  }
+
+  const pageRoot = join(appDir, "pages");
+  const pageFiles = walk(pageRoot);
+  for (const file of pageFiles) {
+    const rel = relative(appDir, file);
+    const nextPath = toTargetPath(rel, to);
+    const outFile = join(outDir, nextPath);
+    mkdirSync(dirname(outFile), { recursive: true });
+
+    const ext = extname(file);
+    let source = readFileSync(file, "utf8");
+    if (ext === ".fs") source = normalizeFastScript(source);
+    source = rewriteImportsForTarget(source, to);
+    if (to === "ts") source = `// @ts-nocheck\n${source}`;
+
+    writeFileSync(outFile, source, "utf8");
+  }
+
+  console.log(`export complete: app -> ${out} (target: ${to})`);
+}

package/node_modules/@fastscript/core-private/src/fs-diagnostics.mjs

@@ -0,0 +1,70 @@
+import { formatDiagnostic, parseFastScript } from "./fs-parser.mjs";
+
+function displayPath(file) {
+  return file || "<memory>";
+}
+
+function safeLine(lines, line) {
+  const index = Math.max(0, Math.min(lines.length - 1, line - 1));
+  return lines[index] ?? "";
+}
+
+function renderPrimarySnippet(diagnostic, source) {
+  if (!source || !diagnostic) return "";
+  const lines = String(source).split(/\r?\n/);
+  const lineText = safeLine(lines, diagnostic.line);
+  const markerStart = Math.max(1, diagnostic.column || 1);
+  const markerEnd = Math.max(markerStart, diagnostic.endColumn || markerStart);
+  const width = Math.max(1, markerEnd - markerStart);
+  const pointer = `${" ".repeat(markerStart - 1)}${"^".repeat(width)}`;
+  return `${String(diagnostic.line).padStart(4, " ")} | ${lineText}\n     | ${pointer}`;
+}
+
+export function formatDiagnosticsReport(diagnostics, { source = "" } = {}) {
+  if (!diagnostics?.length) return "";
+  const ordered = [...diagnostics].sort((a, b) => {
+    const startA = a.span?.start ?? 0;
+    const startB = b.span?.start ?? 0;
+    if (startA !== startB) return startA - startB;
+    return a.code.localeCompare(b.code);
+  });
+
+  return ordered
+    .map((diagnostic) => {
+      const details = [formatDiagnostic(diagnostic)];
+      const snippet = renderPrimarySnippet(diagnostic, source);
+      if (snippet) details.push(snippet);
+      for (const related of diagnostic.related || []) {
+        details.push(
+          `  related ${displayPath(related.file)}:${related.line}:${related.column} ${related.message}`,
+        );
+      }
+      for (const fix of diagnostic.fixes || []) {
+        const text = String(fix.text ?? "").replace(/\n/g, "\\n");
+        details.push(`  fix ${fix.message || "Apply fix"} -> ${text}`);
+      }
+      return details.join("\n");
+    })
+    .join("\n\n");
+}
+
+export function analyzeFastScript(source, { file = "", mode = "lenient" } = {}) {
+  const ast = parseFastScript(source, { file, mode, recover: true });
+  return ast.diagnostics;
+}
+
+export function assertFastScript(source, { file = "", mode = "strict" } = {}) {
+  const diagnostics = analyzeFastScript(source, { file, mode: "lenient" });
+  if (!diagnostics.length) return;
+  const blocking = diagnostics.filter((diagnostic) => diagnostic.severity !== "warning");
+  if (!blocking.length && mode !== "strict") return;
+
+  const primary = (blocking.length ? blocking : diagnostics)[0];
+  const report = formatDiagnosticsReport(diagnostics, { source });
+  const path = displayPath(primary.file);
+  const error = new Error(`${path}:${primary.line}:${primary.column} ${primary.code} ${primary.message}\n${report}`);
+  error.status = 1;
+  error.details = diagnostics;
+  error.report = report;
+  throw error;
+}

package/node_modules/@fastscript/core-private/src/fs-error-codes.mjs

@@ -0,0 +1,141 @@
+export const FS_ERROR_CODES = Object.freeze({
+  FS1001: {
+    severity: "error",
+    message: "Invalid reactive declaration.",
+    hint: "Reactive declarations must be `~name = expression`.",
+  },
+  FS1002: {
+    severity: "error",
+    message: "Invalid state declaration.",
+    hint: "State declarations must be `state name = expression`.",
+  },
+  FS1003: {
+    severity: "error",
+    message: "Invalid function declaration.",
+    hint: "Function declarations must use `fn name(...) { ... }` or `export fn ...`.",
+  },
+  FS1004: {
+    severity: "error",
+    message: "Type declarations are not valid runtime FastScript syntax.",
+    hint: "Move `type`, `interface`, and `enum` definitions to `.d.ts` files or remove them from `.fs` files.",
+  },
+  FS1005: {
+    severity: "error",
+    message: "FastScript parse error.",
+    hint: "Check punctuation and statement structure near the reported location.",
+  },
+  FS1006: {
+    severity: "error",
+    message: "Invalid identifier.",
+    hint: "Identifiers must start with a letter, `_`, or `$`.",
+  },
+  FS1007: {
+    severity: "warning",
+    message: "Suspicious `TODO_ERROR` token found.",
+    hint: "Remove placeholder tokens before shipping.",
+  },
+  FS1010: {
+    severity: "error",
+    message: "Unterminated token.",
+    hint: "Close the string, template, regex, or comment that starts near this location.",
+  },
+  FS1101: {
+    severity: "warning",
+    message: "Unsupported language directive.",
+    hint: "Use directives listed in the FastScript language specification.",
+  },
+  FS2001: {
+    severity: "warning",
+    message: "Prefer `const` when a binding is never reassigned.",
+    hint: "Use lint autofix to rewrite `let` to `const` when safe.",
+  },
+  FS2002: {
+    severity: "warning",
+    message: "Avoid inline `<script>` tags in templates.",
+    hint: "Move script behavior into module functions or hydration handlers.",
+  },
+  FS3001: {
+    severity: "error",
+    message: "`TODO_ERROR` token is not allowed in committed code.",
+    hint: "Delete placeholder tokens before merging.",
+  },
+  FS3002: {
+    severity: "warning",
+    message: "`var` is discouraged in FastScript modules.",
+    hint: "Replace `var` with `let` or `const`.",
+  },
+  FS3003: {
+    severity: "warning",
+    message: "Inline `<script>` tag detected in template literal.",
+    hint: "Use external module code instead of embedding scripts in markup strings.",
+  },
+  FS3004: {
+    severity: "warning",
+    message: "Binding can be `const`.",
+    hint: "Apply the autofix to preserve intent and reduce accidental reassignment.",
+  },
+  FS4001: {
+    severity: "error",
+    message: "Duplicate route mapping detected.",
+    hint: "Ensure each route path+slot pair is unique.",
+  },
+  FS4002: {
+    severity: "warning",
+    message: "Route param is declared but not referenced.",
+    hint: "Use `params.<name>` or remove the dynamic segment.",
+  },
+  FS4101: {
+    severity: "error",
+    message: "Unknown symbol.",
+    hint: "Declare the symbol before use or import it from another module.",
+  },
+  FS4102: {
+    severity: "error",
+    message: "Cannot reassign `const` binding.",
+    hint: "Change the declaration to `let` or remove the assignment.",
+  },
+  FS4103: {
+    severity: "error",
+    message: "Type mismatch in assignment.",
+    hint: "Align assigned expression type with the declared/inferred variable type.",
+  },
+  FS4104: {
+    severity: "error",
+    message: "Incorrect function argument count.",
+    hint: "Pass the required number of arguments or update the function signature.",
+  },
+  FS4105: {
+    severity: "error",
+    message: "Incompatible return type.",
+    hint: "Ensure all return paths in the function resolve to compatible types.",
+  },
+  FS4106: {
+    severity: "error",
+    message: "Attempted to call a non-function value.",
+    hint: "Ensure the callee resolves to a function.",
+  },
+  FS4107: {
+    severity: "error",
+    message: "Invalid operand types for operator.",
+    hint: "Use operands compatible with the operator semantics.",
+  },
+  FS4108: {
+    severity: "error",
+    message: "Browser-only symbol used in non-browser runtime context.",
+    hint: "Move this code to a browser module or gate it behind runtime-aware logic.",
+  },
+  FS4109: {
+    severity: "error",
+    message: "Server-only symbol used in browser runtime context.",
+    hint: "Move this code to server/runtime modules or use a shared-safe abstraction.",
+  },
+  FS4201: {
+    severity: "error",
+    message: "Symbol is not available in this runtime context.",
+    hint: "Use a symbol available in the current context or move code to the correct runtime module.",
+  },
+});
+
+export function resolveErrorMeta(code) {
+  return FS_ERROR_CODES[code] || { severity: "error", message: "FastScript compiler error." };
+}

package/node_modules/@fastscript/core-private/src/fs-formatter.mjs

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { generate } from "astring";
+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 shouldThrowForFormat(diagnostics) {
+  return diagnostics.some((diagnostic) => diagnostic.severity !== "warning");
+}
+
+export function formatFastScriptSource(source, { file = "" } = {}) {
+  const parsed = parseFastScript(source, { file, mode: "lenient", recover: true });
+  if (!parsed.estree || shouldThrowForFormat(parsed.diagnostics)) {
+    return String(source ?? "");
+  }
+
+  const formatted = generate(parsed.estree, {
+    comments: false,
+    indent: "  ",
+    lineEnd: "\n",
+  });
+
+  return formatted.endsWith("\n") ? formatted : `${formatted}\n`;
+}
+
+export async function runFormat(args = []) {
+  let target = "app";
+  let write = true;
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--path") target = args[i + 1] || target;
+    if (args[i] === "--check") write = false;
+    if (args[i] === "--write") write = true;
+  }
+
+  const base = resolve(target);
+  const files = walk(base).filter((file) => extname(file) === ".fs");
+  let changed = 0;
+
+  for (const file of files) {
+    const current = readFileSync(file, "utf8");
+    const next = formatFastScriptSource(current, { file });
+    if (current !== next) {
+      changed += 1;
+      if (write) writeFileSync(file, next, "utf8");
+    }
+  }
+
+  if (!write && changed > 0) {
+    const error = new Error(`format check failed: ${changed} file(s) need formatting`);
+    error.status = 1;
+    throw error;
+  }
+
+  console.log(`format ${write ? "write" : "check"} complete: ${files.length} file(s), ${changed} changed`);
+}