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

package/src/tree/util/__tests__/process-extends.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect } from 'vitest';
+import { Context } from '../../../context.js';
+import { tryExtendSelector } from '../extend-core.js';
+import {
+  rules,
+  ruleset,
+  extend,
+  el,
+  compound,
+  sellist,
+  sel,
+  co,
+  pseudo,
+  ExtendFlag,
+  type Ruleset
+} from '../../index.js';
+
+/**
+ * processExtends behavior is tested via the real eval flow: build AST as the parser would
+ * (rules with rulesets that contain extend() nodes), call root.eval(context), then assert.
+ * No manual context.root, context.extendRoots.registerRoot, or context.extends.push.
+ */
+describe('processExtends function (eval flow)', () => {
+  describe('Basic extend processing', () => {
+    it('should extend a simple ruleset', async () => {
+      const root = rules([
+        ruleset({ selector: el('.foo'), rules: rules([]) }),
+        ruleset({
+          selector: el('.bar'),
+          rules: rules([extend({ target: el('.foo') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe('.foo,.bar');
+    });
+
+    it('should handle multiple extends on same target', async () => {
+      const root = rules([
+        ruleset({ selector: el('.foo'), rules: rules([]) }),
+        ruleset({
+          selector: el('.bar'),
+          rules: rules([extend({ target: el('.foo') })])
+        }),
+        ruleset({
+          selector: el('.baz'),
+          rules: rules([extend({ target: el('.foo') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe('.foo,.bar,.baz');
+    });
+
+    it('should skip self-referencing extends', async () => {
+      const root = rules([
+        ruleset({
+          selector: el('.foo'),
+          rules: rules([extend({ target: el('.foo') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe('.foo');
+    });
+  });
+
+  describe('Extend chaining', () => {
+    it('should chain extends when extended selector matches another target', async () => {
+      const root = rules([
+        ruleset({ selector: el('.foo'), rules: rules([]) }),
+        ruleset({
+          selector: el('.bar'),
+          rules: rules([extend({ target: el('.foo') })])
+        }),
+        ruleset({
+          selector: el('.baz'),
+          rules: rules([extend({ target: el('.bar') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe('.foo,.bar,.baz');
+    });
+  });
+
+  describe('Partial extends', () => {
+    it('should handle partial extends with all flag', async () => {
+      const targetSelector = compound([el('.a'), el('.b')]);
+      const extendSelector = el('.c');
+      const root = rules([
+        ruleset({
+          selector: targetSelector,
+          rules: rules([])
+        }),
+        ruleset({
+          selector: extendSelector,
+          rules: rules([extend({ target: el('.b'), flag: ExtendFlag.All })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      const expected = tryExtendSelector(
+        targetSelector.copy(true),
+        el('.b'),
+        extendSelector.copy(true),
+        true
+      );
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe(expected.value.valueOf());
+    });
+
+    it('should apply partial extends to the outer ruleset selector when partial is true (Less `all`)', async () => {
+      const targetSelector = sellist([
+        compound([el('.replace'), el('.replace')]),
+        sel([compound([el('.c'), el('.replace')]), co('+'), el('.replace')])
+      ]);
+      const extendSelector = el('.rep_ace');
+      const outerRules = rules([
+        ruleset({
+          selector: sellist([el('.replace'), el('.c')]),
+          rules: rules([])
+        })
+      ]);
+      const root = rules([
+        ruleset({
+          selector: targetSelector,
+          rules: outerRules
+        }),
+        ruleset({
+          selector: extendSelector,
+          rules: rules([extend({ target: el('.replace'), flag: ExtendFlag.All })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const outerRuleset = evald.at(0, context) as Ruleset | undefined;
+      const nestedRuleset = outerRuleset?.get('rules')?.value?.[0];
+      const expected = tryExtendSelector(
+        targetSelector.copy(true),
+        el('.replace'),
+        extendSelector.copy(true),
+        true
+      );
+      expect(outerRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe(expected.value.valueOf());
+      // Nested selectors stay defined and keep their existing structure.
+      const nestedSel = nestedRuleset?.selector?.valueOf() ?? '';
+      expect(nestedSel).toContain('.replace');
+      expect(nestedSel).toContain('.c');
+      expect(nestedSel.length).toBeGreaterThan(0);
+    });
+
+    it('should apply multiple partial extends in sequence', async () => {
+      const targetSelector = sellist([
+        sel([el('.foo'), co(' '), el('.bar')]),
+        sel([el('.foo'), co(' '), el('.baz')])
+      ]);
+      const firstExtend = sel([el('.ext1'), co(' '), el('.ext2')]);
+      const secondExtend = pseudo({ name: ':is', arg: sellist([el('.ext3'), el('.ext4')]) });
+      const root = rules([
+        ruleset({
+          selector: targetSelector,
+          rules: rules([])
+        }),
+        ruleset({
+          selector: firstExtend,
+          rules: rules([extend({ target: el('.foo'), flag: ExtendFlag.All })])
+        }),
+        ruleset({
+          selector: secondExtend,
+          rules: rules([extend({ target: el('.foo'), flag: ExtendFlag.All })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      const output = firstRuleset?.getEffectiveSelector?.(false, context).valueOf() ?? '';
+      expect(output).toContain('.ext1 .ext2');
+      expect(output).toContain('.ext3,.ext4');
+      expect(output).toContain('.bar');
+      expect(output).toContain('.baz');
+    });
+  });
+
+  describe('shouldSkipRuleset logic', () => {
+    it('should skip extending ruleset that contains the extend as a child', async () => {
+      // .foo { extend(.foo) } only - the extend node is inside .foo, so we must not modify .foo (self-modification guard)
+      const root = rules([
+        ruleset({
+          selector: el('.foo'),
+          rules: rules([extend({ target: el('.foo') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const firstRuleset = evald.at(0, context) as Ruleset | undefined;
+      expect(firstRuleset?.getEffectiveSelector?.(false, context).valueOf()).toBe('.foo');
+    });
+  });
+
+  describe('Phase 2 iterative processing', () => {
+    it('should process extended rulesets in Phase 2', async () => {
+      const root = rules([
+        ruleset({ selector: el('.foo'), rules: rules([]) }),
+        ruleset({
+          selector: el('.bar'),
+          rules: rules([extend({ target: el('.foo') })])
+        }),
+        ruleset({
+          selector: el('.baz'),
+          rules: rules([extend({ target: el('.bar') })])
+        })
+      ]);
+      const context = new Context();
+      const evald = await root.eval(context);
+      const fooRuleset = evald.at(0, context) as Ruleset | undefined;
+      const barRuleset = evald.at(1, context) as Ruleset | undefined;
+      expect(fooRuleset?.getEffectiveSelector?.(false, context).valueOf()).toContain('.bar');
+      expect(barRuleset?.getEffectiveSelector?.(false, context).valueOf()).toContain('.baz');
+    });
+  });
+});

package/src/tree/util/__tests__/process-leading-is.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'vitest';
+import { el, sel, sellist, compound, co, pseudo, attr, PseudoSelector, amp, rules, ruleset, any } from '../../index.js';
+import { processLeadingIs } from '../process-leading-is.js';
+import { isNode } from '../is-node.js';
+import { N } from '../../node-type.js';
+import type { Selector } from '../../selector.js';
+import { Context } from '../../../context.js';
+import { F_IMPLICIT_AMPERSAND } from '../../node.js';
+
+/** PseudoSelector.create (Node.create) sets generated so processLeadingIs can unwrap. */
+function generatedIs(selector: Selector) {
+  const p = (PseudoSelector as any).create({ name: ':is', arg: selector as any });
+  expect(p.generated, 'PseudoSelector.create must set generated').toBe(true);
+  return p as ReturnType<typeof pseudo>;
+}
+
+/** Stringify processLeadingIs result for toBeString comparison */
+function out(result: Selector | Selector[]): string {
+  return Array.isArray(result) ? result.map(s => (s as Selector).valueOf()).join(', ') : (result as Selector).valueOf();
+}
+
+describe('processLeadingIs', () => {
+  describe('does not unwrap when :is is not generated', () => {
+    it('leaves non-generated :is(SelectorList) as-is', () => {
+      const list = sellist([el('.a'), el('.b')]);
+      const isPseudo = pseudo({ name: ':is', arg: list });
+      expect((isPseudo).generated).toBeFalsy();
+      const result = processLeadingIs(isPseudo);
+      expect(result).toBe(isPseudo);
+      expect(out(result as Selector)).toBeString(`:is(.a,.b)`);
+    });
+
+    it('leaves non-generated :is(simple) as-is', () => {
+      const isPseudo = pseudo({ name: ':is', arg: el('.x') });
+      const result = processLeadingIs(isPseudo);
+      expect(result).toBe(isPseudo);
+      expect(out(result as Selector)).toBeString(`:is(.x)`);
+    });
+  });
+
+  describe('single generated :is()', () => {
+    it('unwraps generated :is(simple) to the inner selector', () => {
+      const inner = el('.x');
+      const isPseudo = generatedIs(inner);
+      const result = processLeadingIs(isPseudo);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`.x`);
+    });
+
+    it('unwraps generated :is(SelectorList) at top level to SelectorList when multiple items', () => {
+      const list = sellist([el('.a'), el('.b')]);
+      const isPseudo = generatedIs(list);
+      const result = processLeadingIs(isPseudo);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`.a,.b`);
+    });
+
+    it('unwraps generated :is(SelectorList) at top level to single selector when one item', () => {
+      const list = sellist([el('.a')]);
+      const isPseudo = generatedIs(list);
+      const result = processLeadingIs(isPseudo);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`.a`);
+    });
+
+    it('returns array when inSelectorList and generated :is(SelectorList)', () => {
+      const list = sellist([el('.a'), el('.b')]);
+      const isPseudo = generatedIs(list);
+      const result = processLeadingIs(isPseudo, { inSelectorList: true });
+      expect(Array.isArray(result)).toBe(true);
+      expect(out(result as Selector[])).toBeString(`.a, .b`);
+    });
+  });
+
+  describe('SelectorList', () => {
+    it('flattens list items that are generated :is(SelectorList) when inSelectorList', () => {
+      const item1 = el('.x');
+      const item2 = generatedIs(sellist([el('.a'), el('.b')]));
+      const list = sellist([item1, item2]);
+      const result = processLeadingIs(list, { inSelectorList: false });
+      expect(out(result as Selector)).toBeString(`.x,.a,.b`);
+    });
+
+    it('returns single selector when list has one item after processing', () => {
+      const inner = el('.only');
+      const isPseudo = generatedIs(inner);
+      const list = sellist([isPseudo]);
+      const result = processLeadingIs(list);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`.only`);
+    });
+  });
+
+  describe('CompoundSelector with generated :is as first component', () => {
+    /**
+     * Same initial AST as Less/CSS parser for `* b { &[e] { } }`:
+     * - Parser: qualifiedRule → selectorList → (single) complexSelector for `* b` → [BasicSelector(*), Combinator(' '), BasicSelector(b)].
+     *   selectorList returns the single item, so ruleset.selector = ComplexSelector (not SelectorList).
+     * - Parser: inner qualifiedRule → selectorList → (single) complexSelector for `&[e]` → compoundSelector → [Ampersand, AttributeSelector(e)].
+     *   compoundSelector with 2 items returns CompoundSelector; complexSelector returns it; selectorList returns it.
+     * So we build the same: frame selector = sel([el('*'), co(' '), el('b')]) (ComplexSelector), inner = compound([amp(), attr({ name: 'e' })]) (CompoundSelector).
+     * Eval produces compound with first component :is(* b); ampersand sets .generated so processLeadingIs unwraps to * b[e].
+     */
+    it('accepts evaled &[e] with frame * b already materialized to * b[e] (same path as ruleset)', async () => {
+      const parentSelector = sel([el('*'), co(' '), el('b')]) as any;
+      const frameRuleset = ruleset({ selector: parentSelector, rules: rules([]) });
+      const innerSelector = compound([amp(), attr({ name: 'e' })]);
+      const context = new Context({ collapseNesting: true });
+      context.rulesetFrames.push(frameRuleset);
+      const evaled = await (innerSelector as any).eval(context);
+      expect(isNode(evaled, N.CompoundSelector)).toBe(true);
+      const first = (evaled as any).value[0];
+      expect(isNode(first, N.ComplexSelector)).toBe(true);
+      expect(out(evaled as Selector)).toBeString(`* b[e]`);
+      const result = processLeadingIs(evaled as Selector);
+      expect(out(result as Selector)).toBeString(`* b[e]`);
+    });
+
+    it('unwraps :is(complex) and merges suffix into last part of complex', () => {
+      const complex = sel([el('.menu'), co(' '), el('.menu')]);
+      const comp = compound([generatedIs(complex as any), el('li')]);
+      const result = processLeadingIs(comp);
+      expect(out(result as Selector)).toBeString(`.menu li.menu`);
+    });
+
+    it('unwraps :is(* b)[e] to * b[e] (complex parent + attribute suffix; css-3 nesting case)', () => {
+      const complex = sel([el('*'), co(' '), el('b')]);
+      const comp = compound([generatedIs(complex as any), attr({ name: 'e' })]);
+      const result = processLeadingIs(comp);
+      expect(out(result as Selector)).toBeString(`* b[e]`);
+    });
+
+    it('does not unwrap when :is arg is SelectorList', () => {
+      const list = sellist([el('.a'), el('.b')]);
+      const comp = compound([generatedIs(list), el('li')]);
+      const result = processLeadingIs(comp);
+      expect(result).toBe(comp);
+      expect(out(result as Selector)).toBeString(`:is(.a,.b)li`);
+    });
+  });
+
+  describe('ComplexSelector with generated :is as first visual component', () => {
+    it('unwraps :is(ComplexSelector) into complex components', () => {
+      const inner = sel([el('.menu'), co(' '), el('.menu')]);
+      const complex = sel([generatedIs(inner as any), co(' '), el('.menu'), co('>'), el('li')]);
+      const result = processLeadingIs(complex as any);
+      expect(out(result as Selector)).toBeString(`.menu .menu .menu>li`);
+    });
+
+    it('unwraps :is(simple) as first component to single selector + rest', () => {
+      const inner = el('.x');
+      const complex = sel([generatedIs(inner), co(' '), el('.y')]);
+      const result = processLeadingIs(complex as any);
+      expect(out(result as Selector)).toBeString(`.x .y`);
+    });
+
+    it('does not unwrap when :is arg is SelectorList', () => {
+      const list = sellist([el('.a'), el('.b')]);
+      const complex = sel([generatedIs(list), co(' '), el('.y')]);
+      const result = processLeadingIs(complex as any);
+      expect(result).toBe(complex);
+      expect(out(result as Selector)).toBeString(`:is(.a,.b) .y`);
+    });
+  });
+
+  describe('implicit ampersand + generated :is(SelectorList)', () => {
+    it('unwraps to selector list when shape is implicit-& + generated :is(list)', () => {
+      const ampNode = amp({ selectorContainer: { selector: el('.base') } });
+      (ampNode as any).addFlag(F_IMPLICIT_AMPERSAND);
+      const listArg = sellist([
+        sel([el('.base'), co(' '), el('.x')]),
+        sel([el('.base'), co(' '), el('.y')])
+      ]);
+      const selector = sel([ampNode, co(' '), generatedIs(listArg)]);
+      const result = processLeadingIs(selector as any);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`.x,.y`);
+    });
+
+    it('removes generated :is(list) wrapper in non-header special case', () => {
+      const ampNode = amp({ selectorContainer: { selector: el('.base') } });
+      (ampNode as any).addFlag(F_IMPLICIT_AMPERSAND);
+      const listArg = sellist([
+        sel([el('.base'), co(' '), el('.x')]),
+        sel([el('.base'), co(' '), el('.y')])
+      ]);
+      const selector = sel([ampNode, co(' '), generatedIs(listArg), co(' '), el('.tail')]);
+      const result = processLeadingIs(selector as any);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).not.toContain(':is(');
+      expect(out(result as Selector)).toContain('.tail');
+    });
+  });
+
+  describe('does not recurse into pseudo args', () => {
+    it('unwraps outer generated :is once; inner :is is returned as arg (not recursively unwrapped)', () => {
+      const innerIs = pseudo({ name: ':is', arg: el('.inner') });
+      innerIs.generated = true;
+      const outer = generatedIs(innerIs);
+      const result = processLeadingIs(outer);
+      expect(Array.isArray(result)).toBe(false);
+      expect(out(result as Selector)).toBeString(`:is(.inner)`);
+    });
+  });
+});

package/src/tree/util/__tests__/recursion-helper.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { CallMap } from '../recursion-helper.js';
+import { call, list, num, ref } from '../../index.js';
+
+describe('CallMap', () => {
+  describe('add', () => {
+    it('should return true when the same call is added twice with undefined', () => {
+      const callMap = new CallMap();
+      const call1 = call({
+        name: ref('mixin'),
+        args: undefined
+      });
+
+      // First call with undefined - should return false
+      expect(callMap.add(call1, undefined)).toBe(false);
+
+      // Second call with undefined - should return true
+      expect(callMap.add(call1, undefined)).toBe(true);
+    });
+
+    it('should return false when different calls are added with undefined', () => {
+      const callMap = new CallMap();
+      const call1 = call({
+        name: ref('mixin1'),
+        args: undefined
+      });
+      const call2 = call({
+        name: ref('mixin2'),
+        args: undefined
+      });
+
+      // First call with undefined
+      expect(callMap.add(call1, undefined)).toBe(false);
+
+      // Different call with undefined - should return false
+      expect(callMap.add(call2, undefined)).toBe(false);
+    });
+
+    it('should return true when the same call is added twice with the same list instance', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // First call with list1
+      expect(callMap.add(call1, list1)).toBe(false);
+
+      // Second call with same list instance - should return true
+      expect(callMap.add(call1, list1)).toBe(true);
+    });
+
+    it('should return true when the same call is added with identical lists (different instances)', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const list2 = list([num(1), num(2)]); // Same content, different instance
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // First call with list1
+      expect(callMap.add(call1, list1)).toBe(false);
+
+      // Second call with list2 (different instance, same value) - should return true
+      expect(callMap.add(call1, list2)).toBe(true);
+    });
+
+    it('should return false when the same call is added with different lists', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const list2 = list([num(3), num(4)]); // Different content
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // First call with list1
+      expect(callMap.add(call1, list1)).toBe(false);
+
+      // Second call with list2 (different content) - should return false
+      expect(callMap.add(call1, list2)).toBe(false);
+    });
+
+    it('should prevent a call from calling itself with the same params', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // First call - should return false
+      expect(callMap.add(call1, list1)).toBe(false);
+
+      // Same call with same params - should return true (recursion detected)
+      expect(callMap.add(call1, list1)).toBe(true);
+    });
+
+    it('should prevent different calls from calling each other with the same params', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const call1 = call({
+        name: ref('mixin1'),
+        args: list1.get('value') as any
+      });
+      const call2 = call({
+        name: ref('mixin2'),
+        args: list1.get('value') as any
+      });
+
+      // First call with list1
+      expect(callMap.add(call1, list1)).toBe(false);
+
+      // Different call with same params - should return false
+      // (each call tracks its own args separately)
+      expect(callMap.add(call2, list1)).toBe(false);
+
+      // But if call2 calls itself with same params, it should return true
+      expect(callMap.add(call2, list1)).toBe(true);
+    });
+  });
+
+  describe('delete', () => {
+    it('should remove the last entry for a call', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // Add once - this adds the entry to the set
+      callMap.add(call1, list1);
+
+      // Add again - this checks but doesn't add (only one entry exists)
+      expect(callMap.add(call1, list1)).toBe(true);
+
+      // Delete once - removes the only entry
+      expect(callMap.delete(call1)).toBe(true);
+
+      // Now should return false (no entries)
+      expect(callMap.add(call1, list1)).toBe(false);
+    });
+
+    it('should handle multiple entries for a call', () => {
+      const callMap = new CallMap();
+      const list1 = list([num(1), num(2)]);
+      const list2 = list([num(3), num(4)]);
+      const call1 = call({
+        name: ref('mixin'),
+        args: list1.get('value') as any
+      });
+
+      // Add first list
+      callMap.add(call1, list1);
+
+      // Manually add second list to the set (simulating multiple calls)
+      // Note: The current implementation doesn't add new args on subsequent calls,
+      // so we need to test the delete behavior with multiple entries differently
+      const set = (callMap as any)._callMap.get(call1);
+      if (set) {
+        set.push(list2);
+      }
+
+      // Delete once - should remove the last entry (list2)
+      expect(callMap.delete(call1)).toBe(true);
+
+      // Should still return true for list1
+      expect(callMap.add(call1, list1)).toBe(true);
+    });
+
+    it('should return false when deleting a non-existent call', () => {
+      const callMap = new CallMap();
+      const call1 = call({
+        name: ref('mixin'),
+        args: undefined
+      });
+
+      expect(callMap.delete(call1)).toBe(false);
+    });
+  });
+});