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

package/src/tree/__tests__/node-mutation.test.ts

@@ -0,0 +1,182 @@
+import { any, seq, decl } from '../index.js';
+import { Context } from '../../context.js';
+import { el } from '../selector-basic.js';
+import { CompoundSelector } from '../selector-compound.js';
+import { SelectorList } from '../selector-list.js';
+
+let context: Context;
+
+describe('Node mutation methods', () => {
+  beforeEach(() => {
+    context = new Context();
+  });
+
+  describe('setValue with index', () => {
+    it('sets parent on the new child node', () => {
+      const a = any('a');
+      const b = any('b');
+      const s = seq([a]);
+      s.setData(0, b);
+      expect(b.parent).toBe(s);
+    });
+
+    it('replaces the element at the given index', () => {
+      const a = any('a');
+      const b = any('b');
+      const s = seq([a]);
+      s.setData(0, b);
+      expect(s.get('value')[0]).toBe(b);
+    });
+  });
+
+  describe('setValue with named key', () => {
+    it('sets parent on the new child node', () => {
+      const name = any('color', { role: 'property' });
+      const value = any('red');
+      const newValue = any('blue');
+      const d = decl({ name, value });
+      d.setData('value', newValue);
+      expect(newValue.parent).toBe(d);
+    });
+  });
+
+  describe('push', () => {
+    it('sets parent on pushed nodes', () => {
+      const a = any('a');
+      const b = any('b');
+      const s = seq([a]);
+      s.push(b);
+      expect(b.parent).toBe(s);
+      expect(s.get('value').length).toBe(2);
+      expect(s.get('value')[1]).toBe(b);
+    });
+
+    it('sets parent on multiple pushed nodes', () => {
+      const a = any('a');
+      const b = any('b');
+      const c = any('c');
+      const s = seq([]);
+      s.push(a, b, c);
+      expect(a.parent).toBe(s);
+      expect(b.parent).toBe(s);
+      expect(c.parent).toBe(s);
+    });
+  });
+
+  describe('unshift', () => {
+    it('sets parent on prepended nodes', () => {
+      const a = any('a');
+      const b = any('b');
+      const s = seq([b]);
+      (s as any).unshift(a);
+      expect(a.parent).toBe(s);
+      expect(s.get('value')[0]).toBe(a);
+      expect(s.get('value')[1]).toBe(b);
+    });
+  });
+
+  describe('splice', () => {
+    it('sets parent on inserted nodes', () => {
+      const a = any('a');
+      const b = any('b');
+      const c = any('c');
+      const s = seq([a, c]);
+      (s as any).splice(1, 0, b);
+      expect(b.parent).toBe(s);
+      expect(s.get('value')[1]).toBe(b);
+    });
+
+    it('returns removed nodes', () => {
+      const a = any('a');
+      const b = any('b');
+      const s = seq([a, b]);
+      const removed = (s as any).splice(0, 1);
+      expect(removed).toEqual([a]);
+      expect(s.get('value').length).toBe(1);
+    });
+  });
+
+  describe('valueOf invalidation', () => {
+    it('recomputes valueOf after setValue by index', () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([a]);
+      expect(compound.valueOf()).toBe('.a');
+      compound.setData(0, b);
+      expect(compound.valueOf()).toBe('.b');
+    });
+
+    it('recomputes valueOf after push', () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([a]);
+      expect(compound.valueOf()).toBe('.a');
+      compound.push(b);
+      expect(compound.valueOf()).toBe('.a.b');
+    });
+
+    it('recomputes valueOf after splice', () => {
+      const a = el('.a');
+      const b = el('.b');
+      const c = el('.c');
+      const compound = (CompoundSelector as any).create([a, b, c]);
+      expect(compound.valueOf()).toBe('.a.b.c');
+      (compound as any).splice(1, 1);
+      expect(compound.valueOf()).toBe('.a.c');
+    });
+
+    it('recomputes valueOf after unshift', () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([b]);
+      expect(compound.valueOf()).toBe('.b');
+      (compound as any).unshift(a);
+      expect(compound.valueOf()).toBe('.a.b');
+    });
+  });
+
+  describe('keySet invalidation', () => {
+    it('recomputes keySet after setValue by index', async () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([a]);
+      await compound.eval(context);
+      await b.eval(context);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.a']))).toBe(true);
+      compound.setData(0, b);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.b']))).toBe(true);
+    });
+
+    it('recomputes keySet after push', async () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([a]);
+      await compound.eval(context);
+      await b.eval(context);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.a']))).toBe(true);
+      compound.push(b);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.a', '.b']))).toBe(true);
+    });
+
+    it('recomputes keySet after splice removal', async () => {
+      const a = el('.a');
+      const b = el('.b');
+      const compound = (CompoundSelector as any).create([a, b]);
+      await compound.eval(context);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.a', '.b']))).toBe(true);
+      (compound as any).splice(0, 1);
+      expect(compound.keySet.equals(context.selectorBits.getBitset(['.b']))).toBe(true);
+    });
+
+    it('recomputes keySet on SelectorList after push', async () => {
+      const a = el('.a');
+      const b = el('.b');
+      const list = (SelectorList as any).create([a]);
+      await list.eval(context);
+      await b.eval(context);
+      expect(list.keySet.equals(context.selectorBits.getBitset(['.a']))).toBe(true);
+      list.push(b);
+      expect(list.keySet.equals(context.selectorBits.getBitset(['.a', '.b']))).toBe(true);
+    });
+  });
+});

package/src/tree/__tests__/operation.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { any, expr, op } from '../index.js';
+import { Context } from '../../context.js';
+
+describe('Operation', () => {
+  it('evaluates child expressions before serialization when the operation is preserved', async () => {
+    const context = new Context();
+    const node = op([
+      expr(any('foo')),
+      '/',
+      expr(any('bar'))
+    ]);
+
+    const evald = await node.eval(context);
+
+    expect(evald.toTrimmedString({ context })).toBe('foo / bar');
+  });
+});

package/src/tree/__tests__/paren.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import { any, paren, ref, rules, vardecl } from '../index.js';
+import { Context } from '../../context.js';
+import { addEdge, getEdge } from '../util/cursor.js';
+import type { RenderKey } from '../node.js';
+
+describe('Paren', () => {
+  it('serializes wrapped values on the public render path', () => {
+    const node = paren(any('red'));
+
+    expect(node.toTrimmedString()).toBe('(red)');
+  });
+
+  it('reads a cloned value without changing canonical render output', () => {
+    const ctx = new Context();
+    const node = paren(any('red'));
+    const clonedNode = node.clone();
+    const patchedValue = any('blue');
+
+    clonedNode.adopt(patchedValue, ctx);
+    (clonedNode as unknown as { value: ReturnType<typeof any> }).value = patchedValue;
+
+    expect(clonedNode.toTrimmedString({ context: ctx })).toBe('(blue)');
+    expect(node.toTrimmedString()).toBe('(red)');
+  });
+
+  it('reads a cloned escaped option without changing canonical render output', () => {
+    const ctx = new Context();
+    const node = paren(any('red'));
+    const clonedNode = node.clone();
+
+    clonedNode.options = { escaped: true };
+
+    expect(clonedNode.toTrimmedString({ context: ctx })).toBe('~(red)');
+    expect(node.toTrimmedString()).toBe('(red)');
+  });
+
+  it('evals without overwriting the canonical child when the wrapper is preserved', async () => {
+    const ctx = new Context();
+    const original = ref({ key: 'color' }, { type: 'variable' });
+    const root = rules([
+      vardecl({ name: 'color', value: any('red') })
+    ]);
+    const node = paren(original);
+    ctx.root = root;
+    ctx.rulesContext = root;
+
+    const evald = await node.eval(ctx);
+
+    expect(evald.toTrimmedString({ context: ctx })).toBe('(red)');
+    expect(node.get('value')).toBe(original);
+    expect(node.toTrimmedString()).toBe('($color)');
+  });
+
+  it('eval uses a cloned escaped option without mutating canonical wrapper behavior', async () => {
+    const ctx = new Context();
+    const original = ref({ key: 'color' }, { type: 'variable' });
+    const root = rules([
+      vardecl({ name: 'color', value: any('red') })
+    ]);
+    const node = paren(original);
+    const clonedNode = node.clone();
+    ctx.root = root;
+    ctx.rulesContext = root;
+
+    clonedNode.options = { escaped: true };
+
+    const evald = await clonedNode.eval(ctx);
+
+    expect(evald.toTrimmedString({ context: ctx })).toBe('red');
+    expect(node.get('value')).toBe(original);
+    expect(clonedNode.toTrimmedString({ context: ctx })).toBe('~($color)');
+    expect(node.toTrimmedString()).toBe('($color)');
+  });
+
+  it('reads a singular child through the cursor model', () => {
+    const canonical = any('red');
+    const alternate = any('blue');
+    const node = paren(canonical);
+    const key = {} as RenderKey;
+    const cursor = { node, renderKey: key };
+
+    expect(getEdge(cursor, 'value')?.node).toBe(canonical);
+
+    addEdge(node, 'value', key, alternate);
+
+    expect(getEdge(cursor, 'value')?.node).toBe(alternate);
+    expect(node.value).toBe(canonical);
+  });
+});

package/src/tree/__tests__/preserve-mode-output.test.ts

@@ -0,0 +1,50 @@
+import { describe, it } from 'vitest';
+import { dimension, num, op } from '..';
+import { Context } from '../../context.js';
+
+describe('Preserve Mode Output Examples', () => {
+  const context = new Context();
+  context.opts.unitMode = 'preserve';
+
+  it('shows actual calc() output for various operations', async () => {
+    // Adding incompatible units
+    const addOp = op([dimension([10, 'px']), '+', dimension([2, 'rem'])]);
+    const addResult = await addOp.eval(context);
+    console.log('10px + 2rem =', addResult.toString());
+
+    // Dividing a number by a unit
+    const divOp = op([num(10), '/', dimension([2, 'px'])]);
+    const divResult = await divOp.eval(context);
+    console.log('10 / 2px =', divResult.toString());
+
+    // Multiplying double units
+    const multOp = op([dimension([10, 'px']), '*', dimension([2, 'px'])]);
+    const multResult = await multOp.eval(context);
+    console.log('10px * 2px =', multResult.toString());
+
+    // Dividing incompatible units
+    const divIncompatOp = op([dimension([10, 'px']), '/', dimension([2, 's'])]);
+    const divIncompatResult = await divIncompatOp.eval(context);
+    console.log('10px / 2s =', divIncompatResult.toString());
+
+    // Multiplying incompatible units
+    const multIncompatOp = op([dimension([10, 'px']), '*', dimension([2, 'em'])]);
+    const multIncompatResult = await multIncompatOp.eval(context);
+    console.log('10px * 2em =', multIncompatResult.toString());
+
+    // Compatible units multiplication (same group, different units)
+    const multCompatOp = op([dimension([10, 'px']), '*', dimension([2, 'cm'])]);
+    const multCompatResult = await multCompatOp.eval(context);
+    console.log('10px * 2cm =', multCompatResult.toString());
+
+    // Compatible units division (same group, different units)
+    const divCompatOp = op([dimension([10, 'px']), '/', dimension([2, 'cm'])]);
+    const divCompatResult = await divCompatOp.eval(context);
+    console.log('10px / 2cm =', divCompatResult.toString());
+
+    // Same units division (should cancel)
+    const sameDivOp = op([dimension([10, 'px']), '/', dimension([2, 'px'])]);
+    const sameDivResult = await sameDivOp.eval(context);
+    console.log('10px / 2px =', sameDivResult.toString(), '(units cancel)');
+  });
+});

package/src/tree/__tests__/quoted.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { any, expr, interpolated, quoted } from '../index.js';
+import { Context } from '../../context.js';
+import { addEdge, getEdge } from '../util/cursor.js';
+import type { RenderKey } from '../node.js';
+
+describe('Quoted', () => {
+  it('serializes a quoted string', () => {
+    const node = quoted('red');
+
+    expect(node.toTrimmedString()).toBe('"red"');
+  });
+
+  it('evaluates to a materialized quoted node without mutating the canonical node', async () => {
+    const context = new Context();
+    const node = quoted(interpolated({
+      source: '%%',
+      replacements: [expr(any('blue'))]
+    }));
+
+    const evald = await node.eval(context);
+
+    expect(evald.toTrimmedString({ context })).toBe('"blue"');
+    expect(node.toTrimmedString()).toBe('"$(blue)"');
+    expect(node.get('value')).toBeTypeOf('object');
+    expect(node.get('value')).not.toBe('blue');
+  });
+
+  it('keeps the canonical root unchanged when eval returns a derived quoted node', async () => {
+    const context = new Context();
+    const node = quoted(interpolated({
+      source: '%%',
+      replacements: [expr(any('blue'))]
+    }));
+
+    const evald = await node.eval(context);
+
+    expect(evald).not.toBe(node);
+    expect(evald.toTrimmedString({ context })).toBe('"blue"');
+    expect(node.toTrimmedString()).toBe('"$(blue)"');
+    expect(node.toTrimmedString({ context })).toBe('"$(blue)"');
+    expect(node.get('value')).toBeTypeOf('object');
+    expect(node.get('value')).not.toBe('blue');
+  });
+
+  it('keeps valueOf() canonical on the original node', () => {
+    const node = quoted('red');
+    expect(node.valueOf()).toBe('red');
+  });
+
+  it('keeps compare() canonical on the original node', () => {
+    const left = quoted('red');
+    const right = quoted('red');
+    expect(left.compare(right)).toBe(0);
+  });
+
+  it('reads a render-key alternate child without mutating the canonical value', () => {
+    const canonical = expr(any('blue'));
+    const alternate = expr(any('green'));
+    const node = quoted(canonical);
+    const key = {} as RenderKey;
+    const cursor = { node, renderKey: key };
+
+    expect(node.value).toBe(canonical);
+    expect(getEdge(cursor, 'value')?.node).toBe(canonical);
+
+    addEdge(node, 'value', key, alternate);
+
+    expect(getEdge(cursor, 'value')?.node).toBe(alternate);
+    expect(node.value).toBe(canonical);
+  });
+});

package/src/tree/__tests__/range.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { any, range } from '../index.js';
+import { Context } from '../../context.js';
+
+describe('Range', () => {
+  it('serializes inclusive and exclusive bounds', () => {
+    const node = range(
+      { start: any('1'), end: any('3'), step: any('2') },
+      { includeStart: false, includeEnd: false }
+    );
+
+    expect(node.toTrimmedString()).toBe('1> to <3 step 2');
+  });
+
+  it('reads cloned bounds without mutating the canonical node', () => {
+    const context = new Context();
+    const node = range(
+      { start: any('1'), end: any('3'), step: any('2') },
+      { includeEnd: false }
+    );
+    const clonedNode = node.clone();
+    const start = any('2');
+    const end = any('4');
+    const step = any('3');
+
+    clonedNode.adopt(start, context);
+    clonedNode.adopt(end, context);
+    clonedNode.adopt(step, context);
+    (clonedNode as unknown as { start: ReturnType<typeof any> }).start = start;
+    (clonedNode as unknown as { end: ReturnType<typeof any> }).end = end;
+    (clonedNode as unknown as { step: ReturnType<typeof any> }).step = step;
+
+    expect(clonedNode.toTrimmedString({ context })).toBe('2 to <4 step 3');
+    expect(node.toTrimmedString()).toBe('1 to <3 step 2');
+    expect(node.get('start').toTrimmedString()).toBe('1');
+    expect(node.get('end').toTrimmedString()).toBe('3');
+    expect(node.get('step')?.toTrimmedString()).toBe('2');
+  });
+
+  it('does not materialize cloned bounds during eval', async () => {
+    const context = new Context();
+    const node = range(
+      { start: any('1'), end: any('3') },
+      { includeEnd: false }
+    );
+    const clonedNode = node.clone();
+    const start = any('9');
+
+    clonedNode.adopt(start, context);
+    (clonedNode as unknown as { start: ReturnType<typeof any> }).start = start;
+
+    const evald = await clonedNode.eval(context);
+
+    expect(evald.toTrimmedString()).toBe('9 to <3');
+    expect(clonedNode.toTrimmedString({ context })).toBe('9 to <3');
+    expect(node.toTrimmedString()).toBe('1 to <3');
+    expect(node.get('start').toTrimmedString()).toBe('1');
+  });
+});