lilact 0.26.16 → 0.27.0

package/src/errors.jsx

@@ -29,7 +29,7 @@
 */
 /*
 Lilact
-Copyright (C) 2024-2026 Arash Kazemi
+Copyright (C) 2024-2026 Arash Kazemi <contact.arash.kazemi@gmail.com>
 BSD-2-Clause
 */
 
@@ -37,398 +37,224 @@ import Lilact from "./lilact.jsx";
 import { required_scripts } from "./run.jsx";
 import { css } from "@emotion/css";
 
-function numberOrNull(value) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : null;
-}
-
-function firstNumber(...values) {
-  for (const value of values) {
-    const n = numberOrNull(value);
-    if (n !== null) return n;
-  }
-  return null;
+function number(value) {
+  const result = Number(value);
+  return Number.isFinite(result) ? result : null;
 }
 
 function asError(value) {
   if (value instanceof Error) return value;
+  if (value?.error instanceof Error) return value.error;
 
-  if (value && typeof value === "object") {
-    if (value.error instanceof Error) return value.error;
-
-    const error = new Error(
-      value.message == null ? String(value) : String(value.message)
-    );
+  const error = new Error(
+    value?.message == null
+      ? String(value)
+      : String(value.message)
+  );
 
+  if (value && typeof value === "object") {
     if (value.name) error.name = value.name;
     if (value.stack) error.stack = value.stack;
 
     for (const key of Object.keys(value)) {
       if (!(key in error)) error[key] = value[key];
     }
-
-    return error;
   }
 
-  return new Error(String(value));
+  return error;
 }
 
 function isParserError(error) {
-  return  error?.name === "JSXParserError";
-}
-
-/*
-Returns zero-based line and column numbers.
-
-Parser errors produced by jsx.js already use zero-based positions.
-Browser Error objects and ErrorEvents normally use one-based positions.
-*/
-function getErrorLocation(error, { zeroBased = false } = {}) {
-  const line = firstNumber(
-    error?.lineNumber,
-    error?.lineno,
-    error?.line
-  );
-
-  const column = firstNumber(
-    error?.columnNumber,
-    error?.colno,
-    error?.column
-  );
-
-  if (line !== null || column !== null) {
-    return {
-      line:
-        line === null
-          ? null
-          : zeroBased
-            ? line
-            : Math.max(0, line - 1),
-
-      col:
-        column === null
-          ? null
-          : zeroBased
-            ? column
-            : Math.max(0, column - 1),
-    };
-  }
-
-  return null;
+  return error?.name === "JSXParserError";
 }
 
-function sourceUrlFromStack(stack) {
-  const text = typeof stack === "string" ? stack : "";
+function stackLocation(stack) {
+  if (typeof stack !== "string") return null;
 
-  /*
-   * The final two colon-separated numeric values are the line and column.
-   * The path is intentionally greedy so paths containing ':' still work.
-   *
-   * Examples:
-   *
-   *   at fn (eval:/components/App.jsx:12:8)
-   *   fn@eval:/components/App.jsx:12:8
-   *   eval:/components/App.jsx:12:8
-   */
-  const expression = /(?:^|[\s(@])((?:eval:\/)[\s\S]*):(\d+):(\d+)(?:\)?$)/;
+  for (const line of stack.split(/\r?\n/)) {
+    const match = line.match(/(eval:\/.*):(\d+):(\d+)/);
 
-  for (const line of text.split(/\r?\n/)) {
-    const match = line.trim().match(expression);
     if (!match) continue;
 
     return {
-      url: match[1],
-      line: Number(match[2]),
-      col: Number(match[3]),
+      path: match[1].replace(/^eval:\/+/, ""),
+      line: Number(match[2]) - 1,
+      column: Number(match[3]) - 1,
     };
   }
 
   return null;
 }
 
-function sourcePathFromEvalUrl(url) {
-  if (typeof url !== "string") return null;
-
-  if (url.startsWith("eval:/")) {
-    return url.slice("eval:/".length);
-  }
+function browserLocation(error) {
+  const line = number(
+    error?.lineNumber ??
+    error?.lineno ??
+    error?.line
+  );
 
-  if (url.startsWith("eval:")) {
-    return url.slice("eval:".length).replace(/^\/+/, "");
-  }
+  const column = number(
+    error?.columnNumber ??
+    error?.colno ??
+    error?.column
+  );
 
-  return null;
+  return {
+    line: line == null ? null : Math.max(0, line - 1),
+    column: column == null ? null : Math.max(0, column - 1),
+  };
 }
 
-/*
-Mappings generated by jsx.js have this shape:
-
-[
-  generatedLine,
-  generatedColumn,
-  sourceLine,
-  sourceColumn,
-  node
-]
-
-All four coordinates are zero-based.
-
-The correct mapping is the closest mapping at or before the generated
-location. The old implementation searched in the opposite direction and
-used the final mapping for errors occurring before the first mapping.
-*/
-export function mapLocation(mappings, generatedLine, generatedColumn) {
-  if (!Array.isArray(mappings) || mappings.length === 0) {
-    return {
-      line: generatedLine,
-      col: generatedColumn,
-    };
-  }
+function traceBlock(error) {
+  const trace = error?.lilact_trace;
+  return Array.isArray(trace) ? trace[0] : trace;
+}
 
-  const line = Number(generatedLine);
-  const col = Number(generatedColumn);
+function blockInfo(error) {
+  const trace = traceBlock(error);
+  return trace == null
+    ? null
+    : Lilact.blocks_info?.labels?.[trace];
+}
 
-  if (!Number.isFinite(line) || !Number.isFinite(col)) {
-    return {
-      line: null,
-      col: null,
-    };
+function mapLocation(mappings, line, column) {
+  if (
+    !Array.isArray(mappings) ||
+    !mappings.length ||
+    !Number.isFinite(line) ||
+    !Number.isFinite(column)
+  ) {
+    return { line, column };
   }
 
-  const validMappings = mappings
-    .filter(
-      (mapping) =>
-        Array.isArray(mapping) &&
-        mapping.length >= 4 &&
-        Number.isFinite(Number(mapping[0])) &&
-        Number.isFinite(Number(mapping[1])) &&
-        Number.isFinite(Number(mapping[2])) &&
-        Number.isFinite(Number(mapping[3]))
+  const valid = mappings
+    .filter(mapping =>
+      Array.isArray(mapping) &&
+      mapping.length >= 4 &&
+      mapping
+        .slice(0, 4)
+        .every(value => Number.isFinite(Number(value)))
     )
-    .slice()
-    .sort((a, b) => {
-      const lineDifference = Number(a[0]) - Number(b[0]);
-
-      if (lineDifference !== 0) {
-        return lineDifference;
-      }
-
-      return Number(a[1]) - Number(b[1]);
-    });
+    .sort((a, b) =>
+      Number(a[0]) - Number(b[0]) ||
+      Number(a[1]) - Number(b[1])
+    );
 
-  if (validMappings.length === 0) {
-    return {
-      line,
-      col,
-    };
-  }
+  if (!valid.length) return { line, column };
 
-  /*
-   * Find the last mapping whose generated position is before or equal
-   * to the runtime position.
-   */
-  let mapping = validMappings[0];
+  let selected = valid[0];
 
-  for (const candidate of validMappings) {
-    const generatedMappingLine = Number(candidate[0]);
-    const generatedMappingColumn = Number(candidate[1]);
+  for (const mapping of valid) {
+    const generatedLine = Number(mapping[0]);
+    const generatedColumn = Number(mapping[1]);
 
     if (
-      generatedMappingLine < line ||
+      generatedLine < line ||
       (
-        generatedMappingLine === line &&
-        generatedMappingColumn <= col
+        generatedLine === line &&
+        generatedColumn <= column
       )
     ) {
-      mapping = candidate;
-      continue;
+      selected = mapping;
+    } else {
+      break;
     }
-
-    break;
   }
 
-  const mappingGeneratedLine = Number(mapping[0]);
-  const mappingGeneratedColumn = Number(mapping[1]);
-  const mappingSourceLine = Number(mapping[2]);
-  const mappingSourceColumn = Number(mapping[3]);
-
-  /*
-   * A mapping points to the beginning of a generated region. Preserve
-   * the relative line offset inside that region.
-   *
-   * This is the important part. Returning mappingSourceLine directly
-   * causes errors inside a generated multi-line block to point to the
-   * first line of the block.
-   */
-  const sourceLine =
-    mappingSourceLine + (line - mappingGeneratedLine);
-
-  /*
-   * Columns are only safely relative when the generated error is on the
-   * same generated line as the mapping. On later lines, use the source
-   * anchor column instead of carrying the generated column across lines.
-   */
-  const sourceColumn =
-    line === mappingGeneratedLine
-      ? Math.max(
-          0,
-          mappingSourceColumn +
-            (col - mappingGeneratedColumn)
-        )
-      : mappingSourceColumn;
+  const generatedLine = Number(selected[0]);
+  const generatedColumn = Number(selected[1]);
+  const sourceLine = Number(selected[2]);
+  const sourceColumn = Number(selected[3]);
 
   return {
-    line: sourceLine,
-    col: sourceColumn,
+    line:
+      sourceLine +
+      (line === generatedLine ? 0 : line - generatedLine),
+    column:
+      line === generatedLine
+        ? Math.max(0, sourceColumn + column - generatedColumn)
+        : sourceColumn,
   };
 }
 
-function getBlockTrace(error) {
-  const trace = error?.lilact_trace;
-
-  if (Array.isArray(trace)) {
-    return trace[0];
-  }
-
-  return trace;
-}
-
-function getBlockInfo(error) {
-  const trace = getBlockTrace(error);
-
-  if (trace === undefined || trace === null) {
-    return null;
-  }
-
-  return Lilact.blocks_info?.labels?.[trace] ?? null;
-}
-
-function applyBlockFallback(error, result, currentPath) {
-  const block = getBlockInfo(error);
-  if (!block) return result;
-
-  if (block.path) {
-    result.fileName = block.path;
-  } else if (!result.fileName) {
-    result.fileName = currentPath;
-  }
-
-  /*
-   * scanBlockLabels() stores the original source position of the block.
-   * This is more reliable than using the location of the generated catch
-   * wrapper.
-   */
-  if (
-    Number.isFinite(block.line) &&
-    Number.isFinite(block.col)
-  ) {
-    result.lineNumber = block.line;
-    result.columnNumber = block.col;
-  }
-
-  if (block.desc) {
-    result.label = block.desc;
-  }
-
-  return result;
-}
-
-function copyErrorMetadata(source, target) {
-  if (!source || typeof source !== "object") return;
-
-  for (const key of [
-    "fileName",
-    "lineNumber",
-    "columnNumber",
-    "lineno",
-    "colno",
-    "line",
-    "column",
-    "componentStackLog",
-    "lilact_trace",
-  ]) {
-    if (source[key] !== undefined && target[key] === undefined) {
-      target[key] = source[key];
-    }
-  }
-}
-
-/**
- * Converts parser errors, runtime errors, ErrorEvents, and rejected
- * promises into one consistent zero-based representation.
- */
 export function traceError(value, runPath) {
   if (value?.isTraced) return value;
 
-  const original =
-    value?.error instanceof Error ? value.error : asError(value);
+  const error = asError(value);
+  const source = error.lilact_source;
+  const stack = isParserError(error)
+    ? null
+    : stackLocation(error.stack);
+  const browser = isParserError(error)
+    ? {
+        line: number(error.lineNumber),
+        column: number(error.columnNumber),
+      }
+    : browserLocation(error);
 
-  const parserError = isParserError(original);
+  /*
+   * lilact_source is authoritative. In particular, it prevents a syntax
+   * error from a nested eval from inheriting the caller's eval filename.
+   */
+  const fileName =
+    source?.path ||
+    stack?.path ||
+    error.fileName ||
+    runPath ||
+    null;
 
-  const stackLocation = parserError
-    ? null
-    : sourceUrlFromStack(original.stack);
+  let line =
+    stack?.line ??
+    browser.line ??
+    null;
 
-  const eventLocation = parserError
-    ? getErrorLocation(original, { zeroBased: true })
-    : getErrorLocation(original);
+  let column =
+    stack?.column ??
+    browser.column ??
+    null;
 
   const result = {
-    fileName:
-      sourcePathFromEvalUrl(stackLocation?.url) ||
-      original.fileName ||
-      runPath ||
-      null,
-
-    lineNumber:
-      stackLocation?.line != null
-        ? Math.max(0, stackLocation.line - 1)
-        : eventLocation?.line ?? null,
-
-    columnNumber:
-      stackLocation?.col != null
-        ? Math.max(0, stackLocation.col - 1)
-        : eventLocation?.col ?? null,
-
+    fileName,
+    lineNumber: line,
+    columnNumber: column,
     message:
-      original.message == null
-        ? String(original)
-        : String(original.message),
-
-    name: original.name || "Error",
-    stack: original.stack || null,
-    _error: original,
+      error.message == null
+        ? String(error)
+        : String(error.message),
+    name: error.name || "Error",
+    stack: error.stack || null,
+    lilact_source: source || null,
+    _error: error,
     isTraced: true,
   };
 
-  copyErrorMetadata(value, result);
-  copyErrorMetadata(original, result);
+  const module = fileName && required_scripts[fileName];
 
-  /*
-   * Parser errors already point into the original JSX source. Do not map
-   * them again.
-   */
-  if (!parserError && stackLocation?.url) {
-    const module = required_scripts[result.fileName];
-
-    if (module?.mappings) {
-      const mapped = mapLocation(
-        module.mappings,
-        result.lineNumber,
-        result.columnNumber
-      );
-
-      result.lineNumber = mapped.line;
-      result.columnNumber = mapped.col;
-    }
+  if (module) {
+    const mapped = mapLocation(
+      module.mappings,
+      result.lineNumber,
+      result.columnNumber
+    );
+
+    result.lineNumber = mapped.line;
+    result.columnNumber = mapped.column;
   }
 
-  /*
-   * When the browser does not preserve the eval sourceURL, the injected
-   * Lilact block label is the reliable fallback.
-   */
-  if (!parserError && !stackLocation?.url) {
-    applyBlockFallback(original, result, runPath);
+  const block = blockInfo(error);
+
+  if (
+    block &&
+    (
+      result.lineNumber == null ||
+      result.columnNumber == null ||
+      !result.fileName
+    )
+  ) {
+    result.fileName ||= block.path || runPath || null;
+    result.lineNumber ??= block.line;
+    result.columnNumber ??= block.col;
+    result.label = block.desc;
   }
 
   Lilact.error = result;
@@ -444,37 +270,35 @@ function escapeHtml(value) {
     .replaceAll("'", "&#39;");
 }
 
-function sourceExcerpt(module, zeroBasedLine) {
-  if (!module || !Number.isFinite(zeroBasedLine)) {
-    return null;
-  }
+function sourceExcerpt(module, line) {
+  if (!module || !Number.isFinite(line)) return null;
 
   const lines = String(module.code ?? "").split(/\r?\n/);
-  const before = lines[zeroBasedLine - 1] ?? "";
-  const current = lines[zeroBasedLine] ?? "";
-  const after = lines[zeroBasedLine + 1] ?? "";
 
-  return { before, current, after };
+  return {
+    before: lines[line - 1] ?? "",
+    current: lines[line] ?? "",
+    after: lines[line + 1] ?? "",
+  };
 }
 
-/**
- * Displays an unhandled error.
- */
 export function globalErrorHandler(eventOrError) {
-  const raw =
+  const value =
     eventOrError?.error instanceof Error
       ? eventOrError.error
       : eventOrError?.reason !== undefined
         ? eventOrError.reason
         : eventOrError;
 
-  const runPath =
-    eventOrError?.fileName ||
-    null;
+  const error = traceError(
+    value,
+    eventOrError?.fileName || null
+  );
 
-  const traced = traceError(raw, runPath);
-  const module = required_scripts[traced.fileName];
-  const excerpt = sourceExcerpt(module, traced.lineNumber);
+  const excerpt = sourceExcerpt(
+    required_scripts[error.fileName],
+    error.lineNumber
+  );
 
   const className = css(`
     background: linear-gradient(135deg, #fff2f2d4, #ffffffd4);
@@ -501,26 +325,24 @@ export function globalErrorHandler(eventOrError) {
   const dialog = document.createElement("dialog");
   dialog.className = className;
 
-  const location =
-    traced.fileName
-      ? `At ${escapeHtml(traced.fileName)}`
-      : "";
+  const location = error.fileName
+    ? `At ${escapeHtml(error.fileName)}`
+    : "";
 
-  const line =
-    Number.isFinite(traced.lineNumber)
-      ? `: Line ${traced.lineNumber + 1}`
-      : "";
+  const line = Number.isFinite(error.lineNumber)
+    ? `: Line ${error.lineNumber + 1}`
+    : "";
 
   const componentStack =
-    traced._error?.componentStackLog ||
-    traced._error?.componentStack ||
+    error._error?.componentStackLog ||
+    error._error?.componentStack ||
     "";
 
   dialog.innerHTML = `
     <h3><red>Error!</red></h3>
     <b>${location}${line}</b><br><br>
-    <b>${escapeHtml(traced.name)}</b>:
-    <span>${escapeHtml(traced.message)}</span>
+    <b>${escapeHtml(error.name)}</b>:
+    <span>${escapeHtml(error.message)}</span>
     <br><br>
 
     ${
@@ -556,21 +378,14 @@ export function globalErrorHandler(eventOrError) {
     dialog.setAttribute("open", "");
   }
 
-  return traced;
+  return error;
 }
 
-/**
- * Registers the source location of an injected Lilact block.
- */
 export function scanBlockLabels(code, path) {
-  const labels = String(code).matchAll(
+  for (const match of String(code).matchAll(
     /LILACTBLOCK(\d+):(\d+),(\d+):([^*]+)\*\//gm
-  );
-
-  for (const match of labels) {
-    const id = match[1];
-
-    Lilact.blocks_info.labels[id] = {
+  )) {
+    Lilact.blocks_info.labels[match[1]] = {
       path,
       line: Number(match[2]),
       col: Number(match[3]),

package/src/expscan.js

@@ -91,7 +91,7 @@ export function labeler(custom_words, x)
 		if(x.type==='comment') return 'C';
 		if(x.type==='regexp') return 'R';
 		if(x.type==='js') return 'J';
-		if(x.type==='paranthesis') return 'P';
+		if(x.type==='parenthesis') return 'P';
 		if(x.type==='string') return 'S';
 		if(x.type==='xml') return 'X';
 	}