jskelet 0.3.5 → 0.4.1

package/src/compile/compile-all.js

@@ -0,0 +1,158 @@
+/**
+ * Tüm `.jsk` dosyalarını derleyip `.jskelet/templates/` altına yazar.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseTemplate } from "./parse.js";
+import { codegen, normalizeIncludeId } from "./codegen.js";
+import { CompileError } from "./errors.js";
+import {
+  collectKnownComponents,
+  componentNameFromViewId,
+  discoverJskFiles,
+  getComponentDirs,
+  getViewRoots,
+} from "./resolve.js";
+
+/**
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @param {{ quiet?: boolean }} [options]
+ * @returns {Promise<{ count: number, manifest: Record<string, string>, outDir: string }>}
+ */
+export async function compileAll(config, options = {}) {
+  const outDir = path.join(config.dirs.generated, "templates");
+  const viewRoots = getViewRoots(config);
+  const jskFiles = discoverJskFiles(viewRoots);
+  const componentDirs = getComponentDirs(config);
+  const knownComponents = collectKnownComponents(componentDirs, jskFiles);
+
+  // Önceki çıktıyı temizle — silinmiş şablonlar kalmasın.
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  /** @type {Record<string, string>} */
+  const manifest = {};
+  /** @type {Map<string, { code: string, includes: string[] }>} */
+  const compiled = new Map();
+
+  for (const [viewId, file] of jskFiles) {
+    const source = fs.readFileSync(file, "utf8");
+    const relative = path.relative(config.root, file).split(path.sep).join("/");
+
+    let ast;
+    try {
+      ast = parseTemplate(source, { file: relative });
+    } catch (error) {
+      if (error instanceof CompileError) throw error;
+      throw error;
+    }
+
+    const { code, includes, components: usedComponents } = codegen(ast, {
+      viewId,
+      file: relative,
+      knownComponents: null,
+    });
+
+    for (const name of usedComponents) {
+      if (knownComponents.has(name)) continue;
+      const camel = name.charAt(0).toLowerCase() + name.slice(1);
+      if (knownComponents.has(camel)) continue;
+      if (!options.quiet) {
+        console.warn(`[jsk] ${relative}: component "${name}" was not found at compile time`);
+      }
+    }
+
+    compiled.set(viewId, { code, includes });
+  }
+
+  // Include hedefleri mevcut mu?
+  for (const [viewId, { includes }] of compiled) {
+    for (const id of includes) {
+      const normalized = normalizeIncludeId(id);
+      if (!compiled.has(normalized) && !jskFiles.has(normalized)) {
+        const file = jskFiles.get(viewId);
+        const relative = file
+          ? path.relative(config.root, file).split(path.sep).join("/")
+          : viewId;
+        throw new CompileError(`Unknown include "${id}"`, { file: relative });
+      }
+    }
+  }
+
+  for (const [viewId, { code }] of compiled) {
+    const outFile = path.join(outDir, `${viewId}.mjs`);
+    fs.mkdirSync(path.dirname(outFile), { recursive: true });
+    fs.writeFileSync(outFile, code, "utf8");
+    manifest[viewId] = `${viewId}.mjs`.split(path.sep).join("/");
+  }
+
+  const manifestPath = path.join(outDir, "manifest.json");
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+
+  // Bileşen adı → view id haritası (runtime kayıt için)
+  /** @type {Record<string, string>} */
+  const components = {};
+  for (const viewId of Object.keys(manifest)) {
+    const name = componentNameFromViewId(viewId);
+    if (name) components[name] = viewId;
+  }
+  fs.writeFileSync(
+    path.join(outDir, "components.json"),
+    `${JSON.stringify(components, null, 2)}\n`,
+    "utf8",
+  );
+
+  return { count: compiled.size, manifest, outDir };
+}
+
+/**
+ * Manifest yoksa veya herhangi bir `.jsk` daha yeniyse yeniden derler.
+ * Dev sunucu restart'ında build watch kaçırmış olsa bile şablonlar güncel kalır.
+ *
+ * @param {{ root: string, dirs: Record<string, string> }} config
+ * @returns {Promise<{ count: number, rebuilt: boolean }>}
+ */
+export async function ensureTemplatesCompiled(config) {
+  const viewRoots = getViewRoots(config);
+  const jskFiles = discoverJskFiles(viewRoots);
+  if (jskFiles.size === 0) {
+    return { count: 0, rebuilt: false };
+  }
+
+  const outDir = path.join(config.dirs.generated, "templates");
+  const manifestPath = path.join(outDir, "manifest.json");
+  let needs = !fs.existsSync(manifestPath);
+
+  if (!needs) {
+    const manifestMtime = fs.statSync(manifestPath).mtimeMs;
+    for (const file of jskFiles.values()) {
+      if (fs.statSync(file).mtimeMs > manifestMtime) {
+        needs = true;
+        break;
+      }
+    }
+  }
+
+  if (!needs) {
+    return { count: jskFiles.size, rebuilt: false };
+  }
+
+  const result = await compileAll(config, { quiet: true });
+  return { count: result.count, rebuilt: true };
+}
+
+/**
+ * Tek kaynak dizgisini derler (birim testleri).
+ * @param {string} source
+ * @param {{ viewId?: string, file?: string, knownComponents?: Set<string> }} [options]
+ * @returns {{ code: string, includes: string[], components: string[] }}
+ */
+export function compileSource(source, options = {}) {
+  const viewId = options.viewId ?? "test";
+  const ast = parseTemplate(source, { file: options.file ?? "test.jsk" });
+  return codegen(ast, {
+    viewId,
+    file: options.file ?? "test.jsk",
+    knownComponents: options.knownComponents ?? null,
+  });
+}

package/src/compile/errors.js

@@ -0,0 +1,66 @@
+/**
+ * Şablon derleme hataları. Satır/sütun korunur ki DX overlay ve CLI
+ * çıktısı kaynağa işaret edebilsin.
+ */
+
+/**
+ * @param {string} source
+ * @param {number} index
+ * @returns {{ line: number, column: number }}
+ */
+export function indexToLocation(source, index) {
+  let line = 1;
+  let column = 1;
+  const end = Math.min(index, source.length);
+  for (let i = 0; i < end; i++) {
+    if (source[i] === "\n") {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column };
+}
+
+/**
+ * @param {string} source
+ * @param {number} line
+ * @returns {string}
+ */
+function lineSnippet(source, line) {
+  const lines = source.split(/\r?\n/);
+  return lines[line - 1] ?? "";
+}
+
+export class CompileError extends Error {
+  /**
+   * @param {string} message
+   * @param {{ file?: string, source?: string, index?: number,
+   *   line?: number, column?: number }} [opts]
+   */
+  constructor(message, opts = {}) {
+    let line = opts.line;
+    let column = opts.column;
+    if ((line == null || column == null) && opts.source != null && opts.index != null) {
+      const loc = indexToLocation(opts.source, opts.index);
+      line = loc.line;
+      column = loc.column;
+    }
+
+    const where =
+      opts.file && line != null
+        ? `${opts.file}:${line}:${column ?? 1}`
+        : opts.file ?? "";
+    const snippet =
+      opts.source && line != null ? lineSnippet(opts.source, line).trimEnd() : "";
+    const head = where ? `${where}\n` : "";
+    const body = snippet ? `${message}\n\n  ${snippet}\n  ${" ".repeat((column ?? 1) - 1)}^` : message;
+
+    super(`${head}${body}`);
+    this.name = "CompileError";
+    this.file = opts.file;
+    this.line = line;
+    this.column = column;
+  }
+}

package/src/compile/expr.js

@@ -0,0 +1,404 @@
+/**
+ * Şablon ifadeleri — kısıtlı alt küme. İstek anında yorumlanmaz; build'de
+ * JS kaynak metnine çevrilir. Çağrı, atama ve `new` yok.
+ */
+import { CompileError } from "./errors.js";
+
+/**
+ * @typedef {{ type: 'Literal', value: string | number | boolean | null, raw: string }} LiteralNode
+ * @typedef {{ type: 'Ident', name: string }} IdentNode
+ * @typedef {{ type: 'Member', object: ExprNode, property: string, optional: boolean }} MemberNode
+ * @typedef {{ type: 'Index', object: ExprNode, index: ExprNode, optional: boolean }} IndexNode
+ * @typedef {{ type: 'Unary', op: '!' | '-', argument: ExprNode }} UnaryNode
+ * @typedef {{ type: 'Binary', op: string, left: ExprNode, right: ExprNode }} BinaryNode
+ * @typedef {{ type: 'Cond', test: ExprNode, consequent: ExprNode, alternate: ExprNode }} CondNode
+ * @typedef {LiteralNode | IdentNode | MemberNode | IndexNode | UnaryNode | BinaryNode | CondNode} ExprNode
+ */
+
+const IDENT_START = /[A-Za-z_$]/
+const IDENT_CONT = /[A-Za-z0-9_$]/
+
+/**
+ * @param {string} source
+ * @param {number} start
+ * @param {number} end
+ * @param {{ file?: string, templateSource?: string, templateIndex?: number }} [meta]
+ * @returns {ExprNode}
+ */
+export function parseExpr(source, start = 0, end = source.length, meta = {}) {
+  const parser = new ExprParser(source, start, end, meta);
+  const node = parser.parseCond();
+  parser.skipWs();
+  if (parser.i < parser.end) {
+    throw parser.error(`Unexpected token in expression`);
+  }
+  return node;
+}
+
+/**
+ * İfadeyi JS kaynak metnine çevirir. `locals` içindeki isimler çıplak kalır;
+ * diğerleri `data.` öneki alır.
+ *
+ * @param {ExprNode} node
+ * @param {Set<string>} [locals]
+ * @returns {string}
+ */
+export function codegenExpr(node, locals = new Set()) {
+  switch (node.type) {
+    case "Literal":
+      return node.raw;
+    case "Ident":
+      if (locals.has(node.name)) return node.name;
+      return `data.${node.name}`;
+    case "Member": {
+      const obj = codegenExpr(node.object, locals);
+      const op = node.optional ? "?." : ".";
+      return `${obj}${op}${node.property}`;
+    }
+    case "Index": {
+      const obj = codegenExpr(node.object, locals);
+      const idx = codegenExpr(node.index, locals);
+      const op = node.optional ? "?.[" : "[";
+      return `${obj}${op}${idx}]`;
+    }
+    case "Unary":
+      return `(${node.op}${codegenExpr(node.argument, locals)})`;
+    case "Binary":
+      return `(${codegenExpr(node.left, locals)} ${node.op} ${codegenExpr(node.right, locals)})`;
+    case "Cond":
+      return `(${codegenExpr(node.test, locals)} ? ${codegenExpr(node.consequent, locals)} : ${codegenExpr(node.alternate, locals)})`;
+    default:
+      throw new Error(`Unknown expr node: ${/** @type {{ type: string }} */ (node).type}`);
+  }
+}
+
+/**
+ * İfadede geçen kök tanımlayıcılar (data alanları / local adayları).
+ * @param {ExprNode} node
+ * @param {Set<string>} [out]
+ * @returns {Set<string>}
+ */
+export function collectIdents(node, out = new Set()) {
+  switch (node.type) {
+    case "Literal":
+      break;
+    case "Ident":
+      out.add(node.name);
+      break;
+    case "Member":
+      collectIdents(node.object, out);
+      break;
+    case "Index":
+      collectIdents(node.object, out);
+      collectIdents(node.index, out);
+      break;
+    case "Unary":
+      collectIdents(node.argument, out);
+      break;
+    case "Binary":
+      collectIdents(node.left, out);
+      collectIdents(node.right, out);
+      break;
+    case "Cond":
+      collectIdents(node.test, out);
+      collectIdents(node.consequent, out);
+      collectIdents(node.alternate, out);
+      break;
+    default:
+      break;
+  }
+  return out;
+}
+
+class ExprParser {
+  /**
+   * @param {string} source
+   * @param {number} start
+   * @param {number} end
+   * @param {{ file?: string, templateSource?: string, templateIndex?: number }} meta
+   */
+  constructor(source, start, end, meta) {
+    this.source = source;
+    this.i = start;
+    this.end = end;
+    this.meta = meta;
+    this.base = start;
+  }
+
+  /**
+   * @param {string} message
+   * @returns {CompileError}
+   */
+  error(message) {
+    const offset = this.meta.templateIndex != null ? this.meta.templateIndex + (this.i - this.base) : this.i;
+    return new CompileError(message, {
+      file: this.meta.file,
+      source: this.meta.templateSource ?? this.source,
+      index: this.meta.templateSource ? offset : this.i,
+    });
+  }
+
+  skipWs() {
+    while (this.i < this.end && /\s/.test(this.source[this.i])) this.i += 1;
+  }
+
+  peek() {
+    return this.i < this.end ? this.source[this.i] : "";
+  }
+
+  /**
+   * @param {string} expected
+   */
+  eat(expected) {
+    this.skipWs();
+    if (!this.source.startsWith(expected, this.i)) {
+      throw this.error(`Expected '${expected}'`);
+    }
+    this.i += expected.length;
+  }
+
+  /**
+   * @param {string} expected
+   * @returns {boolean}
+   */
+  match(expected) {
+    this.skipWs();
+    if (!this.source.startsWith(expected, this.i)) return false;
+    this.i += expected.length;
+    return true;
+  }
+
+  /** @returns {ExprNode} */
+  parseCond() {
+    const test = this.parseOr();
+    this.skipWs();
+    if (!this.match("?")) return test;
+    const consequent = this.parseCond();
+    this.eat(":");
+    const alternate = this.parseCond();
+    return { type: "Cond", test, consequent, alternate };
+  }
+
+  /** @returns {ExprNode} */
+  parseOr() {
+    let left = this.parseAnd();
+    for (;;) {
+      this.skipWs();
+      if (!this.match("||")) break;
+      left = { type: "Binary", op: "||", left, right: this.parseAnd() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseAnd() {
+    let left = this.parseEquality();
+    for (;;) {
+      this.skipWs();
+      if (!this.match("&&")) break;
+      left = { type: "Binary", op: "&&", left, right: this.parseEquality() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseEquality() {
+    let left = this.parseCompare();
+    for (;;) {
+      this.skipWs();
+      let op = null;
+      if (this.match("===")) op = "===";
+      else if (this.match("!==")) op = "!==";
+      else if (this.match("==")) op = "==";
+      else if (this.match("!=")) op = "!=";
+      if (!op) break;
+      left = { type: "Binary", op, left, right: this.parseCompare() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseCompare() {
+    let left = this.parseAdd();
+    for (;;) {
+      this.skipWs();
+      let op = null;
+      if (this.match("<=")) op = "<=";
+      else if (this.match(">=")) op = ">=";
+      else if (this.match("<")) op = "<";
+      else if (this.match(">")) op = ">";
+      if (!op) break;
+      left = { type: "Binary", op, left, right: this.parseAdd() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseAdd() {
+    let left = this.parseMul();
+    for (;;) {
+      this.skipWs();
+      const ch = this.peek();
+      if (ch !== "+" && ch !== "-") break;
+      // `?.` / sayılar ile karışmasın diye yalnızca tek karakter op.
+      this.i += 1;
+      left = { type: "Binary", op: ch, left, right: this.parseMul() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseMul() {
+    let left = this.parseUnary();
+    for (;;) {
+      this.skipWs();
+      const ch = this.peek();
+      if (ch !== "*" && ch !== "/" && ch !== "%") break;
+      this.i += 1;
+      left = { type: "Binary", op: ch, left, right: this.parseUnary() };
+    }
+    return left;
+  }
+
+  /** @returns {ExprNode} */
+  parseUnary() {
+    this.skipWs();
+    if (this.match("!")) {
+      return { type: "Unary", op: "!", argument: this.parseUnary() };
+    }
+    if (this.peek() === "-" && !/[0-9.]/.test(this.source[this.i + 1] ?? "")) {
+      this.i += 1;
+      return { type: "Unary", op: "-", argument: this.parseUnary() };
+    }
+    return this.parsePostfix();
+  }
+
+  /** @returns {ExprNode} */
+  parsePostfix() {
+    let node = this.parsePrimary();
+    for (;;) {
+      this.skipWs();
+      if (this.match("?.")) {
+        this.skipWs();
+        if (this.peek() === "[") {
+          this.i += 1;
+          const index = this.parseCond();
+          this.eat("]");
+          node = { type: "Index", object: node, index, optional: true };
+          continue;
+        }
+        const property = this.readIdent();
+        node = { type: "Member", object: node, property, optional: true };
+        continue;
+      }
+      if (this.peek() === ".") {
+        this.i += 1;
+        const property = this.readIdent();
+        node = { type: "Member", object: node, property, optional: false };
+        continue;
+      }
+      if (this.peek() === "[") {
+        this.i += 1;
+        const index = this.parseCond();
+        this.eat("]");
+        node = { type: "Index", object: node, index, optional: false };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+
+  /** @returns {ExprNode} */
+  parsePrimary() {
+    this.skipWs();
+    const ch = this.peek();
+
+    if (ch === "(") {
+      this.i += 1;
+      const node = this.parseCond();
+      this.eat(")");
+      return node;
+    }
+
+    if (ch === '"' || ch === "'") {
+      return this.readString();
+    }
+
+    if (ch === "`") {
+      throw this.error("Template literals are not allowed in expressions");
+    }
+
+    if (/[0-9]/.test(ch) || (ch === "." && /[0-9]/.test(this.source[this.i + 1] ?? ""))) {
+      return this.readNumber();
+    }
+
+    if (IDENT_START.test(ch)) {
+      const name = this.readIdent();
+      if (name === "true") return { type: "Literal", value: true, raw: "true" };
+      if (name === "false") return { type: "Literal", value: false, raw: "false" };
+      if (name === "null") return { type: "Literal", value: null, raw: "null" };
+      return { type: "Ident", name };
+    }
+
+    throw this.error("Expected expression");
+  }
+
+  /** @returns {string} */
+  readIdent() {
+    this.skipWs();
+    if (!IDENT_START.test(this.peek())) {
+      throw this.error("Expected identifier");
+    }
+    const start = this.i;
+    this.i += 1;
+    while (this.i < this.end && IDENT_CONT.test(this.source[this.i])) this.i += 1;
+    return this.source.slice(start, this.i);
+  }
+
+  /** @returns {LiteralNode} */
+  readString() {
+    const quote = this.source[this.i];
+    this.i += 1;
+    let raw = quote;
+    let value = "";
+    while (this.i < this.end) {
+      const ch = this.source[this.i];
+      if (ch === "\\") {
+        raw += ch + (this.source[this.i + 1] ?? "");
+        value += this.source[this.i + 1] ?? "";
+        this.i += 2;
+        continue;
+      }
+      if (ch === quote) {
+        raw += quote;
+        this.i += 1;
+        return { type: "Literal", value, raw };
+      }
+      if (ch === "\n") {
+        throw this.error("Unterminated string");
+      }
+      raw += ch;
+      value += ch;
+      this.i += 1;
+    }
+    throw this.error("Unterminated string");
+  }
+
+  /** @returns {LiteralNode} */
+  readNumber() {
+    const start = this.i;
+    while (this.i < this.end && /[0-9_]/.test(this.source[this.i])) this.i += 1;
+    if (this.source[this.i] === ".") {
+      this.i += 1;
+      while (this.i < this.end && /[0-9_]/.test(this.source[this.i])) this.i += 1;
+    }
+    if (this.source[this.i] === "e" || this.source[this.i] === "E") {
+      this.i += 1;
+      if (this.source[this.i] === "+" || this.source[this.i] === "-") this.i += 1;
+      while (this.i < this.end && /[0-9]/.test(this.source[this.i])) this.i += 1;
+    }
+    const raw = this.source.slice(start, this.i).replace(/_/g, "");
+    return { type: "Literal", value: Number(raw), raw };
+  }
+}

package/src/compile/index.js

@@ -0,0 +1,17 @@
+/**
+ * Build-time `.jsk` derleyici yüzeyi.
+ */
+export { CompileError, indexToLocation } from "./errors.js";
+export { parseExpr, codegenExpr } from "./expr.js";
+export { parseTemplate, isComponentTag } from "./parse.js";
+export { codegen, toPascalCase, normalizeIncludeId } from "./codegen.js";
+export {
+  getViewRoots,
+  getComponentDirs,
+  discoverJskFiles,
+  componentNameFromViewId,
+  collectKnownComponents,
+  toComponentTag,
+} from "./resolve.js";
+export { scanNamedExports } from "./scan-exports.js";
+export { compileAll, compileSource, ensureTemplatesCompiled } from "./compile-all.js";