@harborclient/sdk 1.0.0 → 1.0.1

package/dist/store.test.js

@@ -1,248 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
-import { createExternalStore, createStorageStore, setIntervalDisposable, syncOnWindowFocus } from './runtime/store.js';
-/**
- * Builds an in-memory storage mock for store tests.
- *
- * @param initial - Seed values keyed by storage key.
- */
-function createMockStorage(initial = {}) {
-    const data = { ...initial };
-    const getMock = jest.fn(async (key) => data[key]);
-    const setMock = jest.fn(async (key, value) => {
-        data[key] = value;
-    });
-    return {
-        data,
-        get: getMock,
-        set: setMock,
-        getMock,
-        setMock
-    };
-}
-describe('createExternalStore', () => {
-    it('notifies subscribers when setState is called', () => {
-        const store = createExternalStore(0);
-        const listener = jest.fn();
-        store.subscribe(listener);
-        store.setState(1);
-        expect(listener).toHaveBeenCalledTimes(1);
-        expect(store.getSnapshot()).toBe(1);
-    });
-});
-describe('createStorageStore', () => {
-    it('starts from parse(undefined)', () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        expect(store.getSnapshot()).toEqual([]);
-    });
-    it('persists and updates the snapshot via set', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.set(['a']);
-        expect(store.getSnapshot()).toEqual(['a']);
-        expect(storage.setMock).toHaveBeenCalledWith('items', ['a']);
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-    it('skips set when equals reports no change', async () => {
-        const storage = createMockStorage({ items: ['a'] });
-        const store = createStorageStore({
-            storage,
-            key: 'items',
-            parse: (raw) => (Array.isArray(raw) ? raw : [])
-        });
-        await store.reloadFromStorage();
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.set(['a']);
-        expect(listener).not.toHaveBeenCalled();
-        expect(storage.setMock).not.toHaveBeenCalled();
-    });
-    it('reloadFromStorage applies parsed storage values', async () => {
-        const storage = createMockStorage({ count: 3 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(store.getSnapshot()).toBe(3);
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-    it('reloadFromStorage skips notify when parsed value is unchanged', async () => {
-        const storage = createMockStorage({ count: 2 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        await store.reloadFromStorage();
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-    });
-    it('uses a custom equals function', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'status',
-            parse: (raw) => raw && typeof raw === 'object' && 'running' in raw
-                ? raw
-                : { running: false },
-            equals: (a, b) => a.running === b.running
-        });
-        await store.set({ running: true });
-        const listener = jest.fn();
-        store.subscribe(listener);
-        storage.data.status = { running: true, port: 8080 };
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-        expect(store.getSnapshot()).toEqual({ running: true });
-    });
-    it('keeps the current snapshot when storage is missing and keepCurrentWhenMissing is true', async () => {
-        const storage = createMockStorage();
-        const store = createStorageStore({
-            storage,
-            key: 'status',
-            parse: () => ({ running: false }),
-            keepCurrentWhenMissing: true
-        });
-        await store.set({ running: true });
-        delete storage.data.status;
-        const listener = jest.fn();
-        store.subscribe(listener);
-        await store.reloadFromStorage();
-        expect(listener).not.toHaveBeenCalled();
-        expect(store.getSnapshot()).toEqual({ running: true });
-    });
-});
-describe('setIntervalDisposable', () => {
-    beforeEach(() => {
-        jest.useFakeTimers();
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-    it('invokes the callback on an interval until disposed', () => {
-        const callback = jest.fn();
-        const disposable = setIntervalDisposable(callback, 100);
-        jest.advanceTimersByTime(250);
-        expect(callback).toHaveBeenCalledTimes(2);
-        disposable.dispose();
-        jest.advanceTimersByTime(200);
-        expect(callback).toHaveBeenCalledTimes(2);
-    });
-});
-describe('syncOnWindowFocus', () => {
-    const focusListeners = new Set();
-    const visibilityListeners = new Set();
-    const originalWindow = globalThis.window;
-    const originalDocument = globalThis.document;
-    beforeEach(() => {
-        jest.useFakeTimers();
-        focusListeners.clear();
-        visibilityListeners.clear();
-        globalThis.window = {
-            addEventListener: (type, listener) => {
-                if (type === 'focus' && typeof listener === 'function') {
-                    focusListeners.add(listener);
-                }
-            },
-            removeEventListener: (type, listener) => {
-                if (type === 'focus' && typeof listener === 'function') {
-                    focusListeners.delete(listener);
-                }
-            },
-            dispatchEvent: (event) => {
-                if (event.type === 'focus') {
-                    for (const listener of focusListeners) {
-                        listener(event);
-                    }
-                }
-                return true;
-            }
-        };
-        globalThis.document = {
-            addEventListener: (type, listener) => {
-                if (type === 'visibilitychange' && typeof listener === 'function') {
-                    visibilityListeners.add(listener);
-                }
-            },
-            removeEventListener: (type, listener) => {
-                if (type === 'visibilitychange' && typeof listener === 'function') {
-                    visibilityListeners.delete(listener);
-                }
-            },
-            dispatchEvent: (event) => {
-                if (event.type === 'visibilitychange') {
-                    for (const listener of visibilityListeners) {
-                        listener(event);
-                    }
-                }
-                return true;
-            }
-        };
-    });
-    afterEach(() => {
-        jest.useRealTimers();
-        globalThis.window = originalWindow;
-        globalThis.document = originalDocument;
-    });
-    it('reloads stores on focus, visibility change, mount, and interval', async () => {
-        const storage = createMockStorage({ count: 1 });
-        const store = createStorageStore({
-            storage,
-            key: 'count',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const reloadSpy = jest.spyOn(store, 'reloadFromStorage');
-        const disposable = syncOnWindowFocus(store, { intervalMs: 500 });
-        expect(reloadSpy).toHaveBeenCalledTimes(1);
-        storage.data.count = 2;
-        window.dispatchEvent(new Event('focus'));
-        expect(reloadSpy).toHaveBeenCalledTimes(2);
-        storage.data.count = 3;
-        document.dispatchEvent(new Event('visibilitychange'));
-        expect(reloadSpy).toHaveBeenCalledTimes(3);
-        storage.data.count = 4;
-        jest.advanceTimersByTime(500);
-        expect(reloadSpy).toHaveBeenCalledTimes(4);
-        disposable.dispose();
-        storage.data.count = 5;
-        window.dispatchEvent(new Event('focus'));
-        jest.advanceTimersByTime(500);
-        expect(reloadSpy).toHaveBeenCalledTimes(4);
-        await store.reloadFromStorage();
-        expect(store.getSnapshot()).toBe(5);
-    });
-    it('reloads multiple stores together', async () => {
-        const storage = createMockStorage();
-        const first = createStorageStore({
-            storage,
-            key: 'first',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const second = createStorageStore({
-            storage,
-            key: 'second',
-            parse: (raw) => (typeof raw === 'number' ? raw : 0)
-        });
-        const reloadFirst = jest.spyOn(first, 'reloadFromStorage');
-        const reloadSecond = jest.spyOn(second, 'reloadFromStorage');
-        syncOnWindowFocus([first, second]).dispose();
-        expect(reloadFirst).toHaveBeenCalledTimes(1);
-        expect(reloadSecond).toHaveBeenCalledTimes(1);
-    });
-});

package/dist/utilities.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=utilities.test.d.ts.map

package/dist/utilities.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utilities.test.d.ts","sourceRoot":"","sources":["../src/utilities.test.ts"],"names":[],"mappings":""}

package/dist/utilities.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { methodColorClass, statusColorClass } from './ui/tokens.js';
-import { formatRelativeTime, formatHeaders } from './ui/format.js';
-describe('method and status color helpers', () => {
-    it('return host classes', () => {
-        expect(methodColorClass('GET')).toBe('text-method-get');
-        expect(statusColorClass(200)).toBe('bg-success');
-        expect(statusColorClass(404)).toBe('bg-danger');
-    });
-});
-describe('format helpers', () => {
-    it('produce readable output', () => {
-        expect(formatHeaders({ Accept: 'application/json' })).toBe('Accept: application/json');
-        expect(formatRelativeTime(Date.now() - 10_000)).toMatch(/ago|just now/);
-    });
-});

package/dist/variables/dynamic.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dynamic.test.d.ts.map

package/dist/variables/dynamic.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic.test.d.ts","sourceRoot":"","sources":["../../src/variables/dynamic.test.ts"],"names":[],"mappings":""}

package/dist/variables/dynamic.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { DYNAMIC_VARIABLE_CATEGORIES, DYNAMIC_VARIABLE_NAMES, DYNAMIC_VARIABLES, getDynamicVariableDescription, isDynamicVariable, resolveDynamicVariable } from './dynamic.js';
-describe('dynamicVariables', () => {
-    it('registers all Postman-style dynamic variable names with $ prefix', () => {
-        expect(DYNAMIC_VARIABLE_NAMES.length).toBeGreaterThan(100);
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            expect(name.startsWith('$')).toBe(true);
-        }
-    });
-    it('generates a non-empty value for every registered dynamic variable', () => {
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            const value = resolveDynamicVariable(name);
-            expect(value).toBeDefined();
-            expect(value.length).toBeGreaterThan(0);
-        }
-    });
-    it('isDynamicVariable and getDynamicVariableDescription reflect the registry', () => {
-        expect(isDynamicVariable('$guid')).toBe(true);
-        expect(isDynamicVariable('$randomFirstName')).toBe(true);
-        expect(isDynamicVariable('host')).toBe(false);
-        expect(isDynamicVariable('$unknownDynamic')).toBe(false);
-        expect(getDynamicVariableDescription('$guid')).toBe(DYNAMIC_VARIABLES.$guid.description);
-        expect(getDynamicVariableDescription('host')).toBeUndefined();
-    });
-    it('resolveDynamicVariable returns undefined for unknown keys', () => {
-        expect(resolveDynamicVariable('$notARealVariable')).toBeUndefined();
-    });
-    it('$guid and $randomUUID produce uuid-v4 shaped values', () => {
-        const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        expect(resolveDynamicVariable('$guid')).toMatch(uuidPattern);
-        expect(resolveDynamicVariable('$randomUUID')).toMatch(uuidPattern);
-    });
-    it('$timestamp returns a numeric unix seconds string', () => {
-        const value = resolveDynamicVariable('$timestamp');
-        expect(value).toMatch(/^\d+$/);
-        const seconds = Number(value);
-        expect(seconds).toBeGreaterThan(1_500_000_000);
-        expect(seconds).toBeLessThanOrEqual(Math.floor(Date.now() / 1000));
-    });
-    it('$isoTimestamp returns an ISO-8601 UTC string', () => {
-        const value = resolveDynamicVariable('$isoTimestamp');
-        expect(value).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
-        expect(() => new Date(value).toISOString()).not.toThrow();
-    });
-    it('generates fresh values on each resolve call for random variables', () => {
-        const first = resolveDynamicVariable('$randomInt');
-        const second = resolveDynamicVariable('$randomInt');
-        expect(first).toMatch(/^\d+$/);
-        expect(second).toMatch(/^\d+$/);
-    });
-    it('lists every dynamic variable exactly once across documentation categories', () => {
-        const categorized = DYNAMIC_VARIABLE_CATEGORIES.flatMap((category) => category.keys);
-        const unique = new Set(categorized);
-        expect(categorized.length).toBe(DYNAMIC_VARIABLE_NAMES.length);
-        expect(unique.size).toBe(DYNAMIC_VARIABLE_NAMES.length);
-        for (const name of DYNAMIC_VARIABLE_NAMES) {
-            expect(unique.has(name)).toBe(true);
-        }
-    });
-});

package/dist/variables/tokens.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tokens.test.d.ts.map

package/dist/variables/tokens.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.test.d.ts","sourceRoot":"","sources":["../../src/variables/tokens.test.ts"],"names":[],"mappings":""}

package/dist/variables/tokens.test.js

@@ -1,160 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import { getVariableTokenAtOffset, getVariableTooltipContent, resolveVariable, substituteVariables, tokenizeVariables } from './tokens.js';
-/**
- * Builds a test variable row.
- *
- * @param key - Variable name.
- * @param value - Current value.
- * @param defaultValue - Fallback when value is empty.
- * @param share - Whether the variable is shared on export.
- */
-const variable = (key, value, defaultValue = '', share = false) => ({
-    key,
-    value,
-    defaultValue,
-    share
-});
-describe('substituteVariables', () => {
-    it('replaces known variable tokens', () => {
-        const result = substituteVariables('https://{{host}}/api/{{version}}', [
-            variable('host', 'api.example.com'),
-            variable('version', 'v1')
-        ]);
-        expect(result).toBe('https://api.example.com/api/v1');
-    });
-    it('leaves unknown tokens unchanged', () => {
-        const result = substituteVariables('https://{{host}}/{{missing}}', [
-            variable('host', 'api.example.com')
-        ]);
-        expect(result).toBe('https://api.example.com/{{missing}}');
-    });
-    it('substitutes {{ host }} when token key has surrounding whitespace', () => {
-        const result = substituteVariables('https://{{ host }}/users', [
-            variable('host', 'api.example.com')
-        ]);
-        expect(result).toBe('https://api.example.com/users');
-    });
-    it('trims variable keys when building the lookup', () => {
-        const result = substituteVariables('https://{{host}}', [
-            variable('  host  ', 'api.example.com')
-        ]);
-        expect(result).toBe('https://api.example.com');
-    });
-    it('ignores blank-key variables', () => {
-        const result = substituteVariables('https://{{host}}', [
-            variable('   ', 'ignored.example.com'),
-            variable('host', 'api.example.com')
-        ]);
-        expect(result).toBe('https://api.example.com');
-    });
-    it('falls back to defaultValue when value is empty', () => {
-        const result = substituteVariables('https://{{host}}/api', [variable('host', '', 'localhost')]);
-        expect(result).toBe('https://localhost/api');
-    });
-    it('prefers value over defaultValue when both are set', () => {
-        const result = substituteVariables('https://{{host}}/api', [
-            variable('host', 'api.example.com', 'localhost')
-        ]);
-        expect(result).toBe('https://api.example.com/api');
-    });
-    it('substitutes variables in collection header values', () => {
-        const result = substituteVariables('Bearer {{token}}', [variable('token', 'abc123')]);
-        expect(result).toBe('Bearer abc123');
-    });
-    it('resolves dynamic variables when no static variable is defined', () => {
-        const result = substituteVariables('id={{ $guid }}', []);
-        expect(result).not.toContain('{{');
-        expect(result).toMatch(/^id=[0-9a-f-]{36}$/i);
-    });
-    it('prefers static variables over dynamic variables with the same key', () => {
-        const result = substituteVariables('{{$randomInt}}', [variable('$randomInt', '42')]);
-        expect(result).toBe('42');
-    });
-    it('leaves unknown dynamic-style tokens unchanged', () => {
-        const result = substituteVariables('{{$notRegistered}}', []);
-        expect(result).toBe('{{$notRegistered}}');
-    });
-});
-describe('tokenizeVariables', () => {
-    it('returns a single plain-text token when no variables are present', () => {
-        expect(tokenizeVariables('https://api.example.com')).toEqual([
-            { text: 'https://api.example.com' }
-        ]);
-    });
-    it('splits text around variable tokens', () => {
-        expect(tokenizeVariables('https://{{host}}/api/{{version}}')).toEqual([
-            { text: 'https://' },
-            { text: '{{host}}', key: 'host' },
-            { text: '/api/' },
-            { text: '{{version}}', key: 'version' }
-        ]);
-    });
-    it('tokenizeVariables extracts host key from {{ host }} token', () => {
-        expect(tokenizeVariables('https://{{ host }}/users')).toEqual([
-            { text: 'https://' },
-            { text: '{{ host }}', key: 'host' },
-            { text: '/users' }
-        ]);
-    });
-    it('tokenizeVariables recognizes dynamic variable keys with $ prefix', () => {
-        expect(tokenizeVariables('{{$randomUUID}}')).toEqual([
-            { text: '{{$randomUUID}}', key: '$randomUUID' }
-        ]);
-    });
-});
-describe('resolveVariable', () => {
-    it('returns the resolved value for a known key', () => {
-        expect(resolveVariable('host', [variable('host', 'api.example.com')])).toBe('api.example.com');
-    });
-    it('falls back to defaultValue when value is empty', () => {
-        expect(resolveVariable('host', [variable('host', '', 'localhost')])).toBe('localhost');
-    });
-    it('returns undefined for unknown keys', () => {
-        expect(resolveVariable('missing', [variable('host', 'api.example.com')])).toBeUndefined();
-    });
-});
-describe('getVariableTokenAtOffset', () => {
-    const text = 'https://{{host}}/api/{{version}}';
-    it('returns the token when offset is inside a variable placeholder', () => {
-        expect(getVariableTokenAtOffset(text, 10)).toEqual({
-            key: 'host',
-            start: 8,
-            end: 16
-        });
-    });
-    it('returns null when offset is outside any token', () => {
-        expect(getVariableTokenAtOffset(text, 0)).toBeNull();
-        expect(getVariableTokenAtOffset(text, 7)).toBeNull();
-    });
-    it('matches at token start and end boundaries', () => {
-        expect(getVariableTokenAtOffset('{{host}}', 0)?.key).toBe('host');
-        expect(getVariableTokenAtOffset('{{host}}', 8)?.key).toBe('host');
-    });
-    it('matches tokens with whitespace around the key', () => {
-        expect(getVariableTokenAtOffset('https://{{ host }}/users', 10)).toEqual({
-            key: 'host',
-            start: 8,
-            end: 18
-        });
-    });
-});
-describe('getVariableTooltipContent', () => {
-    it('returns resolved static value without muted styling', () => {
-        expect(getVariableTooltipContent('host', [variable('host', 'api.example.com')])).toEqual({
-            text: 'api.example.com',
-            muted: false
-        });
-    });
-    it('returns dynamic description for registered dynamic variables', () => {
-        expect(getVariableTooltipContent('$guid', [])).toEqual({
-            text: 'Dynamic: A uuid-v4 style guid',
-            muted: true
-        });
-    });
-    it('returns Not defined for unknown keys', () => {
-        expect(getVariableTooltipContent('missing', [variable('host', 'api.example.com')])).toEqual({
-            text: 'Not defined',
-            muted: true
-        });
-    });
-});