@fgv/ts-web-extras 5.1.0-2 → 5.1.0-21

package/src/test/unit/browserHashProvider.test.ts.bak

@@ -1,376 +0,0 @@
-/*
- * Copyright (c) 2025 Erik Fortune
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import '@fgv/ts-utils-jest';
-import { BrowserHashProvider, BrowserHashingNormalizer } from '../../packlets/crypto';
-
-describe('BrowserHashProvider', () => {
-  describe('Static factory methods', () => {
-    test('createSha256Normalizer returns BrowserHashingNormalizer with SHA-256', () => {
-      const normalizer = BrowserHashProvider.createSha256Normalizer();
-      expect(normalizer).toBeInstanceOf(BrowserHashingNormalizer);
-      expect(normalizer.algorithm).toBe('SHA-256');
-    });
-
-    test('createSha1Normalizer returns BrowserHashingNormalizer with SHA-1', () => {
-      const normalizer = BrowserHashProvider.createSha1Normalizer();
-      expect(normalizer).toBeInstanceOf(BrowserHashingNormalizer);
-      expect(normalizer.algorithm).toBe('SHA-1');
-    });
-
-    test('createSha512Normalizer returns BrowserHashingNormalizer with SHA-512', () => {
-      const normalizer = BrowserHashProvider.createSha512Normalizer();
-      expect(normalizer).toBeInstanceOf(BrowserHashingNormalizer);
-      expect(normalizer.algorithm).toBe('SHA-512');
-    });
-  });
-
-  describe('hashString', () => {
-    test('successfully hashes a string with SHA-256', async () => {
-      const result = await BrowserHashProvider.hashString('test data', 'SHA-256');
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(typeof hash).toBe('string');
-        expect(hash).toMatch(/^[a-f0-9]{64}$/); // SHA-256 produces 64 hex characters
-      });
-    });
-
-    test('successfully hashes a string with SHA-1', async () => {
-      const result = await BrowserHashProvider.hashString('test data', 'SHA-1');
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(typeof hash).toBe('string');
-        expect(hash).toMatch(/^[a-f0-9]{40}$/); // SHA-1 produces 40 hex characters
-      });
-    });
-
-    test('successfully hashes a string with SHA-512', async () => {
-      const result = await BrowserHashProvider.hashString('test data', 'SHA-512');
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(typeof hash).toBe('string');
-        expect(hash).toMatch(/^[a-f0-9]{128}$/); // SHA-512 produces 128 hex characters
-      });
-    });
-
-    test('uses SHA-256 as default algorithm', async () => {
-      const result = await BrowserHashProvider.hashString('test data');
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/); // SHA-256 produces 64 hex characters
-      });
-    });
-
-    test('produces consistent hash for same input', async () => {
-      const input = 'consistent input';
-      const result1 = await BrowserHashProvider.hashString(input);
-      const result2 = await BrowserHashProvider.hashString(input);
-      
-      expect(result1).toSucceed();
-      expect(result2).toSucceed();
-      if (result1.isSuccess() && result2.isSuccess()) {
-        expect(result1.value).toBe(result2.value);
-      }
-    });
-
-    test('produces different hashes for different inputs', async () => {
-      const result1 = await BrowserHashProvider.hashString('input1');
-      const result2 = await BrowserHashProvider.hashString('input2');
-      
-      expect(result1).toSucceed();
-      expect(result2).toSucceed();
-      if (result1.isSuccess() && result2.isSuccess()) {
-        expect(result1.value).not.toBe(result2.value);
-      }
-    });
-
-    test('handles empty string input', async () => {
-      const result = await BrowserHashProvider.hashString('');
-      expect(result).toSucceed();
-    });
-
-    test('handles unicode input', async () => {
-      const result = await BrowserHashProvider.hashString('🚀 Unicode test 测试');
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-      });
-    });
-
-    test('fails when crypto.subtle is unavailable', async () => {
-      const originalCrypto = global.crypto;
-      // @ts-ignore - Intentionally removing crypto for test
-      delete global.crypto;
-
-      const result = await BrowserHashProvider.hashString('test');
-      expect(result).toFailWith(/Hash computation failed/);
-
-      global.crypto = originalCrypto;
-    });
-
-    test('handles invalid algorithm gracefully', async () => {
-      const result = await BrowserHashProvider.hashString('test', 'INVALID-ALG');
-      expect(result).toFailWith(/Hash computation failed/);
-    });
-  });
-
-  describe('hashParts', () => {
-    test('hashes multiple parts with default separator', async () => {
-      const parts = ['part1', 'part2', 'part3'];
-      const result = await BrowserHashProvider.hashParts(parts);
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-      });
-    });
-
-    test('hashes multiple parts with custom separator', async () => {
-      const parts = ['part1', 'part2', 'part3'];
-      const result1 = await BrowserHashProvider.hashParts(parts, 'SHA-256', '|');
-      const result2 = await BrowserHashProvider.hashParts(parts, 'SHA-256', ',');
-      
-      expect(result1).toSucceed();
-      expect(result2).toSucceed();
-      if (result1.isSuccess() && result2.isSuccess()) {
-        expect(result1.value).not.toBe(result2.value);
-      }
-    });
-
-    test('produces same hash as hashString for joined parts', async () => {
-      const parts = ['a', 'b', 'c'];
-      const separator = '-';
-      const joined = parts.join(separator);
-      
-      const partsResult = await BrowserHashProvider.hashParts(parts, 'SHA-256', separator);
-      const stringResult = await BrowserHashProvider.hashString(joined);
-      
-      expect(partsResult).toSucceed();
-      expect(stringResult).toSucceed();
-      if (partsResult.isSuccess() && stringResult.isSuccess()) {
-        expect(partsResult.value).toBe(stringResult.value);
-      }
-    });
-
-    test('handles empty array', async () => {
-      const result = await BrowserHashProvider.hashParts([]);
-      expect(result).toSucceed();
-    });
-
-    test('handles single part', async () => {
-      const result = await BrowserHashProvider.hashParts(['single']);
-      const stringResult = await BrowserHashProvider.hashString('single');
-      
-      expect(result).toSucceed();
-      expect(stringResult).toSucceed();
-      if (result.isSuccess() && stringResult.isSuccess()) {
-        expect(result.value).toBe(stringResult.value);
-      }
-    });
-  });
-});
-
-describe('BrowserHashingNormalizer', () => {
-  describe('constructor', () => {
-    test('creates instance with default SHA-256 algorithm', () => {
-      const normalizer = new BrowserHashingNormalizer();
-      expect(normalizer).toBeInstanceOf(BrowserHashingNormalizer);
-      expect(normalizer.algorithm).toBe('SHA-256');
-    });
-
-    test('creates instance with custom algorithm', () => {
-      const normalizer = new BrowserHashingNormalizer('SHA-512');
-      expect(normalizer.algorithm).toBe('SHA-512');
-    });
-  });
-
-  describe('hashAsync', () => {
-    test('hashes array of strings', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const result = await normalizer.hashAsync(['test1', 'test2']);
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-      });
-    });
-
-    test('produces consistent results', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const parts = ['consistent', 'parts'];
-      
-      const result1 = await normalizer.hashAsync(parts);
-      const result2 = await normalizer.hashAsync(parts);
-      
-      expect(result1).toSucceed();
-      expect(result2).toSucceed();
-      if (result1.isSuccess() && result2.isSuccess()) {
-        expect(result1.value).toBe(result2.value);
-      }
-    });
-  });
-
-  describe('normalizeAsync', () => {
-    test('normalizes primitive values', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      
-      const stringResult = await normalizer.normalizeAsync('test');
-      expect(stringResult).toSucceed();
-      
-      const numberResult = await normalizer.normalizeAsync(42);
-      expect(numberResult).toSucceed();
-      
-      const booleanResult = await normalizer.normalizeAsync(true);
-      expect(booleanResult).toSucceed();
-      
-      const nullResult = await normalizer.normalizeAsync(null);
-      expect(nullResult).toSucceed();
-      
-      const undefinedResult = await normalizer.normalizeAsync(undefined);
-      expect(undefinedResult).toSucceed();
-    });
-
-    test('normalizes arrays', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const array = ['item1', 'item2', 42, true];
-      
-      const result = await normalizer.normalizeAsync(array);
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-      });
-    });
-
-    test('normalizes nested arrays', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const nestedArray = ['item1', ['nested1', 'nested2'], 'item3'];
-      
-      const result = await normalizer.normalizeAsync(nestedArray);
-      expect(result).toSucceed();
-    });
-
-    test('normalizes objects', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const obj = { 
-        name: 'test', 
-        value: 42,
-        nested: { key: 'value' }
-      };
-      
-      const result = await normalizer.normalizeAsync(obj);
-      expect(result).toSucceedAndSatisfy(hash => {
-        expect(hash).toMatch(/^[a-f0-9]{64}$/);
-      });
-    });
-
-    test('normalizes objects with consistent key ordering', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const obj1 = { b: 2, a: 1, c: 3 };
-      const obj2 = { a: 1, c: 3, b: 2 };
-      
-      const result1 = await normalizer.normalizeAsync(obj1);
-      const result2 = await normalizer.normalizeAsync(obj2);
-      
-      expect(result1).toSucceed();
-      expect(result2).toSucceed();
-      if (result1.isSuccess() && result2.isSuccess()) {
-        expect(result1.value).toBe(result2.value);
-      }
-    });
-
-    test('normalizes Date objects', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const date = new Date('2025-01-01T00:00:00Z');
-      
-      const result = await normalizer.normalizeAsync(date);
-      expect(result).toSucceed();
-    });
-
-    test('normalizes RegExp objects', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const regex = /test.*pattern/gi;
-      
-      const result = await normalizer.normalizeAsync(regex);
-      expect(result).toSucceed();
-    });
-
-    test('normalizes complex nested structures', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const complex = {
-        id: 'test-id',
-        data: {
-          values: [1, 2, 3],
-          metadata: {
-            created: new Date('2025-01-01'),
-            tags: ['tag1', 'tag2']
-          }
-        },
-        flags: {
-          active: true,
-          validated: false
-        }
-      };
-      
-      const result = await normalizer.normalizeAsync(complex);
-      expect(result).toSucceed();
-    });
-
-    test('handles bigint values', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const bigIntValue = BigInt(9007199254740991);
-      
-      const result = await normalizer.normalizeAsync(bigIntValue);
-      expect(result).toSucceed();
-    });
-
-    test('handles symbol values', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const symbolValue = Symbol('test');
-      
-      const result = await normalizer.normalizeAsync(symbolValue);
-      expect(result).toSucceed();
-    });
-  });
-
-  describe('computeHash', () => {
-    test('throws error for synchronous operation', () => {
-      const normalizer = new BrowserHashingNormalizer();
-      const result = normalizer.computeHash('test');
-      
-      expect(result).toFailWith(/Synchronous hashing not supported in browser/);
-    });
-  });
-
-  describe('algorithm getter', () => {
-    test('returns the correct algorithm', () => {
-      const sha256 = new BrowserHashingNormalizer('SHA-256');
-      expect(sha256.algorithm).toBe('SHA-256');
-      
-      const sha1 = new BrowserHashingNormalizer('SHA-1');
-      expect(sha1.algorithm).toBe('SHA-1');
-      
-      const sha512 = new BrowserHashingNormalizer('SHA-512');
-      expect(sha512.algorithm).toBe('SHA-512');
-    });
-  });
-
-  describe('_computeHashAsync', () => {
-    test('handles unexpected types gracefully', async () => {
-      const normalizer = new BrowserHashingNormalizer();
-      
-      // Test with function (which is an unexpected type)
-      const func = () => 'test';
-      const result = await normalizer.normalizeAsync(func as unknown);
-      expect(result).toFailWith(/Unexpected type/);
-    });
-  });
-});

package/src/test/unit/directoryHandleStore.test.ts

@@ -1,251 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-import '@fgv/ts-utils-jest';
-import {
-  DirectoryHandleStore,
-  DEFAULT_DIRECTORY_HANDLE_DB,
-  DEFAULT_DIRECTORY_HANDLE_STORE
-} from '../../packlets/file-tree/directoryHandleStore';
-import type { FileSystemDirectoryHandle } from '../../packlets/file-api-types';
-
-import { get, set, del, keys, createStore } from 'idb-keyval';
-
-const mockGet = jest.mocked(get);
-const mockSet = jest.mocked(set);
-const mockDel = jest.mocked(del);
-const mockKeys = jest.mocked(keys);
-const mockCreateStore = jest.mocked(createStore);
-
-function makeMockHandle(name: string): FileSystemDirectoryHandle {
-  return {
-    kind: 'directory',
-    name,
-    isSameEntry: jest.fn(),
-    queryPermission: jest.fn(),
-    requestPermission: jest.fn(),
-    getDirectoryHandle: jest.fn(),
-    getFileHandle: jest.fn(),
-    removeEntry: jest.fn(),
-    resolve: jest.fn(),
-    keys: jest.fn(),
-    values: jest.fn(),
-    entries: jest.fn(),
-    [Symbol.asyncIterator]: jest.fn()
-  } as FileSystemDirectoryHandle;
-}
-
-describe('DirectoryHandleStore', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('constants', () => {
-    test('DEFAULT_DIRECTORY_HANDLE_DB has expected value', () => {
-      expect(DEFAULT_DIRECTORY_HANDLE_DB).toBe('chocolate-lab-storage');
-    });
-
-    test('DEFAULT_DIRECTORY_HANDLE_STORE has expected value', () => {
-      expect(DEFAULT_DIRECTORY_HANDLE_STORE).toBe('directory-handles');
-    });
-  });
-
-  describe('constructor', () => {
-    test('uses default db and store names', () => {
-      new DirectoryHandleStore();
-      expect(mockCreateStore).toHaveBeenCalledWith(
-        DEFAULT_DIRECTORY_HANDLE_DB,
-        DEFAULT_DIRECTORY_HANDLE_STORE
-      );
-    });
-
-    test('uses custom db and store names', () => {
-      new DirectoryHandleStore('custom-db', 'custom-store');
-      expect(mockCreateStore).toHaveBeenCalledWith('custom-db', 'custom-store');
-    });
-  });
-
-  describe('save', () => {
-    test('saves a handle successfully', async () => {
-      mockSet.mockResolvedValue(undefined);
-      const store = new DirectoryHandleStore();
-      const handle = makeMockHandle('my-dir');
-
-      const result = await store.save('my-dir', handle);
-
-      expect(result).toSucceed();
-      expect(mockSet).toHaveBeenCalledWith('my-dir', handle, expect.anything());
-    });
-
-    test('returns failure when set throws', async () => {
-      mockSet.mockRejectedValue(new Error('IndexedDB unavailable'));
-      const store = new DirectoryHandleStore();
-      const handle = makeMockHandle('my-dir');
-
-      const result = await store.save('my-dir', handle);
-
-      expect(result).toFailWith(/IndexedDB unavailable/);
-    });
-  });
-
-  describe('load', () => {
-    test('returns the handle when found', async () => {
-      const handle = makeMockHandle('my-dir');
-      mockGet.mockResolvedValue(handle);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.load('my-dir');
-
-      expect(result).toSucceedWith(handle);
-      expect(mockGet).toHaveBeenCalledWith('my-dir', expect.anything());
-    });
-
-    test('returns undefined when not found', async () => {
-      mockGet.mockResolvedValue(undefined);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.load('missing');
-
-      expect(result).toSucceedWith(undefined);
-    });
-
-    test('returns failure when get throws', async () => {
-      mockGet.mockRejectedValue(new Error('read error'));
-      const store = new DirectoryHandleStore();
-
-      const result = await store.load('my-dir');
-
-      expect(result).toFailWith(/read error/);
-    });
-  });
-
-  describe('remove', () => {
-    test('removes a handle successfully', async () => {
-      mockDel.mockResolvedValue(undefined);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.remove('my-dir');
-
-      expect(result).toSucceed();
-      expect(mockDel).toHaveBeenCalledWith('my-dir', expect.anything());
-    });
-
-    test('returns failure when del throws', async () => {
-      mockDel.mockRejectedValue(new Error('delete error'));
-      const store = new DirectoryHandleStore();
-
-      const result = await store.remove('my-dir');
-
-      expect(result).toFailWith(/delete error/);
-    });
-  });
-
-  describe('getAllLabels', () => {
-    test('returns all keys', async () => {
-      mockKeys.mockResolvedValue(['dir-a', 'dir-b']);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAllLabels();
-
-      expect(result).toSucceedWith(['dir-a', 'dir-b']);
-      expect(mockKeys).toHaveBeenCalledWith(expect.anything());
-    });
-
-    test('returns empty array when no keys', async () => {
-      mockKeys.mockResolvedValue([]);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAllLabels();
-
-      expect(result).toSucceedWith([]);
-    });
-
-    test('returns failure when keys throws', async () => {
-      mockKeys.mockRejectedValue(new Error('keys error'));
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAllLabels();
-
-      expect(result).toFailWith(/keys error/);
-    });
-  });
-
-  describe('getAll', () => {
-    test('returns all label/handle pairs', async () => {
-      const handleA = makeMockHandle('dir-a');
-      const handleB = makeMockHandle('dir-b');
-      mockKeys.mockResolvedValue(['dir-a', 'dir-b']);
-      mockGet.mockResolvedValueOnce(handleA).mockResolvedValueOnce(handleB);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAll();
-
-      expect(result).toSucceedAndSatisfy((entries) => {
-        expect(entries).toHaveLength(2);
-        expect(entries[0]).toEqual({ label: 'dir-a', handle: handleA });
-        expect(entries[1]).toEqual({ label: 'dir-b', handle: handleB });
-      });
-    });
-
-    test('returns empty array when no handles stored', async () => {
-      mockKeys.mockResolvedValue([]);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAll();
-
-      expect(result).toSucceedWith([]);
-    });
-
-    test('skips entries where handle is undefined', async () => {
-      const handleA = makeMockHandle('dir-a');
-      mockKeys.mockResolvedValue(['dir-a', 'dir-b']);
-      mockGet.mockResolvedValueOnce(handleA).mockResolvedValueOnce(undefined);
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAll();
-
-      expect(result).toSucceedAndSatisfy((entries) => {
-        expect(entries).toHaveLength(1);
-        expect(entries[0]).toEqual({ label: 'dir-a', handle: handleA });
-      });
-    });
-
-    test('returns failure when getAllLabels fails', async () => {
-      mockKeys.mockRejectedValue(new Error('keys error'));
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAll();
-
-      expect(result).toFailWith(/keys error/);
-    });
-
-    test('returns failure when load fails for a key', async () => {
-      mockKeys.mockResolvedValue(['dir-a']);
-      mockGet.mockRejectedValue(new Error('load error'));
-      const store = new DirectoryHandleStore();
-
-      const result = await store.getAll();
-
-      expect(result).toFailWith(/load error/);
-    });
-  });
-});