@outputai/core 0.14.0 → 0.14.1-next.2947341.0

package/src/helpers/object.spec.js

@@ -1,425 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { assignImmutableProperty, clone, deepMerge, deepMergeWithResolver, isPlainObject, shuffleArray } from './object.js';
-
-describe( 'clone', () => {
-  it( 'produces a deep copy without shared references', () => {
-    const original = { a: 1, nested: { b: 2 } };
-    const copied = clone( original );
-
-    copied.nested.b = 3;
-
-    expect( original.nested.b ).toBe( 2 );
-    expect( copied.nested.b ).toBe( 3 );
-    expect( copied ).not.toBe( original );
-  } );
-
-  it( 'deep copies JSON-compatible arrays and objects', () => {
-    const original = {
-      arr: [ 1, { nested: true } ],
-      str: 'value',
-      bool: false,
-      nil: null
-    };
-    const copied = clone( original );
-
-    copied.arr[1].nested = false;
-
-    expect( copied ).toEqual( {
-      arr: [ 1, { nested: false } ],
-      str: 'value',
-      bool: false,
-      nil: null
-    } );
-    expect( original.arr[1].nested ).toBe( true );
-    expect( copied ).not.toBe( original );
-    expect( copied.arr ).not.toBe( original.arr );
-  } );
-
-  it( 'returns primitive JSON values when they can be parsed', () => {
-    expect( clone( null ) ).toBeNull();
-    expect( clone( true ) ).toBe( true );
-    expect( clone( false ) ).toBe( false );
-    expect( clone( 123 ) ).toBe( 123 );
-    expect( clone( 'hello' ) ).toBe( 'hello' );
-  } );
-
-  it( 'returns original values when JSON serialization produces no parseable payload', () => {
-    const sym = Symbol( 'x' );
-    const fn = () => {};
-    class Foo {}
-
-    expect( clone( undefined ) ).toBeUndefined();
-    expect( clone( sym ) ).toBe( sym );
-    expect( clone( fn ) ).toBe( fn );
-    expect( clone( Foo ) ).toBe( Foo );
-    expect( clone( Date ) ).toBe( Date );
-    expect( clone( Object ) ).toBe( Object );
-    expect( clone( Number ) ).toBe( Number );
-  } );
-
-  it( 'returns original values when JSON serialization throws', () => {
-    const circular = { name: 'circular' };
-    circular.self = circular;
-    const bigint = 1n;
-
-    expect( clone( circular ) ).toBe( circular );
-    expect( clone( bigint ) ).toBe( bigint );
-  } );
-
-  it( 'keeps JSON.stringify semantics for special numeric values', () => {
-    expect( clone( NaN ) ).toBeNull();
-    expect( clone( Infinity ) ).toBeNull();
-    expect( clone( -Infinity ) ).toBeNull();
-  } );
-
-  it( 'keeps JSON.stringify semantics for non-plain object instances', () => {
-    const date = new Date( '2025-01-01T00:00:00.000Z' );
-
-    expect( clone( date ) ).toBe( '2025-01-01T00:00:00.000Z' );
-    expect( clone( /abc/ ) ).toEqual( {} );
-    expect( clone( new Map( [ [ 'a', 1 ] ] ) ) ).toEqual( {} );
-    expect( clone( new Set( [ 1, 2 ] ) ) ).toEqual( {} );
-  } );
-
-  it( 'drops object properties that JSON.stringify omits', () => {
-    const sym = Symbol( 'x' );
-    const original = {
-      kept: 'yes',
-      missing: undefined,
-      fn: () => {},
-      sym
-    };
-
-    expect( clone( original ) ).toEqual( { kept: 'yes' } );
-  } );
-} );
-
-describe( 'deepMerge', () => {
-  it( 'returns a clone when only the base object is provided', () => {
-    const a = {
-      nested: { value: 1 }
-    };
-    const result = deepMerge( a );
-
-    a.nested.value = 2;
-
-    expect( result ).toEqual( {
-      nested: { value: 1 }
-    } );
-  } );
-
-  it( 'Throws when first argument is not a plain object', () => {
-    expect( () => deepMerge( null ) ).toThrow( Error );
-  } );
-
-  it( 'merges multiple objects from left to right using rightmost values', () => {
-    expect( deepMerge(
-      {
-        a: 1,
-        nested: {
-          a: 'base',
-          kept: true
-        }
-      },
-      {
-        b: 2,
-        nested: {
-          a: 'first',
-          b: 'first'
-        }
-      },
-      {
-        a: 3,
-        nested: {
-          b: 'second',
-          c: 'second'
-        }
-      }
-    ) ).toEqual( {
-      a: 3,
-      b: 2,
-      nested: {
-        a: 'first',
-        b: 'second',
-        c: 'second',
-        kept: true
-      }
-    } );
-  } );
-
-  it( 'ignores non-object values among multiple overlays', () => {
-    expect( deepMerge(
-      { a: 1 },
-      null,
-      { b: 2 },
-      undefined,
-      { a: 3 }
-    ) ).toEqual( {
-      a: 3,
-      b: 2
-    } );
-  } );
-} );
-
-describe( 'deepMergeWithResolver', () => {
-  it( 'returns a clone when only the base object and resolver are provided', () => {
-    const a = {
-      nested: { value: 1 }
-    };
-    const result = deepMergeWithResolver( a, ( x, y ) => x + y );
-
-    a.nested.value = 2;
-
-    expect( result ).toEqual( {
-      nested: { value: 1 }
-    } );
-  } );
-
-  it( 'uses resolver for existing leaf values, including nested leaves', () => {
-    const a = {
-      cost: { total: 1 },
-      tokens: { total: 2, input: 3 }
-    };
-    const b = {
-      cost: { total: 4 },
-      tokens: { total: 5, input: 6, output: 7 }
-    };
-
-    expect( deepMergeWithResolver( a, b, ( x, y ) => x + y ) ).toEqual( {
-      cost: { total: 5 },
-      tokens: { total: 7, input: 9, output: 7 }
-    } );
-  } );
-
-  it( 'copies values from "b" when they do not exist in "a"', () => {
-    const resolver = vi.fn( ( x, y ) => x + y );
-
-    expect( deepMergeWithResolver( { a: 1 }, { b: 2, nested: { c: 3 } }, resolver ) ).toEqual( {
-      a: 1,
-      b: 2,
-      nested: { c: 3 }
-    } );
-    expect( resolver ).not.toHaveBeenCalled();
-  } );
-
-  it( 'keeps extra values from "a" when absent from "b"', () => {
-    expect( deepMergeWithResolver( { a: 1, nested: { kept: 2 } }, { b: 3 }, ( x, y ) => x + y ) ).toEqual( {
-      a: 1,
-      nested: { kept: 2 },
-      b: 3
-    } );
-  } );
-
-  it( 'returns a clone of "a" when "b" is not an object', () => {
-    const a = { nested: { value: 1 } };
-    const result = deepMergeWithResolver( a, null, ( x, y ) => x + y );
-
-    a.nested.value = 2;
-    expect( result ).toEqual( { nested: { value: 1 } } );
-  } );
-
-  it( 'throws when first argument is not a plain object', () => {
-    expect( () => deepMergeWithResolver( null, {}, ( x, y ) => x + y ) ).toThrow( Error );
-    expect( () => deepMergeWithResolver( [], {}, ( x, y ) => x + y ) ).toThrow( Error );
-    expect( () => deepMergeWithResolver( 'a', {}, ( x, y ) => x + y ) ).toThrow( Error );
-  } );
-
-  it( 'throws when last argument is not a resolver function', () => {
-    expect( () => deepMergeWithResolver( { a: 1 }, { a: 2 } ) )
-      .toThrow( 'Last argument (resolver) is not a function.' );
-  } );
-
-  it( 'merges multiple objects using the resolver from left to right', () => {
-    const resolver = vi.fn( ( x, y ) => `${ x }:${ y }` );
-
-    expect( deepMergeWithResolver(
-      {
-        a: 'base',
-        nested: {
-          count: 1,
-          kept: 'yes'
-        }
-      },
-      {
-        a: 'first',
-        nested: {
-          count: 2,
-          firstOnly: true
-        }
-      },
-      {
-        a: 'second',
-        nested: {
-          count: 3,
-          secondOnly: true
-        }
-      },
-      resolver
-    ) ).toEqual( {
-      a: 'base:first:second',
-      nested: {
-        count: '1:2:3',
-        firstOnly: true,
-        kept: 'yes',
-        secondOnly: true
-      }
-    } );
-    expect( resolver ).toHaveBeenCalledTimes( 4 );
-  } );
-
-  it( 'ignores non-object values among multiple resolver overlays', () => {
-    const resolver = vi.fn( ( x, y ) => x + y );
-
-    expect( deepMergeWithResolver(
-      { a: 1 },
-      null,
-      { a: 2 },
-      undefined,
-      { b: 3 },
-      resolver
-    ) ).toEqual( {
-      a: 3,
-      b: 3
-    } );
-    expect( resolver ).toHaveBeenCalledOnce();
-  } );
-} );
-
-describe( 'isPlainObject', () => {
-  it( 'Detects plain objects', () => {
-    expect( isPlainObject( {} ) ).toBe( true );
-    expect( isPlainObject( { a: 1 } ) ).toBe( true );
-    expect( isPlainObject( new Object() ) ).toBe( true );
-    expect( isPlainObject( new Object( { foo: 'bar' } ) ) ).toBe( true );
-    expect( isPlainObject( Object.create( {}.constructor.prototype ) ) ).toBe( true );
-    expect( isPlainObject( Object.create( Object.prototype ) ) ).toBe( true );
-  } );
-
-  it( 'Detects plain objects with different prototypes than Object.prototype', () => {
-    // Object with null prototype
-    expect( isPlainObject( Object.create( null ) ) ).toBe( true );
-  } );
-
-  it( 'Detects non plain objects that had their __proto__ mutated to Object.prototype or null', () => {
-    class Foo {}
-    const x = new Foo();
-    x.__proto__ = Object.prototype;
-    expect( isPlainObject( x ) ).toBe( true );
-
-    const y = new Foo();
-    y.__proto__ = null;
-    expect( isPlainObject( y ) ).toBe( true );
-  } );
-
-  it( 'Returns false for object which the prototype is not Object.prototype or null', () => {
-    // Object which the prototype is a plain {}
-    expect( isPlainObject( Object.create( {} ) ) ).toBe( false );
-    // Object which prototype is a another object with null prototype
-    expect( isPlainObject( Object.create( Object.create( null ) ) ) ).toBe( false );
-  } );
-
-  it( 'Returns false for functions', () => {
-    expect( isPlainObject( Function ) ).toBe( false );
-    expect( isPlainObject( () => {} ) ).toBe( false );
-    expect( isPlainObject( class Foo {} ) ).toBe( false );
-    expect( isPlainObject( Number.constructor ) ).toBe( false );
-    expect( isPlainObject( Number.constructor.prototype ) ).toBe( false );
-  } );
-
-  it( 'Returns false for arrays', () => {
-    expect( isPlainObject( [ 1, 2, 3 ] ) ).toBe( false );
-    expect( isPlainObject( [] ) ).toBe( false );
-    expect( isPlainObject( Array( 3 ) ) ).toBe( false );
-  } );
-
-  it( 'Returns false for primitives', () => {
-    expect( isPlainObject( null ) ).toBe( false );
-    expect( isPlainObject( undefined ) ).toBe( false );
-    expect( isPlainObject( false ) ).toBe( false );
-    expect( isPlainObject( true ) ).toBe( false );
-    expect( isPlainObject( 1 ) ).toBe( false );
-    expect( isPlainObject( 0 ) ).toBe( false );
-    expect( isPlainObject( '' ) ).toBe( false );
-    expect( isPlainObject( 'foo' ) ).toBe( false );
-    expect( isPlainObject( Symbol( 'foo' ) ) ).toBe( false );
-    expect( isPlainObject( Symbol.for( 'foo' ) ) ).toBe( false );
-  } );
-
-  it( 'Returns true for built in objects', () => {
-    expect( isPlainObject( Math ) ).toBe( true );
-    expect( isPlainObject( JSON ) ).toBe( true );
-  } );
-
-  it( 'Returns false for built in types', () => {
-    expect( isPlainObject( String ) ).toBe( false );
-    expect( isPlainObject( Number ) ).toBe( false );
-    expect( isPlainObject( Date ) ).toBe( false );
-  } );
-
-  it( 'Returns false for other instance where prototype is not object or null', () => {
-    expect( isPlainObject( /foo/ ) ).toBe( false );
-    expect( isPlainObject( new RegExp( 'foo' ) ) ).toBe( false );
-    expect( isPlainObject( new Date() ) ).toBe( false );
-    class Foo {}
-    expect( isPlainObject( new Foo() ) ).toBe( false );
-    expect( isPlainObject( Object.create( ( class Foo {} ).prototype ) ) ).toBe( false );
-  } );
-
-  it( 'Returns false if tries to change the prototype to simulate an object', () => {
-    function Bar() {}
-    Bar.prototype = Object.create( null );
-    expect( isPlainObject( new Bar() ) ).toBe( false );
-  } );
-
-  it( 'Returns false if object proto was mutated to anything else than object or null', () => {
-    const zum = {};
-    zum.__proto__ = Number.prototype;
-    expect( isPlainObject( zum ) ).toBe( false );
-  } );
-} );
-
-describe( 'assignImmutableProperty', () => {
-  it( 'defines a non-writable, non-configurable, non-enumerable property', () => {
-    const obj = {};
-    const key = Symbol( 'metadata' );
-    const value = { name: 'test' };
-
-    expect( assignImmutableProperty( obj, key, value ) ).toBe( obj );
-    expect( obj[key] ).toBe( value );
-    expect( Object.getOwnPropertyDescriptor( obj, key ) ).toEqual( {
-      value,
-      writable: false,
-      configurable: false,
-      enumerable: false
-    } );
-    expect( Object.keys( obj ) ).toEqual( [] );
-  } );
-
-  it( 'prevents reassignment and redefinition', () => {
-    const obj = {};
-    const key = 'metadata';
-
-    assignImmutableProperty( obj, key, 'original' );
-
-    expect( () => {
-      obj[key] = 'updated';
-    } ).toThrow( TypeError );
-    expect( () => {
-      Object.defineProperty( obj, key, { value: 'updated' } );
-    } ).toThrow( TypeError );
-    expect( obj[key] ).toBe( 'original' );
-  } );
-} );
-
-describe( 'shuffleArray', () => {
-  it( 'returns a shuffled copy based on random sort keys', () => {
-    vi.spyOn( Math, 'random' )
-      .mockReturnValueOnce( 0.4 )
-      .mockReturnValueOnce( 0.1 )
-      .mockReturnValueOnce( 0.3 );
-    const arr = [ 'a', 'b', 'c' ];
-
-    expect( shuffleArray( arr ) ).toEqual( [ 'b', 'c', 'a' ] );
-    expect( arr ).toEqual( [ 'a', 'b', 'c' ] );
-  } );
-} );

package/src/helpers/promise.spec.js

@@ -1,62 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { sleepCancellable } from './promise.js';
-
-// Long enough that a sleep reaching it means the abort was not honored and the test times out.
-const neverElapses = 60000;
-
-describe( 'sleepCancellable', () => {
-  it( 'resolves only once the timeout elapses', async () => {
-    const order = [];
-    const sleeping = sleepCancellable( 10 ).then( () => order.push( 'slept' ) );
-
-    await Promise.resolve();
-    expect( order ).toEqual( [] );
-
-    await sleeping;
-    expect( order ).toEqual( [ 'slept' ] );
-  } );
-
-  it( 'resolves without a signal', async () => {
-    await expect( sleepCancellable( 10 ) ).resolves.toBeUndefined();
-  } );
-
-  it( 'resolves immediately when the signal is already aborted', async () => {
-    const controller = new AbortController();
-    controller.abort();
-
-    await expect( sleepCancellable( neverElapses, controller.signal ) ).resolves.toBeUndefined();
-  } );
-
-  it( 'resolves as soon as the signal aborts mid sleep', async () => {
-    const controller = new AbortController();
-    const sleeping = sleepCancellable( neverElapses, controller.signal );
-
-    controller.abort();
-
-    await expect( sleeping ).resolves.toBeUndefined();
-  } );
-
-  it( 'swallows the abort reason instead of rejecting with it', async () => {
-    const controller = new AbortController();
-    const sleeping = sleepCancellable( neverElapses, controller.signal );
-
-    controller.abort( new Error( 'shutting down' ) );
-
-    await expect( sleeping ).resolves.toBeUndefined();
-  } );
-
-  it( 'rethrows a rejection that is not an abort', async () => {
-    const failure = new Error( 'timer failed' );
-    vi.doMock( 'node:timers/promises', () => ( { setTimeout: () => Promise.reject( failure ) } ) );
-    vi.resetModules();
-
-    try {
-      const { sleepCancellable: sleeping } = await import( './promise.js' );
-
-      await expect( sleeping( 10 ) ).rejects.toBe( failure );
-    } finally {
-      vi.doUnmock( 'node:timers/promises' );
-      vi.resetModules();
-    }
-  } );
-} );

package/src/helpers/redact.spec.js

@@ -1,66 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { redactHeaders, redactUrl } from './redact.js';
-
-describe( 'redactUrl', () => {
-  it( 'redacts credentials, query values, and the fragment while preserving URL structure', () => {
-    const result = redactUrl( 'https://user:password@example.com/models?model=gpt-5&token=secret#debug' );
-
-    expect( result ).toBe( 'https://***:***@example.com/models?model=***&token=***#***' );
-  } );
-
-  it( 'preserves duplicate query parameters and their order', () => {
-    const result = redactUrl( 'https://example.com/search?tag=first&tag=second&empty=#results' );
-
-    expect( result ).toBe( 'https://example.com/search?tag=***&tag=***&empty=***#***' );
-  } );
-
-  it( 'returns URLs without redacted components unchanged', () => {
-    expect( redactUrl( 'https://example.com/path' ) ).toBe( 'https://example.com/path' );
-  } );
-
-  it( 'does not mutate URL instances', () => {
-    const originalValue = 'ftp://user:password@example.com/file.txt?download=true#details';
-    const url = new URL( originalValue );
-
-    expect( redactUrl( url ) ).toBe( 'ftp://***:***@example.com/file.txt?download=***#***' );
-    expect( url.toString() ).toBe( originalValue );
-  } );
-} );
-
-describe( 'redactHeaders', () => {
-  it( 'redacts sensitive header names', () => {
-    const result = redactHeaders( {
-      Authorization: 'Bearer token',
-      'X-Api-Key': 'api-key',
-      Cookie: 'session=id',
-      'x-client-secret': 'secret'
-    } );
-
-    expect( result ).toEqual( {
-      Authorization: '[REDACTED]',
-      'X-Api-Key': '[REDACTED]',
-      Cookie: '[REDACTED]',
-      'x-client-secret': '[REDACTED]'
-    } );
-  } );
-
-  it( 'preserves non-sensitive header names and ignored false positives', () => {
-    const result = redactHeaders( {
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-      'x-csrf-token': 'csrf-token',
-      'public-key-pins': 'pin'
-    } );
-
-    expect( result ).toEqual( {
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-      'x-csrf-token': 'csrf-token',
-      'public-key-pins': 'pin'
-    } );
-  } );
-
-  it( 'handles empty headers', () => {
-    expect( redactHeaders( {} ) ).toEqual( {} );
-  } );
-} );

package/src/helpers/string.spec.js

@@ -1,99 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isUrl, toUrlSafeBase64, rxEscape } from './string.js';
-
-describe( 'toUrlSafeBase64', () => {
-  const urlSafeAlphabet = /^[A-Za-z0-9_-]+$/;
-
-  it( 'returns a string for a valid UUID', () => {
-    const uuid = '550e8400-e29b-41d4-a716-446655440000';
-    expect( typeof toUrlSafeBase64( uuid ) ).toBe( 'string' );
-    expect( toUrlSafeBase64( uuid ).length ).toBeGreaterThan( 0 );
-  } );
-
-  it( 'output length is 21 or 22 for a standard UUID', () => {
-    const uuid = '550e8400-e29b-41d4-a716-446655440000';
-    const out = toUrlSafeBase64( uuid );
-    expect( out.length ).toBeGreaterThanOrEqual( 21 );
-    expect( out.length ).toBeLessThanOrEqual( 22 );
-  } );
-
-  it( 'output contains only url-safe alphabet characters', () => {
-    const uuid = '550e8400-e29b-41d4-a716-446655440000';
-    const out = toUrlSafeBase64( uuid );
-    expect( out ).toMatch( urlSafeAlphabet );
-  } );
-
-  it( 'is deterministic for the same UUID', () => {
-    const uuid = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-    expect( toUrlSafeBase64( uuid ) ).toBe( toUrlSafeBase64( uuid ) );
-  } );
-
-  it( 'different UUIDs produce different strings', () => {
-    const a = toUrlSafeBase64( '550e8400-e29b-41d4-a716-446655440000' );
-    const b = toUrlSafeBase64( '6ba7b810-9dad-11d1-80b4-00c04fd430c8' );
-    expect( a ).not.toBe( b );
-  } );
-
-  it( 'strips hyphens and encodes hex (same as 32-char hex)', () => {
-    const withHyphens = '550e8400-e29b-41d4-a716-446655440000';
-    const hexOnly = '550e8400e29b41d4a716446655440000';
-    expect( toUrlSafeBase64( withHyphens ) ).toBe( toUrlSafeBase64( hexOnly ) );
-  } );
-} );
-
-describe( 'rxEscape', () => {
-  it( 'escapes all regexp metacharacters', () => {
-    expect( rxEscape( '.*+?^${}()|[]\\' ) ).toBe( '\\.\\*\\+\\?\\^\\$\\{\\}\\(\\)\\|\\[\\]\\\\' );
-  } );
-
-  it( 'keeps file URL paths matchable as literal regexp input', () => {
-    const path = 'file://foo/bar';
-    const rx = new RegExp( `^${rxEscape( path )}$` );
-
-    expect( rx.test( path ) ).toBe( true );
-    expect( rx.test( 'file://foo/bar/baz' ) ).toBe( false );
-  } );
-
-  it( 'keeps Windows paths matchable as literal regexp input', () => {
-    const path = String.raw`C:\foo\bar`;
-    const rx = new RegExp( `^${rxEscape( path )}$` );
-
-    expect( rx.test( path ) ).toBe( true );
-    expect( rx.test( String.raw`C:\foo\bar\baz` ) ).toBe( false );
-  } );
-} );
-
-describe( 'isUrl', () => {
-  it.each( [
-    'https://example.com/path?token=secret#section',
-    'ftp://user:password@example.com/file.txt',
-    'ftps://example.com/file.txt',
-    'git+ssh://example.com/repository',
-    'custom.protocol-v2://example.com/resource'
-  ] )( 'accepts a valid URL starting with a protocol: %s', value => {
-    expect( isUrl( value ) ).toBe( true );
-  } );
-
-  it.each( [
-    'Error: fetch failed',
-    'TypeError: invalid input',
-    'mailto:user@example.com',
-    'urn:isbn:978014',
-    'data:text/plain,hello'
-  ] )( 'rejects non-authority URI-like strings: %s', value => {
-    expect( isUrl( value ) ).toBe( false );
-  } );
-
-  it.each( [
-    '//example.com/path',
-    '/relative/path',
-    'https://',
-    'not a URL'
-  ] )( 'rejects malformed or relative values: %s', value => {
-    expect( isUrl( value ) ).toBe( false );
-  } );
-
-  it.each( [ undefined, null, 42, new URL( 'https://example.com' ) ] )( 'rejects non-string values', value => {
-    expect( isUrl( value ) ).toBe( false );
-  } );
-} );