@chilts/weave 0.6.0 → 0.7.0

package/dist/codegen/index.js

@@ -14,6 +14,29 @@ export class CodegenError extends Error {
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);
 }
+// Appends a compiler-supplied argument (`attrs`, `blocks`, ...) to a
+// captured argument or parameter list. A multi-line list may already end in
+// a trailing comma, and when its ')' sat on a line of its own the extra goes
+// on its own line too, so the output keeps the shape the source was written in.
+// `ownLine` is false for an extra that opens a multi-line literal of its own.
+function appendArg(args, extra, ownLine = true) {
+    if (args === '')
+        return extra;
+    const body = args.trimEnd();
+    const tail = args.slice(body.length);
+    if (ownLine && tail.includes('\n')) {
+        const lastLine = body.slice(body.lastIndexOf('\n') + 1);
+        const indent = /^ */.exec(lastLine)[0];
+        return `${body}${body.endsWith(',') ? '' : ','}\n${indent}${extra},${tail}`;
+    }
+    return `${body}${body.endsWith(',') ? ' ' : ', '}${extra}`;
+}
+// Indents the continuation lines of a multi-line captured expression to sit
+// under the output line it starts on. Captured text never holds a string that
+// spans lines, so every newline is safe to indent after.
+function reindent(text, prefix) {
+    return prefix === '' ? text : text.replace(/\n(?!\n|$)/g, `\n${prefix}`);
+}
 function camelToKebab(name) {
     return name.replace(/[A-Z]/g, m => '-' + m.toLowerCase());
 }
@@ -110,9 +133,10 @@ class CodeGenerator {
             case 'MixinDefinition':
                 return this.genMixinDefinition(node, indent);
             case 'MixinCall':
-                return this.genMixinCall(node);
+                return this.genMixinCall(node, indent);
             case 'Include':
-                return this.genInclude(node);
+                // Hoisted: generate() emits the import once it knows the names.
+                return null;
             case 'Block':
                 return this.genBlock(node, indent);
             case 'Extends':
@@ -157,20 +181,22 @@ class CodeGenerator {
             : variable;
         const bi = this.formatted ? this.ind(indent + 1) : '    ';
         const pi = this.formatted ? this.ind(indent) : '';
-        const code = `${iterable}.map(${param} =>\n${bi}${bodyChunk.code}\n${pi})`;
+        const head = reindent(`${iterable}.map(${param} =>`, this.formatted ? this.ind(indent) : '');
+        const code = `${head}\n${bi}${bodyChunk.code}\n${pi})`;
         const mappings = [
             mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1),
+            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(head)),
         ];
         return { code, mappings };
     }
     parseForParams(params, loc) {
-        const ofIndex = params.indexOf(' of ');
-        if (ofIndex === -1) {
+        // A multi-line header may put `of` at the start or end of a line.
+        const of = /\s+of\s+/.exec(params);
+        if (of === null) {
             throw new CodegenError(`Invalid for params: only "for...of" is supported, got "${params}"`, loc.line, loc.col);
         }
-        const binding = params.slice(0, ofIndex).trim();
-        const iterable = params.slice(ofIndex + 4).trim();
+        const binding = params.slice(0, of.index).trim();
+        const iterable = params.slice(of.index + of[0].length).trim();
         const variable = binding.replace(/^(const|let)\s+/, '');
         return { variable, iterable };
     }
@@ -272,13 +298,16 @@ class CodeGenerator {
         return `{ ${parts.join(', ')} }`;
     }
     mergeClassValue(prefix, value) {
-        if (value.startsWith('`')) {
-            return `\`${prefix} ${value.slice(1)}`;
+        // String and template literals are always strings, so merge them now.
+        // Anything else may be undefined/null/false at render time, which must
+        // add nothing rather than stringify into the class list.
+        if (value === '""' || value === "''" || value === '``') {
+            return `"${prefix}"`;
         }
-        if (value.startsWith('"')) {
-            return `"${prefix} ${value.slice(1)}`;
+        if (value.startsWith('`') || value.startsWith('"') || value.startsWith("'")) {
+            return `${value[0]}${prefix} ${value.slice(1)}`;
         }
-        return `\`${prefix} \${${value}}\``;
+        return `mergeClass("${prefix}", ${value})`;
     }
     attrKey(name) {
         if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
@@ -330,19 +359,19 @@ class CodeGenerator {
             // A mid-layer template both fills its parent's slots and exposes its
             // own (nested `block` nodes), so it needs a `blocks` parameter too.
             const params = templateHasBlocks(node)
-                ? `${node.params}, blocks: ${capitalize(node.name)}Blocks = {}`
+                ? appendArg(node.params, `blocks: ${capitalize(node.name)}Blocks = {}`)
                 : node.params;
             const code = `export function ${node.name}(${params}) {\n${i1}return ${extendsChunk.code}\n}`;
             const mappings = [
                 mapping(node.loc),
-                ...offsetMappings(extendsChunk.mappings, 1),
+                ...offsetMappings(extendsChunk.mappings, 1 + lineCount(params)),
             ];
             return { code, mappings };
         }
         // Check if body tree contains BlockNodes (layout template)
         const hasBlocks = templateHasBlocks(node);
         const params = hasBlocks
-            ? `${node.params}, blocks: ${capitalize(node.name)}Blocks = {}`
+            ? appendArg(node.params, `blocks: ${capitalize(node.name)}Blocks = {}`)
             : node.params;
         const bodyChunks = node.body
             .map(child => this.genNode(child, indent + 2))
@@ -371,16 +400,14 @@ class CodeGenerator {
         const code = `export function ${node.name}(${params}) {\n${commentPrefix}${i1}return ${bodyChunk.code}\n}`;
         const mappings = [
             mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1 + commentLines), // body starts after fn sig + comments
+            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(params) + commentLines), // body starts after fn sig + comments
         ];
         return { code, mappings };
     }
     // --- Mixin generation ---
     genMixinDefinition(node, indent) {
         const i1 = this.ind(indent + 1);
-        const params = node.params
-            ? `${node.params}, attrs: Attrs = {}`
-            : 'attrs: Attrs = {}';
+        const params = appendArg(node.params, 'attrs: Attrs = {}');
         const bodyChunks = node.body
             .map(child => this.genNode(child, indent + 1))
             .filter((e) => e !== null);
@@ -388,19 +415,16 @@ class CodeGenerator {
         const code = `export function ${node.name}(${params}) {\n${i1}return ${bodyChunk.code}\n}`;
         const mappings = [
             mapping(node.loc),
-            ...offsetMappings(bodyChunk.mappings, 1),
+            ...offsetMappings(bodyChunk.mappings, 1 + lineCount(params)),
         ];
         return { code, mappings };
     }
-    genMixinCall(node) {
-        const argParts = [];
-        if (node.args) {
-            argParts.push(node.args);
-        }
-        if (node.attrs.length > 0) {
-            argParts.push(this.genCallAttrs(node.attrs));
-        }
-        return chunk(`${node.name}(${argParts.join(', ')})`, node.loc);
+    genMixinCall(node, indent = 0) {
+        const args = node.attrs.length > 0
+            ? appendArg(node.args, this.genCallAttrs(node.attrs))
+            : node.args;
+        const prefix = this.formatted ? this.ind(indent) : '';
+        return chunk(reindent(`${node.name}(${args})`, prefix), node.loc);
     }
     genCallAttrs(attrs) {
         const parts = [];
@@ -446,17 +470,17 @@ class CodeGenerator {
             blockChunks.push({ code: blockCode, mappings: blockMappings });
         }
         const joinedBlocks = joinChunks(blockChunks, ',\n');
-        const code = `${node.target}(${node.args}, {\n${joinedBlocks.code}\n${pi}})`;
+        const args = reindent(node.args, pi);
+        const head = `${node.target}(${appendArg(args, '{', false)}`;
+        const code = `${head}\n${joinedBlocks.code}\n${pi}})`;
         const mappings = [
             mapping(node.loc),
-            ...offsetMappings(joinedBlocks.mappings, 1),
+            ...offsetMappings(joinedBlocks.mappings, 1 + lineCount(head)),
         ];
         return { code, mappings };
     }
-    genInclude(node) {
-        const segments = node.path.split('/');
-        const name = segments[segments.length - 1];
-        return chunk(`import { ${name} } from '${node.path}.js'`, node.loc);
+    genInclude(node, names) {
+        return chunk(`import { ${names.join(', ')} } from '${node.path}.js'`, node.loc);
     }
     // --- Simple generators ---
     genBufferedCode(node) {
@@ -470,12 +494,21 @@ class CodeGenerator {
 function countEffective(nodes) {
     return nodes.filter(n => n.type !== 'Comment' && n.type !== 'PassthroughComment').length;
 }
+/** True when shorthand classes merge with a `class=` value that is not a string literal. */
+function needsRuntimeClassMerge(node) {
+    const explicitClass = node.attrs.find(a => a.name === 'class' && !a.spread);
+    if (!explicitClass || explicitClass.value === null)
+        return false;
+    return !/^["'`]/.test(explicitClass.value);
+}
 function scanUsedHelpers(node) {
     const helpers = new Set();
     function walk(n) {
         switch (n.type) {
             case 'Element':
                 helpers.add('h');
+                if (n.classes.length > 0 && needsRuntimeClassMerge(n))
+                    helpers.add('mergeClass');
                 if (n.rawBlock)
                     helpers.add('raw');
                 for (const c of n.children)
@@ -570,6 +603,121 @@ function scanUsedHelpers(node) {
     walk(node);
     return helpers;
 }
+// --- Include resolution ---
+/** Names of the mixins a document defines at top level. */
+export function definedMixins(doc) {
+    return doc.children.flatMap(c => (c.type === 'MixinDefinition' ? [c.name] : []));
+}
+/** Every mixin call in the document, first call of each name, in source order. */
+function collectMixinCalls(doc) {
+    const calls = new Map();
+    function walkAll(nodes) {
+        for (const n of nodes)
+            walk(n);
+    }
+    function walk(n) {
+        switch (n.type) {
+            case 'MixinCall':
+                if (!calls.has(n.name))
+                    calls.set(n.name, n);
+                walkAll(n.block);
+                break;
+            case 'Element':
+                walkAll(n.children);
+                break;
+            case 'Conditional':
+                walkAll(n.consequent);
+                for (const alt of n.alternates)
+                    walkAll(alt.body);
+                if (n.fallback)
+                    walkAll(n.fallback);
+                break;
+            case 'Iteration':
+            case 'Template':
+            case 'MixinDefinition':
+                walkAll(n.body);
+                break;
+            case 'Block':
+                walkAll(n.children);
+                break;
+            case 'Extends':
+                for (const block of n.blocks)
+                    walkAll(block.children);
+                break;
+        }
+    }
+    walkAll(doc.children);
+    return calls;
+}
+/**
+ * Value bindings a pass-through `import` statement introduces. A loose read,
+ * not a TS parse: it only needs to spot a mixin imported by hand.
+ */
+function importedBindings(statement) {
+    if (/^import\s+type\b/.test(statement))
+        return [];
+    const clause = /^import\s+([\s\S]*?)\s+from\b/.exec(statement)?.[1];
+    if (!clause)
+        return [];
+    const names = [];
+    const defaultName = /^([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
+    if (defaultName)
+        names.push(defaultName);
+    const namespace = /\*\s*as\s+([A-Za-z_$][\w$]*)/.exec(clause)?.[1];
+    if (namespace)
+        names.push(namespace);
+    const named = /\{([^}]*)\}/.exec(clause)?.[1];
+    if (named) {
+        for (const spec of named.split(',')) {
+            const s = spec.trim();
+            if (s === '' || /^type\s/.test(s))
+                continue;
+            names.push(s.split(/\s+as\s+/).pop().trim());
+        }
+    }
+    return names;
+}
+/** Which called mixins each include must import, in first-call order. */
+function resolveIncludes(doc, resolveInclude) {
+    const includes = doc.children.filter((c) => c.type === 'Include');
+    const picks = new Map(includes.map(inc => [inc, []]));
+    if (includes.length === 0)
+        return picks;
+    const provided = new Set(definedMixins(doc));
+    for (const child of doc.children) {
+        if (child.type === 'Import') {
+            for (const name of importedBindings(child.statement))
+                provided.add(name);
+        }
+    }
+    const needed = [...collectMixinCalls(doc).values()].filter(call => !provided.has(call.name));
+    if (!resolveInclude) {
+        if (includes.length > 1 && needed.length > 0) {
+            const inc = includes[1];
+            throw new CodegenError(`Cannot tell which include defines mixin "${needed[0].name}" without an include resolver`, inc.loc.line, inc.loc.col);
+        }
+        picks.set(includes[0], needed.map(call => call.name));
+        return picks;
+    }
+    const available = new Map();
+    for (const inc of includes) {
+        try {
+            available.set(inc, new Set(resolveInclude(inc.path)));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new CodegenError(`Cannot include ${inc.path}: ${msg}`, inc.loc.line, inc.loc.col);
+        }
+    }
+    for (const call of needed) {
+        const inc = includes.find(i => available.get(i).has(call.name));
+        if (!inc) {
+            throw new CodegenError(`Mixin "${call.name}" is not defined in this file or any include`, call.loc.line, call.loc.col);
+        }
+        picks.get(inc).push(call.name);
+    }
+    return picks;
+}
 // --- Public API ---
 /** Generate a TypeScript expression from a single AST node. */
 export function generateExpr(node) {
@@ -580,14 +728,14 @@ export function generateExpr(node) {
     return result.code;
 }
 /** Generate TypeScript source from a DocumentNode. */
-export function generate(doc) {
+export function generate(doc, options = {}) {
     const gen = new CodeGenerator(true);
     const parts = [];
     // Scan for used runtime helpers
     const helpers = scanUsedHelpers(doc);
     // Emit runtime import (canonical order)
     if (helpers.size > 0) {
-        const order = ['h', 'doctype', 'Fragment', 'raw'];
+        const order = ['h', 'doctype', 'Fragment', 'raw', 'mergeClass'];
         const used = order.filter(h => helpers.has(h));
         parts.push(chunk(`import { ${used.join(', ')} } from "@chilts/weave"`));
     }
@@ -616,13 +764,11 @@ export function generate(doc) {
             parts.push(chunk(statement, child.loc));
         }
     }
-    // Emit include imports
-    for (const child of doc.children) {
-        if (child.type === 'Include') {
-            const result = gen.genNode(child, 0);
-            if (result !== null)
-                parts.push(result);
-        }
+    // Emit include imports: only the mixins this file calls, so an include
+    // that provides nothing used emits nothing.
+    for (const [include, names] of resolveIncludes(doc, options.resolveInclude)) {
+        if (names.length > 0)
+            parts.push(gen.genInclude(include, names));
     }
     // Emit extends imports (auto-import layout function)
     for (const child of doc.children) {
@@ -647,16 +793,16 @@ export function generate(doc) {
     return { code: final.code + '\n', mappings: final.mappings };
 }
 /** Full pipeline: source string → TypeScript source. */
-export function compile(source) {
+export function compile(source, options = {}) {
     const tokens = lex(source);
     const doc = parse(tokens);
-    return generate(doc).code;
+    return generate(doc, options).code;
 }
 /** Full pipeline with source map generation. */
 export function compileWithSourceMap(source, opts) {
     const tokens = lex(source);
     const doc = parse(tokens);
-    const result = generate(doc);
+    const result = generate(doc, opts);
     const sourceMap = buildSourceMap(result.mappings, opts.file, opts.sourceFile);
     return { code: result.code, sourceMap };
 }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { h, doctype, Fragment, raw, escape, SafeHtml } from './runtime/index.js';
+export { h, doctype, Fragment, raw, mergeClass, 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 { compile, compileWithSourceMap, generate, generateExpr, definedMixins, CodegenError } from './codegen/index.js';
+export type { GenerateResult, GenerateOptions, IncludeResolver, CodeChunk, Mapping, SourceMap } from './codegen/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,7 @@
 // Runtime
-export { h, doctype, Fragment, raw, escape, SafeHtml } from './runtime/index.js';
+export { h, doctype, Fragment, raw, mergeClass, 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 { lex, LexerError } from './lexer/index.js';
 export { parse, ParserError } from './parser/index.js';
 //# sourceMappingURL=index.js.map