@craftpipe/contextpack 1.0.0

package/tests/tokenizer.test.mjs

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import tokenizerModule from '../lib/tokenizer.js';
+const { estimateTokens, calculateBundleSize, estimateSavings } = tokenizerModule;
+
+describe('estimateTokens', () => {
+  it('is a function', () => {
+    expect(typeof estimateTokens).toBe('function');
+  });
+
+  it('does not throw when called with an empty string', () => {
+    expect(() => estimateTokens('')).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => estimateTokens(null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => estimateTokens(undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with a normal string', () => {
+    expect(() => estimateTokens('function hello() { return 42; }')).not.toThrow();
+  });
+
+  it('does not throw when called with a number', () => {
+    expect(() => estimateTokens(12345)).not.toThrow();
+  });
+
+  it('does not throw when called with an object', () => {
+    expect(() => estimateTokens({ content: 'hello world' })).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = estimateTokens('hello world');
+    expect(result).toBeDefined();
+  });
+});
+
+describe('calculateBundleSize', () => {
+  it('is a function', () => {
+    expect(typeof calculateBundleSize).toBe('function');
+  });
+
+  it('does not throw when called with an empty object', () => {
+    expect(() => calculateBundleSize({})).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => calculateBundleSize(null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => calculateBundleSize(undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with a bundle-shaped object', () => {
+    const bundle = {
+      metadata: { fileCount: 5, totalSize: 1024 },
+      fileSummaries: [{ path: 'a.js', summary: 'exports foo' }],
+      symbolIndex: { foo: ['a.js'] },
+      dependencyMap: {},
+    };
+    expect(() => calculateBundleSize(bundle)).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = calculateBundleSize({});
+    expect(result).toBeDefined();
+  });
+});
+
+describe('estimateSavings', () => {
+  it('is a function', () => {
+    expect(typeof estimateSavings).toBe('function');
+  });
+
+  it('does not throw when called with two numbers', () => {
+    expect(() => estimateSavings(1000, 400)).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => estimateSavings(null, null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => estimateSavings(undefined, undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with zero values', () => {
+    expect(() => estimateSavings(0, 0)).not.toThrow();
+  });
+
+  it('does not throw when called with objects', () => {
+    expect(() => estimateSavings({ tokens: 1000 }, { tokens: 400 })).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = estimateSavings(1000, 400);
+    expect(result).toBeDefined();
+  });
+});

package/tests/validator.test.mjs

@@ -0,0 +1,111 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import validatorModule from '../lib/validator.js';
+const { validateBundle, checkCircularDependencies, checkSymbolConflicts } = validatorModule;
+
+describe('validateBundle', () => {
+  it('is a function', () => {
+    expect(typeof validateBundle).toBe('function');
+  });
+
+  it('does not throw when called with an empty object', () => {
+    expect(() => validateBundle({})).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => validateBundle(null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => validateBundle(undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with a well-formed bundle', () => {
+    const bundle = {
+      metadata: { projectDir: '/fake', fileCount: 2, totalSize: 512, createdAt: new Date().toISOString() },
+      fileSummaries: [
+        { path: 'a.js', summary: 'exports foo', symbols: ['foo'], size: 100 },
+        { path: 'b.js', summary: 'exports bar', symbols: ['bar'], size: 200 },
+      ],
+      symbolIndex: { foo: ['a.js'], bar: ['b.js'] },
+      dependencyMap: { 'a.js': [], 'b.js': ['a.js'] },
+    };
+    expect(() => validateBundle(bundle)).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = validateBundle({});
+    expect(result).toBeDefined();
+  });
+
+  it('returns an object', () => {
+    const result = validateBundle({});
+    expect(typeof result).toBe('object');
+  });
+});
+
+describe('checkCircularDependencies', () => {
+  it('is a function', () => {
+    expect(typeof checkCircularDependencies).toBe('function');
+  });
+
+  it('does not throw when called with an empty object', () => {
+    expect(() => checkCircularDependencies({})).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => checkCircularDependencies(null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => checkCircularDependencies(undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with a simple acyclic dependency map', () => {
+    const depMap = { 'a.js': ['b.js'], 'b.js': ['c.js'], 'c.js': [] };
+    expect(() => checkCircularDependencies(depMap)).not.toThrow();
+  });
+
+  it('does not throw when called with a circular dependency map', () => {
+    const depMap = { 'a.js': ['b.js'], 'b.js': ['a.js'] };
+    expect(() => checkCircularDependencies(depMap)).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = checkCircularDependencies({});
+    expect(result).toBeDefined();
+  });
+});
+
+describe('checkSymbolConflicts', () => {
+  it('is a function', () => {
+    expect(typeof checkSymbolConflicts).toBe('function');
+  });
+
+  it('does not throw when called with an empty object', () => {
+    expect(() => checkSymbolConflicts({})).not.toThrow();
+  });
+
+  it('does not throw when called with null', () => {
+    expect(() => checkSymbolConflicts(null)).not.toThrow();
+  });
+
+  it('does not throw when called with undefined', () => {
+    expect(() => checkSymbolConflicts(undefined)).not.toThrow();
+  });
+
+  it('does not throw when called with a symbol index with no conflicts', () => {
+    const symbolIndex = { foo: ['a.js'], bar: ['b.js'] };
+    expect(() => checkSymbolConflicts(symbolIndex)).not.toThrow();
+  });
+
+  it('does not throw when called with a symbol index with conflicts', () => {
+    const symbolIndex = { foo: ['a.js', 'b.js'], bar: ['c.js'] };
+    expect(() => checkSymbolConflicts(symbolIndex)).not.toThrow();
+  });
+
+  it('returns a value', () => {
+    const result = checkSymbolConflicts({});
+    expect(result).toBeDefined();
+  });
+});

package/vitest.config.mjs

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.mjs'],
+    globals: false,
+    testTimeout: 10000,
+    hookTimeout: 10000,
+    isolate: true,
+    pool: 'forks',
+  },
+});