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

package/src/tree/util/__tests__/sourcemap.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import { OutputWriter, getPrintOptions } from '../print.js';
+import { buildSourceMap } from '../sourcemap.js';
+import { rules, decl, any, ruleset, sellist, sel, el } from '../../index.js';
+
+describe('source map segments', () => {
+  it('collects segments for simple declaration', () => {
+    const w = new OutputWriter();
+    const root = rules([
+      decl({ name: any('color'), value: any('red') })
+    ]);
+    // fake location & file for mapping
+    (root.value[0] as any)._location = [0, 1, 1, 0, 1, 6];
+    (root as any).treeContext.file = { name: 'root.jess', path: '.', fullPath: '/abs/root.jess' };
+    const css = root.toString(getPrintOptions({ writer: w }));
+    expect(css).toBe('color: red;\n');
+    const segs = w.getSegments();
+    // Should have at least one segment at start
+    expect(segs[0]?.genLine).toBe(0);
+    expect(segs[0]?.genColumn).toBe(0);
+  });
+
+  it('maps nested rules content lines', () => {
+    const w = new OutputWriter();
+    const nested = rules([
+      ruleset({
+        selector: sellist([sel([el('.a')])]),
+        rules: rules([
+          decl({ name: any('x'), value: any('y') })
+        ])
+      })
+    ]);
+    // attach fake locations and files
+    const rs = (nested.value[0] as any).rules;
+    (rs.value[0] as any)._location = [0, 1, 3, 0, 1, 8];
+    (nested as any).treeContext.file = { name: 'nested.jess', path: '.', fullPath: '/abs/nested.jess' };
+    const css = nested.toString(getPrintOptions({ writer: w }));
+    expect(css).toBe('.a {\n  x: y;\n}\n');
+    const segs = w.getSegments();
+    // Segment should exist on the generated line containing "x: y;"
+    const lines = css.split('\n');
+    const lineIdx = lines.findIndex(l => l.includes('x: y;'));
+    const hasInnerLine = segs.some(s => s.genLine === lineIdx);
+    expect(hasInnerLine, `expected a segment on generated line ${lineIdx}`).toBe(true);
+    const map = buildSourceMap(w, { file: 'out.css' });
+    expect(map.version).toBe(3);
+    expect(map.file).toBe('out.css');
+    expect(Array.isArray(map.sources)).toBe(true);
+    expect(typeof map.mappings).toBe('string');
+  });
+
+  it('writer line/column advance for newlines between rules', () => {
+    const w = new OutputWriter();
+    const a = decl({ name: any('a'), value: any('1') });
+    a.post = ['\n\n\n'];
+    const b = decl({ name: any('b'), value: any('2') });
+    // Attach fake locations so segments are recorded (orig lines are 1-based here)
+    a._location = [0, 1, 1, 0, 1, 5];   // original line 1 (0-based 0)
+    b._location = [0, 4, 1, 0, 4, 5];   // original line 2 (0-based 1)
+    const root = rules([a, b]);
+    const css = root.toString(getPrintOptions({ writer: w }));
+    expect(css).toBe('a: 1;\n' + 'b: 2;\n');
+    // After first declaration 'a: 1;', writer should have advanced one line on the newline
+    // Find index of newline and validate writer's internal line/column
+    const idx = css.indexOf('\n');
+    expect(idx).toBeGreaterThan(0);
+    // Simulate writer state by splitting lines
+    const lines = css.split('\n');
+    // Current serializer emits trailing newline for root rules output
+    expect(css.endsWith('\n')).toBe(true);
+    // First and second lines are correct
+    expect(lines[0]).toBe('a: 1;');
+    expect(lines[1]).toBe('b: 2;');
+
+    // Confirm that a segment exists at the generated start of 'b: 2;'
+    const segs = w.getSegments();
+    // Assert segment for 'a' is on generated line 0 and maps to original line 0
+    const aLineIdx = 0;
+    const aColIdx = lines[aLineIdx]!.indexOf('a');
+    const aSeg = segs.find(s => s.genLine === aLineIdx && s.genColumn === aColIdx);
+    expect(aSeg && aSeg.origLine === 0).toBe(true);
+
+    // Assert segment for 'b' is on generated line 1 but maps to original line 3 (line 4 in 1-based),
+    // because we compressed three newlines in serialization
+    const bLineIdx = 1; // generated is 0-based: second line
+    const bColIdx = lines[bLineIdx]!.indexOf('b');
+    const bSeg = segs.find(s => s.genLine === bLineIdx && s.genColumn === bColIdx);
+    expect(bSeg && bSeg.origLine === 3).toBe(true);
+    expect(bSeg?.genLine).toBe(1);
+  });
+
+  it('combines segments from different trees (files)', () => {
+    const w = new OutputWriter();
+    const left = rules([
+      decl({ name: any('a'), value: any('1') })
+    ]);
+    // attach file+location to the declaration itself so segments carry sources
+    (left.value[0] as any).treeContext.file = { name: 'left.jess', path: '.', fullPath: '/abs/left.jess' };
+    (left.value[0] as any)._location = [0, 1, 1, 0, 1, 5];
+
+    const right = rules([
+      decl({ name: any('b'), value: any('2') })
+    ]);
+    (right.value[0] as any).treeContext.file = { name: 'right.jess', path: '.', fullPath: '/abs/right.jess' };
+    (right.value[0] as any)._location = [0, 1, 1, 0, 1, 5];
+
+    const root = rules([left, right]);
+    const css = root.toString(getPrintOptions({ writer: w }));
+    expect(css).toBe('a: 1;' + '\n' + 'b: 2;\n');
+
+    const map = buildSourceMap(w, { file: 'out.css' });
+    expect(map.version).toBe(3);
+    const srcs = map.sources.filter((s): s is string => typeof s === 'string');
+    expect(srcs.some(s => s.includes('left.jess'))).toBe(true);
+    expect(srcs.some(s => s.includes('right.jess'))).toBe(true);
+  });
+});

package/src/tree/util/ampersand-template.ts

@@ -0,0 +1,9 @@
+/**
+ * Selector-like ampersand template payloads.
+ *
+ * Supports:
+ * - suffix/prefix forms like `-1`, `.foo`, `b`
+ * - explicit insertion templates containing `&`
+ * - selector-ish fragments, but reserves `nil` for `&(nil)`
+ */
+export const AMPERSAND_TEMPLATE_CONTENTS_REGEX = /(?:[.#\w\u0080-\uffff-]|\d)(?:[.#\w\u0080-\uffff-]|&)*|(?:[.#\w\u0080-\uffff-]|&)*&(?:[.#\w\u0080-\uffff-]|&)*/;

package/src/tree/util/bitset.ts

@@ -0,0 +1,194 @@
+import { default as OriginalBitSet } from 'bitset';
+
+export class BitSet<T = unknown> extends OriginalBitSet {
+  _library: BitSetLibrary<T> | undefined;
+
+  override or(other: BitSet<T>): BitSet<T> {
+    let set = super.or(other) as BitSet<T>;
+    set._library = this._library;
+    return set;
+  }
+
+  override clone(): BitSet<T> {
+    let set: any = new BitSet<T>();
+    /**
+     * Clone like the regular bitset does but preserve this as the constructor.
+     * Otherwise cloned objects won't preserve the library reference.
+     */
+    set.data = (this as any).data.slice();
+    set._ = (this as any)._;
+    set._library = this._library;
+    return set;
+  }
+
+  override and(other: BitSet<T>): BitSet<T> {
+    let set = super.and(other) as BitSet<T>;
+    set._library = this._library;
+    return set;
+  }
+
+  override xor(other: BitSet<T>): BitSet<T> {
+    let set = super.xor(other) as BitSet<T>;
+    set._library = this._library;
+    return set;
+  }
+
+  override not(): BitSet<T> {
+    let set = super.not() as BitSet<T>;
+    set._library = this._library;
+    return set;
+  }
+}
+
+export class BitSetLibrary<T = unknown> {
+  private _bitset: BitSet<T>;
+  /** Value to Bitset position map */
+  private _values = new Map<T, number>();
+  /** Bitset position to value map */
+  private _positions: T[] = [];
+
+  constructor(values?: T[]) {
+    this._bitset = new BitSet();
+    this._bitset._library = this;
+    if (values) {
+      for (let i = 0; i < values.length; i++) {
+        this._values.set(values[i]!, i);
+        this._bitset.set(i, 0);
+      }
+    }
+  }
+
+  get size() {
+    return this._values.size;
+  }
+
+  /** Returns position */
+  add(value: T): number {
+    let values = this._values;
+    let pos = values.get(value);
+    if (pos !== undefined) {
+      return pos;
+    }
+    pos = this.size;
+    values.set(value, pos);
+    this._positions[pos] = value;
+    this._bitset.set(pos, 0);
+    return pos;
+  }
+
+  has(value: T) {
+    return this._values.has(value);
+  }
+
+  /** Get Bitset from an iterable of values */
+  getBitset(values?: Iterable<T>): BitSet<T> {
+    let bitset = this._bitset.clone();
+    if (values) {
+      for (const value of values) {
+        let pos = this.add(value);
+        bitset.set(pos, 1);
+      }
+    }
+    return bitset;
+  }
+
+  getValue(position: number): T | undefined {
+    return this._positions[position];
+  }
+
+  hasBit(bitset: BitSet<T>, value: T): boolean {
+    if (bitset._library !== this) {
+      throw new Error('Bitset must be from this library');
+    }
+    const pos = this._values.get(value);
+    return pos !== undefined ? Boolean(bitset.get(pos)) : false;
+  }
+
+  forEachValue(bitset: BitSet<T>, fn: (value: T, position: number) => void): void {
+    if (bitset._library !== this) {
+      throw new Error('Bitset must be from this library');
+    }
+
+    const data = (bitset as { data?: number[] }).data;
+    if (!data) {
+      return;
+    }
+
+    for (let wordIndex = 0; wordIndex < data.length; wordIndex++) {
+      let word = data[wordIndex]! >>> 0;
+      while (word !== 0) {
+        const lowestBit = word & -word;
+        const bitIndex = 31 - Math.clz32(lowestBit);
+        const position = (wordIndex * 32) + bitIndex;
+        const value = this._positions[position];
+        if (value !== undefined) {
+          fn(value, position);
+        }
+        word &= word - 1;
+      }
+    }
+  }
+
+  valuesOf(bitset: BitSet<T>): T[] {
+    const values: T[] = [];
+    this.forEachValue(bitset, (value) => {
+      values.push(value);
+    });
+    return values;
+  }
+}
+
+/**
+ * All bits in a that are true must be true in b
+*/
+export function isSubsetOf(a: BitSet, b: BitSet): boolean {
+  if (a._library !== b._library) {
+    throw new Error('Bitsets must be from the same library');
+  }
+
+  const aInternal = a as { data?: number[]; _?: number };
+  const bInternal = b as { data?: number[]; _?: number };
+  if (aInternal._ || bInternal._) {
+    return a.and(b).equals(a);
+  }
+
+  const aData = aInternal.data;
+  const bData = bInternal.data;
+  if (!aData) {
+    return true;
+  }
+
+  for (let i = 0; i < aData.length; i++) {
+    const aWord = aData[i] ?? 0;
+    if (!aWord) {
+      continue;
+    }
+
+    const bWord = bData?.[i] ?? 0;
+    if ((aWord & ~bWord) !== 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/** True when `a` and `b` share no set bits. */
+export function isDisjoint(a: BitSet, b: BitSet): boolean {
+  if (a._library !== b._library) {
+    throw new Error('Bitsets must be from the same library');
+  }
+  const intersection = a.and(b) as BitSet;
+  const data = (intersection as { data?: number[] }).data;
+  if (!data) {
+    return true;
+  }
+
+  for (let i = 0; i < data.length; i++) {
+    if (data[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/tree/util/calculate.ts

@@ -0,0 +1,11 @@
+export type Operator = '+' | '-' | '*' | '/' | '%';
+
+export function calculate(a: number, op: Operator, b: number) {
+  switch (op) {
+    case '+': return a + b;
+    case '-': return a - b;
+    case '*': return a * b;
+    case '/': return a / b;
+    case '%': return a % b;
+  }
+}

package/src/tree/util/cast.ts

@@ -0,0 +1,89 @@
+import type { Node } from '../node.js';
+import { Nil } from '../nil.js';
+import { List } from '../list.js';
+// Dimension and Num are NOT imported here to break circular dependency:
+// dimension.ts → color.ts → call.ts → cast.ts → dimension.ts
+// Instead, we use createRequire to access them synchronously at runtime
+import { Any } from '../any.js';
+import { Color } from '../color.js';
+import { JsFunction } from '../js-function.js';
+import { JsObject } from '../js-object.js';
+import { Bool } from '../bool.js';
+import { isNode } from './is-node.js';
+import { isPlainObject } from './collections.js';
+import { createRequire } from 'node:module';
+
+const { isArray } = Array;
+
+// Create a synchronous require function for ES modules
+const require = createRequire(import.meta.url);
+
+// Lazy getters for Dimension and Num to break circular dependency
+// These use require() to access modules at runtime, not at module load time
+// By the time cast() is called, dimension.ts and number.ts will be fully loaded
+function getDimension() {
+  // Use require() to access module at runtime - breaks circular dependency at module load time
+  return require('../dimension.js').Dimension;
+}
+
+function getNum() {
+  // Use require() to access module at runtime - breaks circular dependency at module load time
+  return require('../number.js').Num;
+}
+
+function getNodeType(value: any): Node {
+  if (isNode(value)) {
+    return value;
+  }
+  if (value === undefined || value === null) {
+    return new Nil();
+  }
+  if (typeof value === 'boolean') {
+    return new Bool(value);
+  }
+  if (typeof value === 'function') {
+    // Hmm, the LLM added this, is it needed?
+    // Preserve function options (e.g., params metadata from getFunctionFromMixins)
+    const options = (value as Function & { options?: Record<string, unknown> }).options;
+    return new JsFunction(value, options);
+  }
+  if (isPlainObject(value)) {
+    return new JsObject(value);
+  }
+  if (isArray(value)) {
+    return new List(value.map(val => cast(val)));
+  }
+  if (value.constructor === Number) {
+    const Num = getNum();
+    return new Num(value as unknown as number);
+  }
+  if (typeof value === 'string') {
+    if (value.startsWith('#')) {
+      return new Color(value);
+    } else {
+      let result = value.match(/^(\d*(?:\.\d+))([a-z]*)$/i);
+      if (result) {
+        const Dimension = getDimension();
+        return new Dimension({ number: parseFloat(result[1]!), unit: result[2] });
+      }
+    }
+  }
+  return new Any(value.toString());
+}
+
+/**
+ * Casts a primitive JavaScript value to a Jess node
+ * (if not already).
+ *
+ * @example
+ * cast(area(5))
+ */
+export function cast(value: any): Node {
+  const node = getNodeType(value);
+  /**
+   * If converting from a primitive, then
+   * the value should be considered evaluated.
+   */
+  // Cast from primitive — F_STATIC on Any/Num/etc prevents re-eval.
+  return node;
+}

package/src/tree/util/cloning.ts

@@ -0,0 +1,8 @@
+import type { Node } from '../node-base.js';
+
+/** Cloning functions */
+export function freezeChildren(node: Node) {
+  let n = node.clone(true);
+  n.frozen = true;
+  return n;
+};