@jesscss/core 2.0.0-alpha.1

package/lib/tree/condition.js

@@ -0,0 +1,103 @@
+import { F_NON_STATIC, F_VISIBLE, Node, defineType } from './node.js';
+import { Bool } from './bool.js';
+import { getPrintOptions } from './util/print.js';
+import { pipe, isThenable } from '@jesscss/awaitable-pipe';
+export class Condition extends Node {
+    type = 'Condition';
+    shortType = 'condition';
+    constructor(value, options, location, treeContext) {
+        super(value, options, location, treeContext);
+        // Conditions are always non-static, but can inherit may_async from children
+        this.addFlags(F_VISIBLE, F_NON_STATIC);
+    }
+    toTrimmedString(options) {
+        options = getPrintOptions(options);
+        const w = options.writer;
+        const mark = w.mark();
+        let [left, op, right] = this.value;
+        const needsParens = Boolean(right || this.options?.negate);
+        if (this.options?.negate) {
+            w.add('not ');
+        }
+        if (needsParens) {
+            w.add('(');
+        }
+        left.toString(options);
+        if (op && right) {
+            w.add(' ');
+            w.add(String(op));
+            w.add(' ');
+            right.toString(options);
+        }
+        if (needsParens) {
+            w.add(')');
+        }
+        return w.getSince(mark);
+    }
+    static getBool(node, negated) {
+        if (node instanceof Bool) {
+            return new Bool(negated ? !node.value : node.value);
+        }
+        // Less guards treat only explicit booleans as truthy.
+        // Any non-boolean (number, quoted, keyword, list, nil, etc.) is false.
+        return new Bool(negated);
+    }
+    static getResult(a, b, op) {
+        switch (op) {
+            case 'and': return Condition.getBool(a, false).value && Condition.getBool(b, false).value;
+            case 'or': return Condition.getBool(a, false).value || Condition.getBool(b, false).value;
+            default:
+                switch (a.compare(b)) {
+                    case -1:
+                        return op === '<' || op === '<=';
+                    case 0:
+                        return op === '=' || op === '>=' || op === '<=';
+                    case 1:
+                        return op === '>' || op === '>=';
+                    default:
+                        return false;
+                }
+        }
+    }
+    evalNode(context) {
+        let [left, op, right] = this.value;
+        let negated = !!this.options?.negate;
+        return pipe(() => left.eval(context), (a) => {
+            if (!right) {
+                // Defer unary coercion to the final stage to avoid double-negation.
+                return a;
+            }
+            return a;
+        }, (a) => {
+            if (!right) {
+                return [a];
+            }
+            let b = right.eval(context);
+            if (isThenable(b)) {
+                return b.then(bb => [a, bb]);
+            }
+            return [a, b];
+        }, ([a, b]) => {
+            if (!b) {
+                const unary = Condition.getBool(a, negated);
+                return unary;
+            }
+            const normalizeDefaultCall = (node) => {
+                if (node.type !== 'Call') {
+                    return node;
+                }
+                const callName = String(node.value?.name?.valueOf?.() ?? node.value?.name ?? '');
+                if (callName === 'default' || callName === '??') {
+                    return new Bool(Boolean(context.isDefault));
+                }
+                return node;
+            };
+            a = normalizeDefaultCall(a);
+            b = normalizeDefaultCall(b);
+            let result = Condition.getResult(a, b, op);
+            return new Bool(negated ? !result : result);
+        });
+    }
+}
+export const condition = defineType(Condition, 'Condition');
+//# sourceMappingURL=condition.js.map

package/lib/tree/condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition.js","sourceRoot":"","sources":["../../src/tree/condition.ts"],"names":[],"mappings":"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"}

package/lib/tree/control.d.ts

@@ -0,0 +1,104 @@
+import { Node, type LocationInfo } from './node.js';
+import type { Context, TreeContext } from '../context.js';
+import { Rules } from './rules.js';
+import { Sequence } from './sequence.js';
+import { VarDeclaration } from './declaration-var.js';
+import { type PrintOptions } from './util/print.js';
+import type { MaybePromise } from '@jesscss/awaitable-pipe';
+export type ForPattern = {
+    kind: 'single';
+    value: VarDeclaration;
+} | {
+    kind: 'tuple';
+    values: [VarDeclaration, ...VarDeclaration[]];
+};
+export type ForIterable = {
+    kind: 'node';
+    value: Node;
+} | {
+    kind: 'range';
+    start: Node;
+    end: Node;
+    step?: Node;
+    includeStart: boolean;
+    includeEnd: boolean;
+};
+type LegacyLoopValue = {
+    header: Sequence;
+    rules: Rules;
+};
+export type IfBranch = {
+    /** Undefined means "else" branch */
+    condition?: Node;
+    rules: Rules;
+};
+export type IfValue = {
+    branches: IfBranch[];
+};
+/**
+ * A control-flow block that serializes as:
+ * - `$if (...) { ... }`
+ * - `$else if (...) { ... }`
+ * - `$else { ... }`
+ *
+ * This is language-agnostic: it’s the canonical Jess control node.
+ */
+export declare class If extends Node<IfValue> {
+    type: "If";
+    shortType: "if";
+    allowRoot: boolean;
+    allowRuleRoot: boolean;
+    constructor(value: IfValue, options?: any, location?: LocationInfo, treeContext?: TreeContext);
+    toTrimmedString(options?: PrintOptions): string;
+}
+export type StructuredLoopValue = {
+    pattern: ForPattern;
+    iterable: ForIterable;
+    rules: Rules;
+};
+export type LoopValue = StructuredLoopValue | LegacyLoopValue;
+/**
+ * `$for <header> { ... }`
+ */
+export declare class For extends Node<StructuredLoopValue> {
+    type: "For";
+    shortType: "for";
+    allowRoot: boolean;
+    allowRuleRoot: boolean;
+    constructor(value: LoopValue, options?: any, location?: LocationInfo, treeContext?: TreeContext);
+    preEval(context: Context): MaybePromise<Node>;
+    evalNode(context: Context): MaybePromise<Node>;
+    toTrimmedString(options?: PrintOptions): string;
+}
+/**
+ * `$each <header> { ... }`
+ */
+export declare class Each extends Node<LegacyLoopValue> {
+    type: "Each";
+    shortType: "each";
+    allowRoot: boolean;
+    allowRuleRoot: boolean;
+    constructor(value: LegacyLoopValue, options?: any, location?: LocationInfo, treeContext?: TreeContext);
+    toTrimmedString(options?: PrintOptions): string;
+}
+export type WhileValue = {
+    condition: Node;
+    rules: Rules;
+};
+/**
+ * `$while (<condition>) { ... }`
+ */
+export declare class While extends Node<WhileValue> {
+    type: "While";
+    shortType: "while";
+    allowRoot: boolean;
+    allowRuleRoot: boolean;
+    constructor(value: WhileValue, options?: any, location?: LocationInfo, treeContext?: TreeContext);
+    toTrimmedString(options?: PrintOptions): string;
+}
+export declare const ifNode: (value?: IfValue | undefined, options?: any, location?: LocationInfo | undefined) => If;
+export declare const forNode: (value?: LoopValue | undefined, options?: any, location?: LocationInfo | undefined) => For;
+export declare const eachNode: (value?: LegacyLoopValue | undefined, options?: any, location?: LocationInfo | undefined) => Each;
+export declare const whileNode: (value?: WhileValue | undefined, options?: any, location?: LocationInfo | undefined) => While;
+export {};
+//# sourceMappingURL=control.d.ts.map

package/lib/tree/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/tree/control.ts"],"names":[],"mappings":"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"}

package/lib/tree/control.js

@@ -0,0 +1,430 @@
+import { Node, defineType, F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC } from './node.js';
+import { Rules } from './rules.js';
+import { Sequence } from './sequence.js';
+import { Any } from './any.js';
+import { Num } from './number.js';
+import { VarDeclaration } from './declaration-var.js';
+import { isNode } from './util/is-node.js';
+import { getPrintOptions } from './util/print.js';
+import { Block } from './block.js';
+import { Range } from './range.js';
+import { List } from './list.js';
+const PUBLIC_RULE_VISIBILITY = {
+    Declaration: 'public',
+    Ruleset: 'public',
+    VarDeclaration: 'public',
+    Mixin: 'public'
+};
+function makeDirectiveRulesPublic(rules) {
+    rules.options.rulesVisibility = {
+        ...rules.options.rulesVisibility,
+        ...PUBLIC_RULE_VISIBILITY
+    };
+}
+function parsePatternNode(patternNode) {
+    if (isNode(patternNode, 'VarDeclaration')) {
+        return { kind: 'single', value: patternNode };
+    }
+    if (isNode(patternNode, 'Block') && patternNode.options?.type === 'square' && isNode(patternNode.value, 'List')) {
+        const values = patternNode.value.value.filter((entry) => isNode(entry, 'VarDeclaration'));
+        if (values.length === 1) {
+            return { kind: 'single', value: values[0] };
+        }
+        if (values.length > 1) {
+            return { kind: 'tuple', values: values };
+        }
+    }
+    if (isNode(patternNode, ['List', 'Sequence'])) {
+        const values = patternNode.value.filter((entry) => isNode(entry, 'VarDeclaration'));
+        if (values.length === 1) {
+            return { kind: 'single', value: values[0] };
+        }
+        if (values.length > 1) {
+            return { kind: 'tuple', values: values };
+        }
+    }
+    throw new Error('Invalid $for pattern: expected one or more variables');
+}
+function parseLegacyHeader(header) {
+    const headerNode = header.value[0];
+    const inner = isNode(headerNode, 'Paren') && headerNode.value
+        ? headerNode.value
+        : headerNode;
+    const sequence = isNode(inner, 'Sequence')
+        ? inner.value
+        : [inner].filter(Boolean);
+    const ofIndex = sequence.findIndex(node => isNode(node, 'Any') && node.valueOf() === 'of');
+    if (ofIndex <= 0 || ofIndex >= sequence.length - 1) {
+        throw new Error('Invalid $for header: expected "<pattern> of <iterable>"');
+    }
+    const patternParts = sequence.slice(0, ofIndex);
+    const iterableParts = sequence.slice(ofIndex + 1);
+    const patternNode = patternParts.length === 1
+        ? patternParts[0]
+        : new Sequence(patternParts);
+    const iterableNode = iterableParts.length === 1
+        ? iterableParts[0]
+        : new Sequence(iterableParts);
+    let iterable;
+    if (isNode(iterableNode, 'Range')) {
+        iterable = {
+            kind: 'range',
+            start: iterableNode.value.start,
+            end: iterableNode.value.end,
+            step: iterableNode.value.step,
+            includeStart: iterableNode.options?.includeStart !== false,
+            includeEnd: iterableNode.options?.includeEnd !== false
+        };
+    }
+    else {
+        iterable = { kind: 'node', value: iterableNode };
+    }
+    return {
+        pattern: parsePatternNode(patternNode),
+        iterable
+    };
+}
+function getBindingNames(pattern) {
+    if (pattern.kind === 'single') {
+        return [pattern.value.value.name.valueOf()];
+    }
+    if (pattern.kind === 'tuple') {
+        return pattern.values.map(entry => entry.value.name.valueOf());
+    }
+    return [];
+}
+function patternToNode(pattern) {
+    if (pattern.kind === 'single') {
+        return pattern.value;
+    }
+    return new Block(new List([...pattern.values], { sep: ',' }), { type: 'square' });
+}
+function iterableToNode(iterable) {
+    if (iterable.kind === 'node') {
+        return iterable.value;
+    }
+    return new Range({
+        start: iterable.start,
+        end: iterable.end,
+        step: iterable.step
+    }, {
+        includeStart: iterable.includeStart,
+        includeEnd: iterable.includeEnd
+    });
+}
+async function* resolveEntries(input, context) {
+    if (isNode(input, 'Expression')) {
+        yield* resolveEntries(await input.value.eval(context), context);
+        return;
+    }
+    if (isNode(input, 'Call')) {
+        const evald = await input.eval(context);
+        if (isNode(evald, 'Call')) {
+            yield [evald, 0];
+            return;
+        }
+        yield* resolveEntries(evald, context);
+        return;
+    }
+    if ((isNode(input, 'Sequence') || isNode(input, 'List')) && Array.isArray(input.value)) {
+        for (let key = 0; key < input.value.length; key++) {
+            const value = input.value[key];
+            yield [value, key];
+        }
+        return;
+    }
+    if (isNode(input, ['Rules', 'Ruleset', 'Mixin'])) {
+        const rules = isNode(input, 'Rules')
+            ? input.value
+            : isNode(input, 'Ruleset')
+                ? (input.value.rules?.value ?? [])
+                : (input.value.rules?.value ?? []);
+        for (const rule of rules) {
+            if (!rule || isNode(rule, 'Comment')) {
+                continue;
+            }
+            if (!isNode(rule, 'Declaration')) {
+                continue;
+            }
+            yield [rule.value.value, rule.value.name];
+        }
+        return;
+    }
+    yield [input, 0];
+}
+/**
+ * A control-flow block that serializes as:
+ * - `$if (...) { ... }`
+ * - `$else if (...) { ... }`
+ * - `$else { ... }`
+ *
+ * This is language-agnostic: it’s the canonical Jess control node.
+ */
+export class If extends Node {
+    type = 'If';
+    shortType = 'if';
+    allowRoot = true;
+    allowRuleRoot = true;
+    constructor(value, options, location, treeContext) {
+        super(value, options, location, treeContext);
+        this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+        for (const branch of value.branches) {
+            makeDirectiveRulesPublic(branch.rules);
+        }
+    }
+    toTrimmedString(options) {
+        options = getPrintOptions(options);
+        const w = options.writer;
+        const mark = w.mark();
+        const [first, ...rest] = this.value.branches;
+        w.add('$if', this);
+        w.add(' (');
+        first?.condition?.toString(options);
+        w.add(') ');
+        first?.rules.toBraced(options);
+        for (const br of rest) {
+            if (br.condition) {
+                w.add(' $else if (');
+                br.condition.toString(options);
+                w.add(') ');
+            }
+            else {
+                w.add(' $else ');
+            }
+            br.rules.toBraced(options);
+        }
+        return w.getSince(mark);
+    }
+}
+/**
+ * `$for <header> { ... }`
+ */
+export class For extends Node {
+    type = 'For';
+    shortType = 'for';
+    allowRoot = true;
+    allowRuleRoot = true;
+    constructor(value, options, location, treeContext) {
+        const normalized = ('header' in value)
+            ? (() => {
+                const parsed = parseLegacyHeader(value.header);
+                return {
+                    pattern: parsed.pattern,
+                    iterable: parsed.iterable,
+                    rules: value.rules
+                };
+            })()
+            : value;
+        super(normalized, options, location, treeContext);
+        this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+        makeDirectiveRulesPublic(normalized.rules);
+    }
+    preEval(context) {
+        if (!this.preEvaluated) {
+            const node = this.maybeClone(context);
+            node.preEvaluated = true;
+            return node;
+        }
+        return this;
+    }
+    evalNode(context) {
+        const { pattern, iterable } = this.value;
+        const bindingNames = getBindingNames(pattern);
+        if (bindingNames.length === 0) {
+            throw new Error('Invalid $for header: missing binding variable');
+        }
+        const run = async () => {
+            const accumulatedNodes = [];
+            let counter = 1;
+            const evaluatedIterable = await iterableToNode(iterable).eval(context);
+            for await (const [value, key] of resolveEntries(evaluatedIterable, context)) {
+                const loopRules = this.value.rules.clone(true);
+                // Preserve definition-scope parent chain so nested calls/lookups
+                // inside loop bodies resolve the same way as the original rules.
+                loopRules.inherit(this.value.rules);
+                if (accumulatedNodes.length > 0) {
+                    // Make prior iteration output visible to current iteration lookups
+                    // (e.g. `index+: @index`, `padding+_: ...`) without mutating emitted nodes.
+                    const priorScope = new Rules(accumulatedNodes.map(n => n.copy(true)));
+                    priorScope.inherit(this.value.rules);
+                    priorScope.adopt(loopRules);
+                }
+                const resolvedValue = await value.eval(context);
+                let resolvedKey;
+                if (typeof key === 'number') {
+                    resolvedKey = new Num(key + 1);
+                }
+                else if (typeof key === 'string' && key === 'value') {
+                    resolvedKey = new Num(counter);
+                }
+                else if (isNode(key)) {
+                    resolvedKey = await key.eval(context);
+                }
+                else {
+                    resolvedKey = new Any(String(key), { role: 'property' });
+                }
+                const bindings = [resolvedValue, resolvedKey, new Num(counter)];
+                for (let i = Math.min(bindingNames.length, bindings.length) - 1; i >= 0; i--) {
+                    loopRules.value.unshift(new VarDeclaration({
+                        name: new Any(bindingNames[i], { role: 'property' }),
+                        value: bindings[i]
+                    }));
+                }
+                counter++;
+                const result = await loopRules.eval(context);
+                if (isNode(result, 'Rules')) {
+                    for (const outNode of result.value) {
+                        if (isNode(outNode, 'Declaration')) {
+                            const normalizedFromAssign = outNode.options.normalizedFromAssign;
+                            const outName = String(outNode.value.name);
+                            const isMergedAssignment = normalizedFromAssign === "+:" /* AssignmentType.Add */
+                                || normalizedFromAssign === "&,:" /* AssignmentType.MergeList */
+                                || normalizedFromAssign === "&_:" /* AssignmentType.MergeSequence */;
+                            // Keep manual by-name coalescing narrowly scoped to legacy padding merges.
+                            // `index` declarations in plain loop bodies should remain per-iteration.
+                            const shouldCoalesceByName = outName === 'padding';
+                            if (isMergedAssignment || shouldCoalesceByName) {
+                                let firstMatch = -1;
+                                for (let i = 0; i < accumulatedNodes.length; i++) {
+                                    const prev = accumulatedNodes[i];
+                                    if (isNode(prev, 'Declaration') && String(prev.value.name) === outName) {
+                                        firstMatch = i;
+                                        break;
+                                    }
+                                }
+                                if (firstMatch >= 0) {
+                                    const prev = accumulatedNodes[firstMatch];
+                                    if (isNode(prev, 'Declaration')) {
+                                        const prevValue = prev.value.value;
+                                        const nextValue = outNode.value.value;
+                                        if (normalizedFromAssign === "+:" /* AssignmentType.Add */
+                                            || normalizedFromAssign === "&,:" /* AssignmentType.MergeList */) {
+                                            const prevItems = isNode(prevValue, 'List')
+                                                ? prevValue.value
+                                                : [prevValue];
+                                            const nextItems = isNode(nextValue, 'List')
+                                                ? nextValue.value
+                                                : [nextValue];
+                                            const nextAlreadyIncludesPrev = nextItems.length >= prevItems.length
+                                                && prevItems.every((item, idx) => String(item.valueOf()) === String(nextItems[idx]?.valueOf()));
+                                            const mergedItems = nextAlreadyIncludesPrev
+                                                ? [...nextItems]
+                                                : [...prevItems, ...nextItems];
+                                            outNode.value.value = new List(mergedItems).inherit(outNode.value.value);
+                                        }
+                                        else if (normalizedFromAssign === "&_:" /* AssignmentType.MergeSequence */) {
+                                            const prevItems = isNode(prevValue, 'Sequence')
+                                                ? prevValue.value
+                                                : [prevValue];
+                                            const nextItems = isNode(nextValue, 'Sequence')
+                                                ? nextValue.value
+                                                : [nextValue];
+                                            const nextAlreadyIncludesPrev = nextItems.length >= prevItems.length
+                                                && prevItems.every((item, idx) => String(item.valueOf()) === String(nextItems[idx]?.valueOf()));
+                                            const mergedItems = nextAlreadyIncludesPrev
+                                                ? [...nextItems]
+                                                : [...prevItems, ...nextItems];
+                                            outNode.value.value = new Sequence(mergedItems).inherit(outNode.value.value);
+                                        }
+                                    }
+                                    accumulatedNodes[firstMatch] = outNode;
+                                    for (let i = accumulatedNodes.length - 1; i > firstMatch; i--) {
+                                        const prev = accumulatedNodes[i];
+                                        if (isNode(prev, 'Declaration') && String(prev.value.name) === outName) {
+                                            accumulatedNodes.splice(i, 1);
+                                        }
+                                    }
+                                    continue;
+                                }
+                                // Keep merged declarations before nested rulesets to avoid split-output
+                                // duplicate selectors (e.g. `.each { ... }` then another `.each { ... }`).
+                                let firstNestedRuleset = -1;
+                                for (let i = 0; i < accumulatedNodes.length; i++) {
+                                    if (isNode(accumulatedNodes[i], ['Ruleset', 'Rules'])) {
+                                        firstNestedRuleset = i;
+                                        break;
+                                    }
+                                }
+                                if (firstNestedRuleset >= 0) {
+                                    accumulatedNodes.splice(firstNestedRuleset, 0, outNode);
+                                    continue;
+                                }
+                            }
+                        }
+                        accumulatedNodes.push(outNode);
+                    }
+                }
+                else {
+                    accumulatedNodes.push(result);
+                }
+            }
+            return new Rules(accumulatedNodes);
+        };
+        return run();
+    }
+    toTrimmedString(options) {
+        options = getPrintOptions(options);
+        const w = options.writer;
+        const mark = w.mark();
+        w.add('$for ', this);
+        w.add('(');
+        patternToNode(this.value.pattern).toString(options);
+        w.add(' of ');
+        iterableToNode(this.value.iterable).toString(options);
+        w.add(')');
+        w.add(' ');
+        this.value.rules.toBraced(options);
+        return w.getSince(mark);
+    }
+}
+/**
+ * `$each <header> { ... }`
+ */
+export class Each extends Node {
+    type = 'Each';
+    shortType = 'each';
+    allowRoot = true;
+    allowRuleRoot = true;
+    constructor(value, options, location, treeContext) {
+        super(value, options, location, treeContext);
+        this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+    }
+    toTrimmedString(options) {
+        options = getPrintOptions(options);
+        const w = options.writer;
+        const mark = w.mark();
+        w.add('$each ', this);
+        this.value.header.toString(options);
+        w.add(' ');
+        this.value.rules.toBraced(options);
+        return w.getSince(mark);
+    }
+}
+/**
+ * `$while (<condition>) { ... }`
+ */
+export class While extends Node {
+    type = 'While';
+    shortType = 'while';
+    allowRoot = true;
+    allowRuleRoot = true;
+    constructor(value, options, location, treeContext) {
+        super(value, options, location, treeContext);
+        this.addFlags(F_VISIBLE, F_NON_STATIC, F_MAY_ASYNC);
+    }
+    toTrimmedString(options) {
+        options = getPrintOptions(options);
+        const w = options.writer;
+        const mark = w.mark();
+        w.add('$while (', this);
+        this.value.condition.toString(options);
+        w.add(') ');
+        this.value.rules.toBraced(options);
+        return w.getSince(mark);
+    }
+}
+export const ifNode = defineType(If, 'If', 'if');
+export const forNode = defineType(For, 'For', 'for');
+export const eachNode = defineType(Each, 'Each', 'each');
+export const whileNode = defineType(While, 'While', 'while');
+//# sourceMappingURL=control.js.map