@jesscss/core 2.0.0-alpha.2 → 2.0.0-alpha.5

package/lib/tree/rules.js

@@ -637,6 +637,12 @@ export class Rules extends Node {
                 rules.value[index] = node.preEval(context);
                 return;
             }
+            // Nodes that don't register by name (Call, Expression, etc.) skip
+            // both preEval and dynamic resolution — they're handled by the eval queue.
+            if (!this._isRegisterableType(node)) {
+                node.index = index;
+                return;
+            }
             if (this._hasStaticName(node)) {
                 // Pre-evaluate nodes with static names before registration
                 // This ensures selectors are evaluated and keySets are available for rulesets
@@ -696,6 +702,15 @@ export class Rules extends Node {
         // Primitive values (strings, numbers, etc.) are considered static
         return true;
     }
+    /**
+     * Check if a node type participates in name-based registration.
+     * Only these node types have names/selectors that _resolveDynamicNodes
+     * needs to resolve. Everything else (Call, Expression, Comment, etc.)
+     * goes straight to the eval queue without preEval.
+     */
+    _isRegisterableType(node) {
+        return isNode(node, ['VarDeclaration', 'Declaration', 'Mixin', 'Ruleset', 'StyleImport']);
+    }
     /**
      * Check if a node has a static name that can be registered immediately
      */
@@ -708,6 +723,10 @@ export class Rules extends Node {
             const name = node.value.name;
             return this._isStatic(name);
         }
+        if (isNode(node, 'Declaration')) {
+            const name = node.value.name;
+            return this._isStatic(name);
+        }
         if (isNode(node, 'StyleImport')) {
             const path = node.value.path;
             return this._isStatic(path);
@@ -729,7 +748,7 @@ export class Rules extends Node {
             }
             return false;
         }
-        // For other node types, assume they can be registered if they have static names
+        // For other registerable node types, check the F_STATIC flag
         return node.hasFlag(F_STATIC);
     }
     /**
@@ -751,105 +770,132 @@ export class Rules extends Node {
      * Multi-pass resolution of dynamic nodes with interpolated names
      */
     _resolveDynamicNodes(rules, context, saved, dynamicNodes) {
-        const unresolvedNodes = [...dynamicNodes];
         const resolvedNodes = [];
-        let firstError;
-        let resolutionAttempts = 0;
-        const MAX_RESOLUTION_ATTEMPTS = 5;
-        const attemptResolution = () => {
-            resolutionAttempts++;
-            if (resolutionAttempts > MAX_RESOLUTION_ATTEMPTS) {
-                throw new Error(`Could not resolve node.`);
+        const handleResolvedNode = (resolvedNode, node, stillUnresolved) => {
+            if (resolvedNode.index === undefined) {
+                resolvedNode.index = node.index;
+            }
+            if (!resolvedNode.sourceNode) {
+                resolvedNode.sourceNode = node.sourceNode ?? node;
+            }
+            if (resolvedNode.type === 'Ruleset') {
+                rules.registerNode(resolvedNode);
+            }
+            if (isNode(resolvedNode, 'Nil') || this._hasStaticName(resolvedNode)) {
+                resolvedNodes.push(resolvedNode);
+                this._registerNodeIfEligible(rules, resolvedNode, context);
+                return true; // made progress
+            }
+            else {
+                stillUnresolved.push(resolvedNode);
+                return false;
+            }
+        };
+        const applyResolvedNodes = () => {
+            for (let i = 0; i < rules.value.length; i++) {
+                const node = rules.value[i];
+                const resolvedNode = resolvedNodes.find(n => n.index === node.index);
+                if (resolvedNode && resolvedNode !== node) {
+                    rules.value[i] = resolvedNode.inherit(node);
+                    rules.adopt(resolvedNode);
+                }
+            }
+        };
+        const finishResolution = () => {
+            applyResolvedNodes();
+            context.rulesContext = saved.rulesContext;
+            context.treeRoot = saved.treeRoot;
+            if (saved.root !== undefined) {
+                context.root = saved.root;
+            }
+            return rules;
+        };
+        // Separate declarations (whose dynamic names might depend on each other)
+        // from non-declarations (which depend on declaration VALUES, not names,
+        // so retrying during preEval won't help).
+        const isDeclarationType = (n) => isNode(n, 'VarDeclaration') || isNode(n, 'Declaration');
+        const dynamicDeclarations = [];
+        const otherDynamic = [];
+        for (const node of dynamicNodes) {
+            if (isDeclarationType(node)) {
+                dynamicDeclarations.push(node);
+            }
+            else {
+                otherDynamic.push(node);
+            }
+        }
+        // Phase 1: Resolve declarations with dynamic names.
+        // Retry because one declaration's name might depend on another's being registered.
+        const MAX_DECL_RETRIES = 5;
+        let declRetries = 0;
+        const unresolvedDecls = [...dynamicDeclarations];
+        const resolveDeclarations = () => {
+            declRetries++;
+            if (declRetries > MAX_DECL_RETRIES || unresolvedDecls.length === 0) {
+                return;
             }
             const stillUnresolved = [];
             let madeProgress = false;
-            for (const node of unresolvedNodes) {
+            for (let i = 0; i < unresolvedDecls.length; i++) {
+                const node = unresolvedDecls[i];
                 try {
-                    // Try to preEval the node
                     const result = node.preEval(context);
                     if (isThenable(result)) {
-                        // Handle async preEval
+                        const remaining = unresolvedDecls.slice(i + 1);
                         return result.then((resolvedNode) => {
-                            if (resolvedNode.index === undefined) {
-                                resolvedNode.index = node.index;
-                            }
-                            if (!resolvedNode.sourceNode) {
-                                resolvedNode.sourceNode = node.sourceNode ?? node;
-                            }
-                            // Register rulesets after preEval regardless of static name
-                            if (resolvedNode.type === 'Ruleset') {
-                                // registerNode handles both 'mixin' and 'ruleset' registries
-                                rules.registerNode(resolvedNode);
-                            }
-                            if (isNode(resolvedNode, 'Nil') || this._hasStaticName(resolvedNode)) {
-                                resolvedNodes.push(resolvedNode);
-                                this._registerNodeIfEligible(rules, resolvedNode, context);
+                            if (handleResolvedNode(resolvedNode, node, stillUnresolved)) {
                                 madeProgress = true;
                             }
-                            else {
-                                stillUnresolved.push(resolvedNode);
+                            unresolvedDecls.length = 0;
+                            unresolvedDecls.push(...stillUnresolved, ...remaining);
+                            if (madeProgress && unresolvedDecls.length > 0) {
+                                return resolveDeclarations();
                             }
-                            return attemptResolution();
                         });
                     }
-                    // Register rulesets after preEval regardless of static name
-                    if (result.index === undefined) {
-                        result.index = node.index;
-                    }
-                    if (!result.sourceNode) {
-                        result.sourceNode = node.sourceNode ?? node;
-                    }
-                    if (result.type === 'Ruleset') {
-                        // registerNode handles both 'mixin' and 'ruleset' registries
-                        rules.registerNode(result);
-                    }
-                    // Check if the node now has a static name
-                    if (isNode(result, 'Nil') || this._hasStaticName(result)) {
-                        resolvedNodes.push(result);
-                        this._registerNodeIfEligible(rules, result, context);
+                    if (handleResolvedNode(result, node, stillUnresolved)) {
                         madeProgress = true;
                     }
-                    else {
-                        stillUnresolved.push(result);
-                    }
                 }
-                catch (error) {
-                    if (!firstError) {
-                        firstError = error;
-                    }
+                catch {
                     stillUnresolved.push(node);
                 }
             }
-            // Update the rules with resolved nodes
-            for (let i = 0; i < rules.value.length; i++) {
-                const node = rules.value[i];
-                const resolvedNode = resolvedNodes.find(n => n.index === node.index);
-                if (resolvedNode && resolvedNode !== node) {
-                    rules.value[i] = resolvedNode.inherit(node);
-                    rules.adopt(resolvedNode);
-                }
-            }
-            // If we made progress, try again
             if (madeProgress && stillUnresolved.length > 0) {
-                unresolvedNodes.length = 0;
-                unresolvedNodes.push(...stillUnresolved);
-                return attemptResolution();
+                unresolvedDecls.length = 0;
+                unresolvedDecls.push(...stillUnresolved);
+                return resolveDeclarations();
             }
-            // If we still have unresolved nodes and we're done with rules evaluation, throw the first error
-            if (stillUnresolved.length > 0 && firstError) {
-                throw firstError;
-            }
-            // Restore context after preEval is complete
-            context.rulesContext = saved.rulesContext;
-            context.treeRoot = saved.treeRoot;
-            // Only restore context.root if saved.root is defined (not the outermost root)
-            // If saved.root is undefined, it means we're at the outermost level, so keep context.root as is
-            if (saved.root !== undefined) {
-                context.root = saved.root;
+        };
+        // Phase 2: Try non-declarations once. Their interpolated names typically
+        // depend on declaration VALUES (e.g. @infix from breakpoint-infix()),
+        // which aren't evaluated until the eval phase. Retrying won't help.
+        const resolveOtherOnce = () => {
+            for (let i = 0; i < otherDynamic.length; i++) {
+                const node = otherDynamic[i];
+                try {
+                    const result = node.preEval(context);
+                    if (isThenable(result)) {
+                        const remaining = otherDynamic.slice(i + 1);
+                        return result.then((resolvedNode) => {
+                            handleResolvedNode(resolvedNode, node, []);
+                            // Continue with remaining nodes
+                            otherDynamic.length = 0;
+                            otherDynamic.push(...remaining);
+                            return resolveOtherOnce();
+                        });
+                    }
+                    handleResolvedNode(result, node, []);
+                }
+                catch {
+                    // Can't resolve during preEval — leave in place for eval phase
+                }
             }
-            return rules;
         };
-        return attemptResolution();
+        return pipe(() => resolveDeclarations(), () => {
+            applyResolvedNodes();
+            return resolveOtherOnce();
+        }, () => finishResolution());
     }
     /**
      * Helper method to continue preEval'ing remaining children after an async preEval.
@@ -1025,6 +1071,15 @@ export class Rules extends Node {
                     if (p === 0 /* Priority.None */) {
                         throw error;
                     }
+                    // Only retry when the import path itself couldn't be resolved
+                    // (e.g. @import "@{theme}/file" where @theme isn't available yet).
+                    // Path resolution is cheap (no cloning). Content evaluation errors
+                    // (after cloning the import tree) are never retried — each retry
+                    // would re-clone the entire tree, causing memory blowup.
+                    const isPathError = error instanceof Error && error._isPathResolutionError;
+                    if (!isPathError) {
+                        throw error;
+                    }
                     // Retry policy:
                     // 1) first failure at a priority -> retry once at same priority
                     // 2) second+ failure at that priority -> step down one level
@@ -2038,7 +2093,7 @@ export function getFunctionFromMixins(mixins) {
                         Mixin: 'public'
                     }
                 });
-                candidate.parent.adopt(outerRules);
+                (thisContext.rulesContext ?? candidate.parent).adopt(outerRules);
                 outerRules.index = candidate.index;
                 for (let i = 0; i < params.value.length; i++) {
                     let param = params.value[i];
@@ -2108,9 +2163,20 @@ export function getFunctionFromMixins(mixins) {
                         .map(p => p.value.value);
                     const argumentNodes = (paramValues && paramValues.length > 0) ? paramValues : nodeArgs;
                     for (const argNode of argumentNodes) {
-                        const cloned = argNode.copy(true, freezeChildren);
-                        cloned.frozen = true;
-                        argumentsArgs.push(cloned);
+                        // If a Rest param collected args into a Sequence, spread its items
+                        // so @arguments reflects the actual argument count
+                        if (isNode(argNode, 'Sequence')) {
+                            for (const item of argNode.value) {
+                                const cloned = item.copy(true, freezeChildren);
+                                cloned.frozen = true;
+                                argumentsArgs.push(cloned);
+                            }
+                        }
+                        else {
+                            const cloned = argNode.copy(true, freezeChildren);
+                            cloned.frozen = true;
+                            argumentsArgs.push(cloned);
+                        }
                     }
                 }
             }