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

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

@@ -0,0 +1,142 @@
+import { BitSetLibrary, isSubsetOf } from '../bitset.js';
+import { compound, el, sel, pseudo, co, num, type ComplexSelector } from '../../index.js';
+import { Context } from '../../../context.js';
+
+describe('BitSet', () => {
+  it('can create a basic selector bitset', () => {
+    let library = new BitSetLibrary(['.foo', '.bar']);
+    expect(library.size).toBe(2);
+    let bitset = library.getBitset();
+    /** No bits are set */
+    expect(bitset.isEmpty()).toBe(true);
+  });
+
+  it('won\'t expand size with existing values', () => {
+    let library = new BitSetLibrary(['.foo', '.bar']);
+    library.add('.foo');
+    expect(library.size).toBe(2);
+    library.add('.baz');
+    expect(library.size).toBe(3);
+  });
+
+  it('can make bitset from iterable', () => {
+    let library = new BitSetLibrary();
+    let bitset = library.getBitset(['.foo', '.baz']);
+    expect(bitset.cardinality()).toBe(2);
+    expect(bitset.get(0)).toBe(1);
+    expect(bitset.get(1)).toBe(1);
+  });
+
+  it('can get bitset from iterable', () => {
+    let library = new BitSetLibrary(['.foo', '.baz']);
+    let bitset = library.getBitset(['.foo', '.baz']);
+    expect(bitset.cardinality()).toBe(2);
+    expect(bitset.get(0)).toBe(1);
+    expect(bitset.get(1)).toBe(1);
+  });
+
+  it('can calculate the union of two bitsets', () => {
+    let library = new BitSetLibrary(['.foo', '.baz']);
+    let bitset1 = library.getBitset(['.foo', '.baz']);
+    let bitset2 = library.getBitset(['.bar', '.baz']);
+    let union = bitset1.or(bitset2);
+    expect(union.cardinality()).toBe(3);
+    expect(union.get(0)).toBe(1);
+    expect(union.get(1)).toBe(1);
+    expect(union.get(2)).toBe(1);
+  });
+
+  it('will throw an error if bitsets are from different libraries', () => {
+    let library1 = new BitSetLibrary(['.foo', '.baz']);
+    let library2 = new BitSetLibrary(['.bar', '.baz']);
+    let bitset1 = library1.getBitset(['.foo', '.baz']);
+    let bitset2 = library2.getBitset(['.bar', '.baz']);
+    expect(() => isSubsetOf(bitset1, bitset2)).toThrow('Bitsets must be from the same library');
+  });
+
+  it('is a subset of itself', () => {
+    let library = new BitSetLibrary(['.foo', '.baz']);
+    let bitset = library.getBitset(['.foo', '.baz']);
+    expect(isSubsetOf(bitset, bitset)).toBe(true);
+  });
+
+  it('is a subset of a larger bitset', () => {
+    let library = new BitSetLibrary(['.foo', '.baz']);
+    let bitset1 = library.getBitset(['.foo', '.baz']);
+    let bitset2 = library.getBitset(['.foo', '.baz', '.bar']);
+    expect(isSubsetOf(bitset1, bitset2)).toBe(true);
+  });
+});
+
+describe('BitSets and selectors', () => {
+  let context: Context;
+  beforeEach(() => {
+    context = new Context();
+  });
+
+  it('can create a bitset from a selector', async () => {
+    let selector = el('.foo');
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['.foo']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['.foo']))).toBe(true);
+  });
+
+  it('bubbles selectors into compound keysets', async () => {
+    let selector = compound([el('.foo'), el('.bar')]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['.foo', '.bar']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['.foo', '.bar']))).toBe(true);
+  });
+
+  it('bubbles selectors into complex keysets #1', async () => {
+    let selector = sel([el('.foo'), co(' '), el('.bar')]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['.foo', ' ', '.bar']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['.foo', ' ', '.bar']))).toBe(true);
+  });
+
+  it('bubbles selectors into complex keysets #2', async () => {
+    let selector = sel([compound([el('a'), el('.foo')]), co(' '), el('.bar')]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['a', '.foo', ' ', '.bar']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['a', '.foo', ' ', '.bar']))).toBe(true);
+  });
+
+  it('bubbles selectors into complex keysets #3', async () => {
+    let selector = sel([compound([el('a'), el('.foo')]), co('>'), el('.bar'), co('+'), el('.baz')]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['a', '.foo', '>', '.bar', '+', '.baz']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['a', '.foo', '>', '.bar', '+', '.baz']))).toBe(true);
+  });
+
+  it('calculates subset keysets of complex selectors', async () => {
+    let sel1 = sel([compound([el('a'), el('.foo')]), co('>'), el('.bar'), co('+'), el('.baz')]);
+    let sel2 = sel([el('.foo'), co('>'), el('.bar'), co('+'), el('.baz')]);
+    let evald1 = await sel1.eval(context) as ComplexSelector;
+    let evald2 = await sel2.eval(context) as ComplexSelector;
+    expect(isSubsetOf(evald2.keySet, evald1.keySet)).toBe(true);
+    /** Larger one doesn't fit into smaller */
+    expect(isSubsetOf(evald1.keySet, evald2.keySet)).toBe(false);
+  });
+
+  test(':is doesn\'t get added to keyset', async () => {
+    let selector = sel([pseudo({ name: ':is', arg: el('.foo') })]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['.foo']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['.foo']))).toBe(true);
+  });
+
+  test('other pseudo selectors get added to keyset', async () => {
+    let selector = sel([pseudo({ name: ':not', arg: el('.foo') })]);
+    await selector.eval(context);
+    expect(selector.keySet.equals(context.selectorBits.getBitset(['.foo', ':not']))).toBe(true);
+    expect(selector.visibleKeySet.equals(context.selectorBits.getBitset(['.foo', ':not']))).toBe(true);
+  });
+
+  test('nth selectors', async () => {
+    let sel = pseudo({ name: ':nth-child', arg: num(1) });
+    await sel.eval(context);
+    expect(sel.keySet.equals(context.selectorBits.getBitset([':nth-child(1)']))).toBe(true);
+    expect(sel.visibleKeySet.equals(context.selectorBits.getBitset([':nth-child(1)']))).toBe(true);
+  });
+});

package/src/tree/util/__tests__/debug-log.ts

@@ -0,0 +1,50 @@
+/**
+ * Synchronous debug logging utility for tests.
+ * This file is in __tests__ so it won't be included in the public API.
+ */
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// Find monorepo root by looking for pnpm-workspace.yaml
+function findMonorepoRoot(start: string): string {
+  let dir = start;
+  while (dir !== '/') {
+    if (existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return process.cwd();
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = findMonorepoRoot(__dirname);
+
+function getLogPath(): string {
+  if (process.env.DEBUG_LOG_PATH) {
+    return process.env.DEBUG_LOG_PATH;
+  }
+  const logDir = process.env.DEBUG_LOG_DIR || join(ROOT, '.cursor');
+  return join(logDir, 'debug.log');
+}
+
+export function getDebugLogPath(): string {
+  return getLogPath();
+}
+
+export const syncLog = (data: Record<string, unknown>) => {
+  try {
+    const logPath = getLogPath();
+    const logDir = dirname(logPath);
+    mkdirSync(logDir, { recursive: true });
+    // Session ID is optional per debug run; omit it unless explicitly configured.
+    const payload = { ...data };
+    if (!process.env.DEBUG_SESSION_ID) {
+      delete payload.sessionId;
+    }
+    appendFileSync(logPath, JSON.stringify(payload) + '\n');
+  } catch {
+    // Ignore errors
+  }
+};

package/src/tree/util/__tests__/extend-comment-handling.test.ts

@@ -0,0 +1,187 @@
+import { expect, describe, it } from 'vitest';
+import { el, sel, sellist, compound, is, co, comment, type Selector } from '../../index.js';
+import { tryExtendSelector } from '../extend-core.js';
+
+function applyExtend(
+  selector: Selector,
+  target: Selector,
+  extendWith: Selector,
+  partial: boolean
+): Selector {
+  const result = tryExtendSelector(selector, target, extendWith, partial);
+  expect(result.error).toBeUndefined();
+  return result.value;
+}
+
+describe('Extend Comment and Whitespace Handling Tests', () => {
+  describe('Comment duplication prevention', () => {
+    it('should extend compound selector with :is() wrapper preserving comments', () => {
+      // Create a target selector with a comment in pre
+      const target = el('.b');
+      const commentNode = comment('/* brand */');
+      target.pre = [commentNode];
+
+      // Create selector that contains the target
+      const selector = compound([el('.a'), target]);
+
+      const extendWith = el('.c');
+
+      // Extend with partial matching - this creates :is() wrapper
+      const result = applyExtend(selector, target, extendWith, true);
+
+      // toTrimmedString should not show duplicated comments
+      const trimmedResult = result.toTrimmedString();
+
+      // Assert the exact output - shows how compound selector extension works with comments
+      expect(trimmedResult).toBe('.a:is(/* brand */.b, .c)');
+
+      // Should contain the comment only once, not multiple times
+      const commentCount = (trimmedResult.match(/\/\* brand \*\//g) || []).length;
+      expect(commentCount).toBe(1);
+    });
+
+    it('should extend complex selector creating selector list (comment lost)', () => {
+      // Original: .a > /* b */.b
+      // Target: .b
+      // ExtendWith: .c, .d (selector list)
+
+      const commentNode = comment('/* b */');
+      const targetSelector = el('.b');
+      targetSelector.pre = [commentNode]; // Comment before .b
+
+      const selector = sel([el('.a'), co('>'), targetSelector]);
+      const target = el('.b');
+      const extendWith = sel([el('.c'), el('.d')]);
+
+      const result = applyExtend(selector as Selector, target, extendWith as Selector, true);
+      const trimmed = result.toTrimmedString();
+
+      // Assert the exact expected output - this shows how extension preserves comments
+      expect(trimmed).toBe('.a > :is(/* b */.b, .c.d)');
+
+      // Verify comment handling - comment should be preserved on the original component
+      expect(trimmed).toContain('/* b */');
+
+      // Verify no comment duplication
+      const commentCount = (trimmed.match(/\/\* b \*\//g) || []).length;
+      expect(commentCount).toBe(1);
+    });
+
+    it('should extend complex nested selector creating selector list', () => {
+      // target: .a > .b.c > .d.e
+      // comment before .b
+      const commentNode = comment('/* component */');
+      const bSelector = el('.b');
+      bSelector.pre = [commentNode];
+
+      const selector = sel([
+        el('.a'),
+        co('>'),
+        compound([bSelector, el('.c')]),
+        co('>'),
+        compound([el('.d'), el('.e')])
+      ]);
+
+      const target = el('.b');
+      const extendWith = el('.f');
+
+      const result = applyExtend(selector as Selector, target, extendWith as Selector, true);
+      const trimmed = result.toTrimmedString();
+
+      // Assert the exact output - shows how component-level extension uses :is() wrapper
+      expect(trimmed).toBe('.a > :is(/* component */.b, .f).c > .d.e');
+
+      // Verify no comment duplication
+      const commentCount = (trimmed.match(/\/\* component \*\//g) || []).length;
+      expect(commentCount).toBe(1);
+    });
+  });
+
+  describe('Whitespace preservation tests', () => {
+    it('should extend compound selector preserving pre-comments', () => {
+      // Test that whitespace structure around comments is maintained
+      const commentNode = comment('/* spacing */');
+      const targetSelector = el('.target');
+
+      // Set up: comment + target (simplified)
+      targetSelector.pre = [commentNode];
+
+      const selector = compound([el('.prefix'), targetSelector]);
+      const target = el('.target');
+      const extendWith = el('.extension');
+
+      const result = applyExtend(selector, target, extendWith, true);
+
+      // The result should preserve the original spacing intent
+      // without duplicating the comment structure
+      const trimmed = result.toTrimmedString();
+
+      // Assert exact output - shows how pre-comment whitespace works with compound selectors
+      expect(trimmed).toBe('.prefix:is(/* spacing */.target, .extension)');
+
+      // Should not duplicate comments
+      const commentCount = (trimmed.match(/\/\* spacing \*\//g) || []).length;
+      expect(commentCount).toBe(1);
+    });
+
+    it('should extend compound selector with multiple comments', () => {
+      // Create a more complex scenario with multiple comments
+      const comment1 = comment('/* first */');
+      const comment2 = comment('/* second */');
+
+      const targetA = el('.a');
+      const targetB = el('.b');
+      targetA.pre = [comment1];
+      targetB.pre = [comment2];
+
+      const selector = compound([targetA, targetB]);
+      const target = el('.a');
+      const extendWith = el('.c');
+
+      const result = applyExtend(selector, target, extendWith, true);
+      const trimmed = result.toTrimmedString();
+
+      // Assert exact output - shows how multiple comments are handled in compound selectors
+      expect(trimmed).toBe(':is(/* first */.a, .c)/* second */.b');
+
+      // Verify each comment appears exactly once
+      expect((trimmed.match(/\/\* first \*\//g) || []).length).toBe(1);
+      expect((trimmed.match(/\/\* second \*\//g) || []).length).toBe(1);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle extend with no pre/post gracefully', () => {
+      const selector = compound([el('.a'), el('.b')]);
+      const target = el('.b');
+      const extendWith = el('.c');
+
+      const result = applyExtend(selector, target, extendWith, true);
+      const trimmed = result.toTrimmedString();
+
+      expect(trimmed).toBe('.a:is(.b, .c)');
+    });
+
+    it('should handle nested :is() extension without comment duplication', () => {
+      // Test extending a selector that already contains :is()
+      const innerComment = comment('/* inner */');
+      const innerTarget = el('.inner');
+      innerTarget.pre = [innerComment];
+
+      const selector = is(sellist([innerTarget, el('.other')]));
+      const target = el('.inner');
+      const extendWith = el('.extended');
+
+      const result = applyExtend(selector, target, extendWith, false);
+      const trimmed = result.toTrimmedString();
+
+      // Assert exact output - shows how nested :is() extension works with full matching
+      // Original :is() should be preserved since it wasn't created by extend
+      expect(trimmed).toBe(':is(/* inner */.inner, .other, .extended)');
+
+      // Should not duplicate the comment
+      const commentCount = (trimmed.match(/\/\* inner \*\//g) || []).length;
+      expect(commentCount).toBe(1);
+    });
+  });
+});