claude-yes 1.27.0 → 1.29.2

package/ts/utils.spec.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it } from 'vitest';
+import { type DeepPartial, deepMixin, sleepms } from './utils';
+
+describe('utils', () => {
+  describe('sleepms', () => {
+    it('should return a promise', () => {
+      const result = sleepms(100);
+      expect(result).toBeInstanceOf(Promise);
+    });
+
+    it('should resolve after some time', async () => {
+      const start = Date.now();
+      await sleepms(10);
+      const end = Date.now();
+      expect(end - start).toBeGreaterThanOrEqual(5); // Allow some margin
+    });
+
+    it('should handle zero milliseconds', async () => {
+      const start = Date.now();
+      await sleepms(0);
+      const end = Date.now();
+      expect(end - start).toBeLessThan(50); // Should be quick
+    });
+  });
+
+  describe('deepMixin', () => {
+    it('should merge simple properties', () => {
+      const target = { a: 1, b: 2 };
+      const source = { b: 3, c: 4 };
+      const result = deepMixin(target, source);
+
+      expect(result).toEqual({ a: 1, b: 3, c: 4 });
+      expect(result).toBe(target); // Should modify original object
+    });
+
+    it('should merge nested objects', () => {
+      const target = {
+        user: { name: 'John', age: 30 },
+        settings: { theme: 'dark' },
+      };
+      const source: DeepPartial<typeof target> = {
+        user: { age: 31 },
+        settings: { language: 'en' } as any,
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        user: { name: 'John', age: 31 },
+        settings: { theme: 'dark', language: 'en' },
+      });
+    });
+
+    it('should create nested objects when target property is null', () => {
+      const target: any = { config: null };
+      const source = { config: { enabled: true } };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        config: { enabled: true },
+      });
+    });
+
+    it('should create nested objects when target property is primitive', () => {
+      const target: any = { config: 'string' };
+      const source = { config: { enabled: true } };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        config: { enabled: true },
+      });
+    });
+
+    it('should handle arrays by replacing them', () => {
+      const target = { items: [1, 2, 3] };
+      const source = { items: [4, 5] };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ items: [4, 5] });
+    });
+
+    it('should ignore undefined values', () => {
+      const target = { a: 1, b: 2 };
+      const source = { a: undefined, c: 3 };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ a: 1, b: 2, c: 3 });
+    });
+
+    it('should handle null values', () => {
+      const target = { a: 1, b: 2 };
+      const source = { a: null, c: 3 };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({ a: null, b: 2, c: 3 });
+    });
+
+    it('should handle deeply nested structures', () => {
+      const target = {
+        level1: {
+          level2: {
+            level3: { value: 'old' },
+          },
+        },
+      };
+      const source = {
+        level1: {
+          level2: {
+            level3: { value: 'new', extra: 'added' },
+          },
+        },
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        level1: {
+          level2: {
+            level3: { value: 'new', extra: 'added' },
+          },
+        },
+      });
+    });
+
+    it('should handle empty objects', () => {
+      const target = {};
+      const source = {};
+
+      const result = deepMixin(target, source);
+
+      expect(result).toEqual({});
+      expect(result).toBe(target);
+    });
+
+    it('should handle complex mixed types', () => {
+      const target: any = {
+        string: 'value',
+        number: 42,
+        boolean: true,
+        object: { nested: 'value' },
+        array: [1, 2, 3],
+      };
+      const source: any = {
+        string: 'new value',
+        number: 100,
+        boolean: false,
+        object: { nested: 'new value', added: 'property' },
+        array: [4, 5],
+        newProp: 'added',
+      };
+
+      deepMixin(target, source);
+
+      expect(target).toEqual({
+        string: 'new value',
+        number: 100,
+        boolean: false,
+        object: { nested: 'new value', added: 'property' },
+        array: [4, 5],
+        newProp: 'added',
+      });
+    });
+  });
+});

package/ts/yesLog.spec.ts

@@ -0,0 +1,74 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+describe('yesLog', () => {
+  const originalVerbose = process.env.VERBOSE;
+
+  beforeEach(() => {
+    // Reset modules to ensure fresh state
+    delete require.cache[require.resolve('./yesLog')];
+  });
+
+  afterEach(() => {
+    // Restore original VERBOSE setting
+    if (originalVerbose !== undefined) {
+      process.env.VERBOSE = originalVerbose;
+    } else {
+      delete process.env.VERBOSE;
+    }
+  });
+
+  it('should not crash when VERBOSE is not set', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw and returns undefined
+    const result = yesLog`Test message`;
+    expect(result).toBeUndefined();
+  });
+
+  it('should be callable with template literals', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw with variables
+    const variable = 'test value';
+    const result = yesLog`Message with ${variable}`;
+    expect(result).toBeUndefined();
+  });
+
+  it('should handle multiple calls', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    // Multiple calls should not throw
+    expect(yesLog`First message`).toBeUndefined();
+    expect(yesLog`Second message`).toBeUndefined();
+    expect(yesLog`Third message`).toBeUndefined();
+  });
+
+  it('should work when VERBOSE is set', async () => {
+    process.env.VERBOSE = '1';
+
+    const { yesLog } = await import('./yesLog');
+
+    // Should not throw even when verbose
+    expect(yesLog`Verbose message`).toBeUndefined();
+  });
+
+  it('should handle template literals with different types', async () => {
+    delete process.env.VERBOSE;
+
+    const { yesLog } = await import('./yesLog');
+
+    const number = 42;
+    const object = { key: 'value' };
+    const array = [1, 2, 3];
+
+    expect(yesLog`Number: ${number}`).toBeUndefined();
+    expect(yesLog`Object: ${object}`).toBeUndefined();
+    expect(yesLog`Array: ${array}`).toBeUndefined();
+  });
+});