@chilts/weave 0.6.0 → 0.8.0

package/dist/codegen/sourcemap.d.ts

@@ -1,4 +1,4 @@
-import type { SourceLocation } from '../parser/types.js';
+import type { SourceLocation, ValueLoc } from '../parser/types.js';
 /** A single mapping segment: generated position → source position (all 0-based) */
 export interface Mapping {
     genLine: number;
@@ -29,6 +29,34 @@ export declare function encodeVLQ(value: number): string;
 export declare function encodeMappings(mappings: Mapping[]): string;
 /** Create a CodeChunk with an optional mapping at position (0,0) tied to a source location. */
 export declare function chunk(code: string, loc?: SourceLocation): CodeChunk;
+/** A zero-width chunk that maps the code following it to `loc`. */
+export declare function mark(loc: SourceLocation): CodeChunk;
+/**
+ * Concatenate code and chunks, placing each chunk's mappings where it lands:
+ * its first line shifts by the column it starts at, every line by the line.
+ */
+export declare function concat(...parts: (string | CodeChunk)[]): CodeChunk;
+/** Captured TS text and where its lines start in the source, when known. */
+export interface Captured {
+    text: string;
+    loc?: ValueLoc | undefined;
+}
+/**
+ * The part of a captured value from `start` to `end`, with its line starts
+ * moved to match. Trims surrounding whitespace, as the slice is re-emitted on
+ * its own.
+ */
+export declare function sliceCaptured(value: Captured, start: number, end?: number): Captured;
+/**
+ * A chunk for captured TS, which weave re-emits character for character. Every
+ * token (a run of word characters, or any other non-space character) gets a
+ * mapping to its own source position, so a diagnostic anywhere in the value
+ * lands on the token it names. Splitting on character classes is not a TS
+ * parse; it only needs to put a mapping wherever tsc might start a span.
+ * Without a location the text is emitted unmapped, covered by whatever
+ * mapping precedes it.
+ */
+export declare function verbatim(value: Captured): CodeChunk;
 /** Offset all mappings in an array by a line delta. */
 export declare function offsetMappings(mappings: Mapping[], lineOffset: number): Mapping[];
 /** Count newlines in a string. */
@@ -40,4 +68,24 @@ export declare function lineCount(code: string): number;
 export declare function joinChunks(chunks: CodeChunk[], separator: string): CodeChunk;
 /** Build a complete V3 source map object. */
 export declare function buildSourceMap(mappings: Mapping[], file: string, sourceFile: string): SourceMap;
+/**
+ * Decode a V3 `mappings` string into absolute mappings (the inverse of
+ * encodeMappings). The source index and names are ignored: weave emits a
+ * single source and no names. Segments with no source position are skipped.
+ */
+export declare function decodeMappings(mappings: string): Mapping[];
+/** A position in the original source (1-based line and col). */
+export interface OriginalPosition {
+    source: string;
+    line: number;
+    col: number;
+}
+/**
+ * Find the source position for a generated position (1-based line and col).
+ * Uses the last mapping at or before it on the same line, else the last
+ * mapping on the nearest earlier line. Weave maps every token of a captured TS
+ * expression to its own source position, and generated wrapper code to the
+ * start of the node that produced it.
+ */
+export declare function originalPosition(map: SourceMap, line: number, col: number): OriginalPosition | undefined;
 //# sourceMappingURL=sourcemap.d.ts.map

package/dist/codegen/sourcemap.js

@@ -24,14 +24,13 @@ export function encodeMappings(mappings) {
         return '';
     // Find max generated line
     const maxLine = sorted[sorted.length - 1].genLine;
-    let prevGenCol = 0;
     let prevSrcLine = 0;
     let prevSrcCol = 0;
     let idx = 0;
     const lines = [];
     for (let line = 0; line <= maxLine; line++) {
         const segments = [];
-        prevGenCol = 0; // genCol resets per line
+        let prevGenCol = 0; // genCol resets per line
         while (idx < sorted.length && sorted[idx].genLine === line) {
             const m = sorted[idx];
             let seg = encodeVLQ(m.genCol - prevGenCol);
@@ -62,6 +61,88 @@ export function chunk(code, loc) {
     }
     return { code, mappings };
 }
+/** A zero-width chunk that maps the code following it to `loc`. */
+export function mark(loc) {
+    return chunk('', loc);
+}
+/**
+ * Concatenate code and chunks, placing each chunk's mappings where it lands:
+ * its first line shifts by the column it starts at, every line by the line.
+ */
+export function concat(...parts) {
+    let code = '';
+    const mappings = [];
+    let line = 0;
+    let col = 0;
+    for (const part of parts) {
+        const c = typeof part === 'string' ? { code: part, mappings: [] } : part;
+        for (const m of c.mappings) {
+            mappings.push({
+                ...m,
+                genLine: m.genLine + line,
+                genCol: m.genLine === 0 ? m.genCol + col : m.genCol,
+            });
+        }
+        code += c.code;
+        const lastNewline = c.code.lastIndexOf('\n');
+        if (lastNewline === -1) {
+            col += c.code.length;
+        }
+        else {
+            line += lineCount(c.code);
+            col = c.code.length - lastNewline - 1;
+        }
+    }
+    return { code, mappings };
+}
+/**
+ * The part of a captured value from `start` to `end`, with its line starts
+ * moved to match. Trims surrounding whitespace, as the slice is re-emitted on
+ * its own.
+ */
+export function sliceCaptured(value, start, end = value.text.length) {
+    const raw = value.text.slice(start, end);
+    const from = start + (raw.length - raw.trimStart().length);
+    const text = raw.trim();
+    if (!value.loc)
+        return { text };
+    const before = value.text.slice(0, from);
+    const line = lineCount(before);
+    const first = value.loc[line];
+    if (!first)
+        return { text };
+    const col = first.col + from - (before.lastIndexOf('\n') + 1);
+    return { text, loc: [{ line: first.line, col }, ...value.loc.slice(line + 1, line + 1 + lineCount(text))] };
+}
+/**
+ * A chunk for captured TS, which weave re-emits character for character. Every
+ * token (a run of word characters, or any other non-space character) gets a
+ * mapping to its own source position, so a diagnostic anywhere in the value
+ * lands on the token it names. Splitting on character classes is not a TS
+ * parse; it only needs to put a mapping wherever tsc might start a span.
+ * Without a location the text is emitted unmapped, covered by whatever
+ * mapping precedes it.
+ */
+export function verbatim(value) {
+    const { text, loc } = value;
+    const mappings = [];
+    if (loc) {
+        text.split('\n').forEach((lineText, genLine) => {
+            const start = loc[genLine];
+            if (!start)
+                return;
+            for (const m of lineText.matchAll(/[\w$]+|\S/g)) {
+                mappings.push({
+                    genLine,
+                    genCol: m.index,
+                    srcLine: start.line - 1,
+                    srcCol: start.col - 1 + m.index,
+                });
+            }
+        });
+    }
+    return { code: text, mappings };
+}
 /** Offset all mappings in an array by a line delta. */
 export function offsetMappings(mappings, lineOffset) {
     if (lineOffset === 0)
@@ -110,4 +191,75 @@ export function buildSourceMap(mappings, file, sourceFile) {
         mappings: encodeMappings(mappings),
     };
 }
+// --- Decoding ---
+const BASE64_VALUES = new Map([...BASE64].map((c, i) => [c, i]));
+/** Decode one segment's VLQ fields. */
+function decodeSegment(segment) {
+    const values = [];
+    let shift = 0;
+    let vlq = 0;
+    for (const c of segment) {
+        const digit = BASE64_VALUES.get(c);
+        if (digit === undefined)
+            throw new Error(`Invalid base64 character in source map: ${c}`);
+        vlq += (digit & 0b11111) << shift;
+        if (digit & 0b100000) {
+            shift += 5;
+        }
+        else {
+            values.push(vlq & 1 ? -(vlq >>> 1) : vlq >>> 1);
+            shift = 0;
+            vlq = 0;
+        }
+    }
+    return values;
+}
+/**
+ * Decode a V3 `mappings` string into absolute mappings (the inverse of
+ * encodeMappings). The source index and names are ignored: weave emits a
+ * single source and no names. Segments with no source position are skipped.
+ */
+export function decodeMappings(mappings) {
+    const result = [];
+    let srcLine = 0;
+    let srcCol = 0;
+    mappings.split(';').forEach((line, genLine) => {
+        let genCol = 0; // genCol resets per line
+        for (const segment of line.split(',')) {
+            if (segment === '')
+                continue;
+            const fields = decodeSegment(segment);
+            genCol += fields[0];
+            if (fields.length < 4)
+                continue;
+            srcLine += fields[2];
+            srcCol += fields[3];
+            result.push({ genLine, genCol, srcLine, srcCol });
+        }
+    });
+    return result;
+}
+/**
+ * Find the source position for a generated position (1-based line and col).
+ * Uses the last mapping at or before it on the same line, else the last
+ * mapping on the nearest earlier line. Weave maps every token of a captured TS
+ * expression to its own source position, and generated wrapper code to the
+ * start of the node that produced it.
+ */
+export function originalPosition(map, line, col) {
+    const source = map.sources[0];
+    if (source === undefined)
+        return undefined;
+    const genLine = line - 1;
+    const genCol = col - 1;
+    let best;
+    for (const m of decodeMappings(map.mappings)) {
+        if (m.genLine > genLine || (m.genLine === genLine && m.genCol > genCol))
+            break;
+        best = m;
+    }
+    if (!best)
+        return undefined;
+    return { source, line: best.srcLine + 1, col: best.srcCol + 1 };
+}
 //# sourceMappingURL=sourcemap.js.map

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,25 @@
+/** A diagnostic at a 1-based line and col, from tsc or anything else. */
+export interface Diagnostic {
+    file: string;
+    line: number;
+    col: number;
+    message: string;
+}
+/** Returns a file's contents, or undefined if it cannot be read. */
+export type ReadFile = (file: string) => string | undefined;
+/**
+ * Translate a diagnostic in a compiled .ts file to its .weave source, using
+ * the source map weave wrote beside it. The returned file is the .weave path,
+ * resolved the same way as the diagnostic's file (relative stays relative).
+ * Returns undefined when the file has no usable map — it is not a weave
+ * output, or was compiled with --no-sourcemap — so the caller can report the
+ * diagnostic as-is.
+ */
+export declare function mapDiagnostic(diag: Diagnostic, readFile?: ReadFile): Diagnostic | undefined;
+export declare function formatCodeFrame(source: string, line: number, col: number): string;
+/**
+ * Format a diagnostic like a LexerError or ParserError: `weave: file:L:C: msg`,
+ * followed by a code frame when the source is given.
+ */
+export declare function formatDiagnostic(diag: Diagnostic, source?: string): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/diagnostics/index.js

@@ -0,0 +1,68 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { originalPosition } from '../codegen/sourcemap.js';
+function readFromDisk(file) {
+    try {
+        return readFileSync(file, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The map file a compiled .ts points at, falling back to `<file>.map`. */
+function mapFileFor(file, code) {
+    const url = code?.match(/^\/\/# sourceMappingURL=(.+)$/m)?.[1]?.trim();
+    return url ? path.join(path.dirname(file), url) : file + '.map';
+}
+function parseSourceMap(json) {
+    try {
+        const map = JSON.parse(json);
+        return map.version === 3 && Array.isArray(map.sources) && typeof map.mappings === 'string'
+            ? map
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Translate a diagnostic in a compiled .ts file to its .weave source, using
+ * the source map weave wrote beside it. The returned file is the .weave path,
+ * resolved the same way as the diagnostic's file (relative stays relative).
+ * Returns undefined when the file has no usable map — it is not a weave
+ * output, or was compiled with --no-sourcemap — so the caller can report the
+ * diagnostic as-is.
+ */
+export function mapDiagnostic(diag, readFile = readFromDisk) {
+    const json = readFile(mapFileFor(diag.file, readFile(diag.file)));
+    if (json === undefined)
+        return undefined;
+    const map = parseSourceMap(json);
+    if (!map)
+        return undefined;
+    const pos = originalPosition(map, diag.line, diag.col);
+    if (!pos)
+        return undefined;
+    const file = path.join(path.dirname(diag.file), map.sourceRoot ?? '', pos.source);
+    return { file, line: pos.line, col: pos.col, message: diag.message };
+}
+export function formatCodeFrame(source, line, col) {
+    const lines = source.split('\n');
+    if (line < 1 || line > lines.length)
+        return '';
+    const sourceLine = lines[line - 1];
+    const lineNum = String(line);
+    const gutter = ' '.repeat(lineNum.length);
+    return `\n ${lineNum} | ${sourceLine}\n ${gutter} | ${' '.repeat(col - 1)}^`;
+}
+/**
+ * Format a diagnostic like a LexerError or ParserError: `weave: file:L:C: msg`,
+ * followed by a code frame when the source is given.
+ */
+export function formatDiagnostic(diag, source) {
+    let result = `weave: ${diag.file}:${diag.line}:${diag.col}: ${diag.message}`;
+    if (source)
+        result += formatCodeFrame(source, diag.line, diag.col);
+    return result;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-export { h, doctype, Fragment, raw, escape, SafeHtml } from './runtime/index.js';
-export type { Attrs } from './runtime/index.js';
-export { compile, compileWithSourceMap, generate, generateExpr, CodegenError } from './codegen/index.js';
-export type { GenerateResult, CodeChunk, Mapping, SourceMap } from './codegen/index.js';
+export { h, doctype, Fragment, raw, mergeClass, each, interpolate, escape, SafeHtml } from './runtime/index.js';
+export type { Attrs, AttrValue, ClassValue, StyleValue } from './runtime/index.js';
+export { compile, compileWithSourceMap, generate, generateExpr, definedMixins, CodegenError } from './codegen/index.js';
+export type { GenerateResult, GenerateOptions, IncludeResolver, CodeChunk, Mapping, SourceMap } from './codegen/index.js';
+export { decodeMappings, originalPosition } from './codegen/sourcemap.js';
+export type { OriginalPosition } from './codegen/sourcemap.js';
+export { mapDiagnostic, formatDiagnostic, formatCodeFrame } from './diagnostics/index.js';
+export type { Diagnostic, ReadFile } from './diagnostics/index.js';
 export { lex, LexerError } from './lexer/index.js';
 export type { Token, TokenType } from './lexer/index.js';
 export { parse, ParserError } from './parser/index.js';

package/dist/index.js

@@ -1,7 +1,9 @@
 // Runtime
-export { h, doctype, Fragment, raw, escape, SafeHtml } from './runtime/index.js';
+export { h, doctype, Fragment, raw, mergeClass, each, interpolate, escape, SafeHtml } from './runtime/index.js';
 // Compiler
-export { compile, compileWithSourceMap, generate, generateExpr, CodegenError } from './codegen/index.js';
+export { compile, compileWithSourceMap, generate, generateExpr, definedMixins, CodegenError } from './codegen/index.js';
+export { decodeMappings, originalPosition } from './codegen/sourcemap.js';
+export { mapDiagnostic, formatDiagnostic, formatCodeFrame } from './diagnostics/index.js';
 export { lex, LexerError } from './lexer/index.js';
 export { parse, ParserError } from './parser/index.js';
 //# sourceMappingURL=index.js.map

package/dist/lexer/index.d.ts

@@ -1,9 +1,13 @@
-export type TokenType = 'NEWLINE' | 'INDENT' | 'DEDENT' | 'EOF' | 'IMPORT' | 'TEMPLATE' | 'MIXIN' | 'EXTENDS' | 'BLOCK' | 'INCLUDE' | 'DOCTYPE' | 'IF' | 'ELSE_IF' | 'ELSE' | 'FOR' | 'TAG' | 'CLASS' | 'ID' | 'ATTR_START' | 'ATTR_END' | 'ATTR_NAME' | 'ATTR_VALUE' | 'SPREAD' | 'BUFFERED_CODE' | 'TEXT' | 'INTERPOLATION' | 'PIPE' | 'RAW_TEXT' | 'MIXIN_CALL' | 'COMMENT' | 'PASSTHROUGH_COMMENT' | 'PARAMS' | 'IDENTIFIER' | 'PATH';
+export type TokenType = 'NEWLINE' | 'INDENT' | 'DEDENT' | 'EOF' | 'IMPORT' | 'TEMPLATE' | 'MIXIN' | 'EXTENDS' | 'BLOCK' | 'INCLUDE' | 'DOCTYPE' | 'IF' | 'UNLESS' | 'ELSE_IF' | 'ELSE' | 'FOR' | 'TAG' | 'CLASS' | 'ID' | 'ATTR_START' | 'ATTR_END' | 'ATTR_NAME' | 'ATTR_VALUE' | 'SPREAD' | 'BUFFERED_CODE' | 'TEXT' | 'INTERPOLATION' | 'PIPE' | 'RAW_TEXT' | 'MIXIN_CALL' | 'COMMENT' | 'PASSTHROUGH_COMMENT' | 'PARAMS' | 'IDENTIFIER' | 'PATH';
 export interface Token {
     type: TokenType;
     value: string;
     line: number;
     col: number;
+    starts?: {
+        line: number;
+        col: number;
+    }[];
 }
 export declare class LexerError extends Error {
     readonly line: number;