@radio-garden/ditojs-utils 2.85.0-0.5067ad799

package/types/tests/base.test-d.ts

@@ -0,0 +1,172 @@
+import { assertType, describe, expectTypeOf, it } from 'vitest'
+import type {
+  isArray,
+  isPlainObject,
+  isFunction,
+  isNumber,
+  isString,
+  isBoolean,
+  isDate,
+  isRegExp,
+  isPromise,
+  isAsync,
+  isArrayLike,
+  asObject,
+  asArray,
+  asFunction
+} from '../index.d.ts'
+
+describe('type guards', () => {
+  it('isArray narrows unknown to any[]', () => {
+    const guard = {} as typeof isArray
+    const val: unknown = []
+    if (guard(val)) {
+      expectTypeOf(val).toEqualTypeOf<any[]>()
+    }
+  })
+
+  it('isPlainObject narrows union to record', () => {
+    const guard = {} as typeof isPlainObject
+    const val: string | Record<string, unknown> = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toEqualTypeOf<Record<string, unknown>>()
+    }
+  })
+
+  it('isFunction narrows to callable', () => {
+    const guard = {} as typeof isFunction
+    const val: string | (() => void) = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toBeCallableWith()
+    }
+  })
+
+  it('isNumber narrows union', () => {
+    const guard = {} as typeof isNumber
+    const val: string | number = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toBeNumber()
+    }
+  })
+
+  it('isString narrows union', () => {
+    const guard = {} as typeof isString
+    const val: number | string = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      assertType<string | String>(val)
+    }
+  })
+
+  it('isBoolean narrows union', () => {
+    const guard = {} as typeof isBoolean
+    const val: string | boolean = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toBeBoolean()
+    }
+  })
+
+  it('isDate narrows to Date', () => {
+    const guard = {} as typeof isDate
+    const val: string | Date = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toEqualTypeOf<Date>()
+    }
+  })
+
+  it('isRegExp narrows to RegExp', () => {
+    const guard = {} as typeof isRegExp
+    const val: string | RegExp = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toEqualTypeOf<RegExp>()
+    }
+  })
+
+  it('isPromise narrows to Promise', () => {
+    const guard = {} as typeof isPromise
+    const val: string | Promise<number> = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      assertType<Promise<any>>(val)
+    }
+  })
+
+  it('isAsync narrows to async function', () => {
+    const guard = {} as typeof isAsync
+    const val: (() => void) | (() => Promise<string>) = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      assertType<(...args: any[]) => Promise<any>>(val)
+    }
+  })
+
+  it('isArrayLike narrows to ArrayLike', () => {
+    const guard = {} as typeof isArrayLike
+    const val: string | ArrayLike<number> = {} as any
+    if (guard(val)) {
+      expectTypeOf(val).not.toBeAny()
+      expectTypeOf(val).toHaveProperty('length')
+    }
+  })
+})
+
+describe('asObject', () => {
+  it('preserves object types', () => {
+    const fn = {} as typeof asObject
+    const obj = { a: 1 }
+    const result = fn(obj)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toHaveProperty('a')
+  })
+
+  it('returns null/undefined as-is', () => {
+    const fn = {} as typeof asObject
+    expectTypeOf(fn(null)).toBeNull()
+    expectTypeOf(fn(undefined)).toBeUndefined()
+  })
+})
+
+describe('asArray', () => {
+  it('passes arrays through unchanged', () => {
+    const fn = {} as typeof asArray
+    const arr = [1, 2, 3]
+    const result = fn(arr)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<number[]>()
+  })
+
+  it('wraps non-array in array', () => {
+    const fn = {} as typeof asArray
+    const result = fn('hello')
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<string[]>()
+  })
+
+  it('returns empty array for undefined', () => {
+    const fn = {} as typeof asArray
+    expectTypeOf(fn(undefined)).toEqualTypeOf<never[]>()
+  })
+})
+
+describe('asFunction', () => {
+  it('passes functions through unchanged', () => {
+    const fn = {} as typeof asFunction
+    const cb = (x: number) => x * 2
+    const result = fn(cb)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<(x: number) => number>()
+  })
+
+  it('wraps non-function in thunk', () => {
+    const fn = {} as typeof asFunction
+    const result = fn(42)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<() => number>()
+  })
+})

package/types/tests/datapath.test-d.ts

@@ -0,0 +1,75 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import type {
+  getValueAtDataPath,
+  getEntriesAtDataPath,
+  setValueAtDataPath,
+  setDataPathEntries,
+  normalizeDataPath,
+  parseDataPath
+} from '../index.d.ts'
+
+describe('getValueAtDataPath', () => {
+  it('error handler receives correct params', () => {
+    const fn = {} as typeof getValueAtDataPath
+    fn({}, 'a.b', (obj, part, index) => {
+      expectTypeOf(part).not.toBeAny()
+      expectTypeOf(part).toBeString()
+      expectTypeOf(index).not.toBeAny()
+      expectTypeOf(index).toBeNumber()
+    })
+  })
+})
+
+describe('getEntriesAtDataPath', () => {
+  it('error handler receives correct params', () => {
+    const fn = {} as typeof getEntriesAtDataPath
+    fn({}, 'items.*', (obj, part, index) => {
+      expectTypeOf(part).not.toBeAny()
+      expectTypeOf(part).toBeString()
+      expectTypeOf(index).not.toBeAny()
+      expectTypeOf(index).toBeNumber()
+    })
+  })
+})
+
+describe('setValueAtDataPath', () => {
+  it('preserves the object type', () => {
+    const fn = {} as typeof setValueAtDataPath
+    const obj = { a: { b: 1 } }
+    const result = fn(obj, 'a.b', 2)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<typeof obj>()
+  })
+})
+
+describe('setDataPathEntries', () => {
+  it('preserves the object type', () => {
+    const fn = {} as typeof setDataPathEntries
+    const obj = { x: 1, y: 2 }
+    const result = fn(obj, { x: 10 })
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<typeof obj>()
+  })
+})
+
+describe('parseDataPath', () => {
+  it('returns string array from string or array input', () => {
+    const fn = {} as typeof parseDataPath
+    const fromString = fn('a.b.c')
+    const fromArray = fn(['a', 'b'])
+    expectTypeOf(fromString).not.toBeAny()
+    expectTypeOf(fromString).toEqualTypeOf<string[]>()
+    expectTypeOf(fromArray).toEqualTypeOf<string[]>()
+  })
+})
+
+describe('normalizeDataPath', () => {
+  it('returns string from string or array input', () => {
+    const fn = {} as typeof normalizeDataPath
+    const fromString = fn('a.b')
+    const fromArray = fn(['a', 'b'])
+    expectTypeOf(fromString).not.toBeAny()
+    expectTypeOf(fromString).toBeString()
+    expectTypeOf(fromArray).toBeString()
+  })
+})

package/types/tests/function.test-d.ts

@@ -0,0 +1,137 @@
+import { assertType, describe, expectTypeOf, it } from 'vitest'
+import type {
+  debounce,
+  debounceAsync,
+  toAsync,
+  toCallback,
+  toPromiseCallback
+} from '../index.d.ts'
+
+describe('debounce', () => {
+  it('preserves original function signature', () => {
+    const fn = {} as typeof debounce
+    const original = (x: number, y: string) => x + y.length
+    const debounced = fn(original, 100)
+    expectTypeOf(debounced).not.toBeAny()
+    expectTypeOf(debounced).toBeCallableWith(1, 'hello')
+    expectTypeOf(debounced(1, 'a')).toBeNumber()
+  })
+
+  it('adds cancel method', () => {
+    const fn = {} as typeof debounce
+    const debounced = fn(() => {}, 100)
+    expectTypeOf(debounced.cancel).not.toBeAny()
+    expectTypeOf(debounced.cancel).toBeFunction()
+    expectTypeOf(debounced.cancel()).toBeBoolean()
+  })
+
+  it('accepts options object', () => {
+    const fn = {} as typeof debounce
+    fn((x: number) => x, { delay: 100, immediate: true })
+  })
+
+  it('rejects wrong argument types', () => {
+    const fn = {} as typeof debounce
+    const debounced = fn((x: number) => x, 100)
+    // @ts-expect-error - string not assignable to number
+    debounced('wrong')
+  })
+})
+
+describe('debounceAsync', () => {
+  it('preserves async function signature', () => {
+    const fn = {} as typeof debounceAsync
+    const original = async (id: number) => ({
+      id,
+      name: 'test'
+    })
+    const debounced = fn(original, 200)
+    expectTypeOf(debounced).not.toBeAny()
+    expectTypeOf(debounced).toBeCallableWith(1)
+    expectTypeOf(debounced(1))
+      .resolves.toHaveProperty('name')
+  })
+})
+
+describe('toAsync', () => {
+  it('converts error-first callback to promise', () => {
+    const fn = {} as typeof toAsync
+    const readFile = (
+      path: string,
+      cb: (err: any, data: Buffer) => void
+    ) => {}
+    const asyncReadFile = fn(readFile)
+    expectTypeOf(asyncReadFile).not.toBeAny()
+    expectTypeOf(asyncReadFile).toBeCallableWith('test.txt')
+    expectTypeOf(asyncReadFile('x'))
+      .resolves.toEqualTypeOf<Buffer>()
+  })
+
+  it('converts void callback to promise', () => {
+    const fn = {} as typeof toAsync
+    const doThing = (cb: (err?: any) => void) => {}
+    const asyncDoThing = fn(doThing)
+    expectTypeOf(asyncDoThing).not.toBeAny()
+    expectTypeOf(asyncDoThing())
+      .resolves.toEqualTypeOf<void>()
+  })
+
+  it('handles multiple arguments', () => {
+    const fn = {} as typeof toAsync
+    const write = (
+      path: string,
+      data: string,
+      cb: (err: any, written: number) => void
+    ) => {}
+    const asyncWrite = fn(write)
+    expectTypeOf(asyncWrite).not.toBeAny()
+    expectTypeOf(asyncWrite).toBeCallableWith('f', 'data')
+    expectTypeOf(asyncWrite('f', 'd'))
+      .resolves.toBeNumber()
+  })
+})
+
+describe('toCallback', () => {
+  it('converts async fn to callback style', () => {
+    const fn = {} as typeof toCallback
+    const asyncFn = async (x: number): Promise<string> => `${x}`
+    const cbFn = fn(asyncFn)
+    expectTypeOf(cbFn).not.toBeAny()
+    expectTypeOf(cbFn).toBeCallableWith(
+      42,
+      (err: any, result: string) => {}
+    )
+  })
+
+  it('handles void return', () => {
+    const fn = {} as typeof toCallback
+    const asyncFn = async (x: string): Promise<void> => {}
+    const cbFn = fn(asyncFn)
+    expectTypeOf(cbFn).not.toBeAny()
+    expectTypeOf(cbFn).toBeCallableWith(
+      'hello',
+      (err: any) => {}
+    )
+  })
+})
+
+describe('toPromiseCallback', () => {
+  it('returns callback matching resolve/reject types', () => {
+    const fn = {} as typeof toPromiseCallback
+    const cb = fn<string, Error>(
+      value => {
+        expectTypeOf(value).not.toBeAny()
+        expectTypeOf(value).toBeString()
+      },
+      reason => {
+        expectTypeOf(reason).not.toBeAny()
+        expectTypeOf(reason).toEqualTypeOf<Error>()
+      }
+    )
+    expectTypeOf(cb).not.toBeAny()
+    expectTypeOf(cb).toBeCallableWith(
+      new Error(),
+      'result'
+    )
+  })
+})

package/types/tests/object.test-d.ts

@@ -0,0 +1,190 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import type {
+  clone,
+  groupBy,
+  mergeDeeply,
+  assignDeeply,
+  pick,
+  pickBy,
+  mapKeys,
+  mapValues
+} from '../index.d.ts'
+
+describe('clone', () => {
+  it('preserves the input type', () => {
+    const fn = {} as typeof clone
+    const obj = { a: 1, b: 'hello' }
+    const result = fn(obj)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<typeof obj>()
+  })
+
+  it('processValue callback receives correct type', () => {
+    const fn = {} as typeof clone
+    fn(
+      { x: 1 },
+      {
+        processValue(value) {
+          expectTypeOf(value).not.toBeAny()
+          expectTypeOf(value).toEqualTypeOf<{ x: number }>()
+          return value
+        }
+      }
+    )
+  })
+})
+
+describe('groupBy', () => {
+  it('infers callback param type from array', () => {
+    const fn = {} as typeof groupBy
+    const items = [
+      { name: 'a', category: 'x' },
+      { name: 'b', category: 'y' }
+    ]
+    fn(items, item => {
+      expectTypeOf(item).not.toBeAny()
+      expectTypeOf(item).toEqualTypeOf<{
+        name: string
+        category: string
+      }>()
+      return item.category
+    })
+  })
+
+  it('accepts property key shorthand', () => {
+    const fn = {} as typeof groupBy
+    const items = [{ type: 'a' as const, v: 1 }]
+    const result = fn(items, 'type')
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<
+      Record<string, { type: 'a'; v: number }[]>
+    >()
+  })
+
+  it('works with record input', () => {
+    const fn = {} as typeof groupBy
+    const obj: Record<string, { group: string }> = {}
+    fn(obj, item => {
+      expectTypeOf(item).not.toBeAny()
+      expectTypeOf(item).toEqualTypeOf<{ group: string }>()
+      return item.group
+    })
+  })
+})
+
+describe('mergeDeeply', () => {
+  it('produces intersection of two args', () => {
+    const fn = {} as typeof mergeDeeply
+    const result = fn(
+      {} as { a: number },
+      {} as { b: string }
+    )
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toHaveProperty('a')
+    expectTypeOf(result).toHaveProperty('b')
+  })
+
+  it('produces intersection of three args', () => {
+    const fn = {} as typeof mergeDeeply
+    const result = fn(
+      {} as { a: number },
+      {} as { b: string },
+      {} as { c: boolean }
+    )
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toHaveProperty('a')
+    expectTypeOf(result).toHaveProperty('b')
+    expectTypeOf(result).toHaveProperty('c')
+  })
+})
+
+describe('assignDeeply', () => {
+  it('produces intersection of two args', () => {
+    const fn = {} as typeof assignDeeply
+    const result = fn(
+      {} as { a: number },
+      {} as { b: string }
+    )
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toHaveProperty('a')
+    expectTypeOf(result).toHaveProperty('b')
+  })
+})
+
+describe('pick', () => {
+  it('returns union of argument types', () => {
+    const fn = {} as typeof pick
+    const result = fn(
+      {} as number | undefined,
+      {} as string
+    )
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<number | undefined | string>()
+  })
+})
+
+describe('pickBy', () => {
+  it('callback receives value, key, and object', () => {
+    const fn = {} as typeof pickBy
+    const obj: Record<string, number> = {}
+    fn(obj, (value, key, source) => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(value).toBeNumber()
+      expectTypeOf(key).toBeString()
+      expectTypeOf(source).toEqualTypeOf(obj)
+      return value > 1
+    })
+  })
+
+  it('returns partial of input type', () => {
+    const fn = {} as typeof pickBy
+    const obj = {} as { a: number; b: number }
+    const result = fn(obj, () => true)
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<Partial<{ a: number; b: number }>>()
+  })
+})
+
+describe('mapKeys', () => {
+  it('callback receives key, value, and object', () => {
+    const fn = {} as typeof mapKeys
+    const obj: Record<string, number> = {}
+    fn(obj, (key, value, source) => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(key).toBeString()
+      expectTypeOf(value).toBeNumber()
+      expectTypeOf(source).toEqualTypeOf(obj)
+      return `prefix_${key}`
+    })
+  })
+})
+
+describe('mapValues', () => {
+  it('callback receives value, key, and object', () => {
+    const fn = {} as typeof mapValues
+    const obj: Record<string, number> = {}
+    fn(obj, (value, key, source) => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(value).toBeNumber()
+      expectTypeOf(key).toBeString()
+      expectTypeOf(source).toEqualTypeOf(obj)
+      return String(value)
+    })
+  })
+
+  it('result values match callback return type', () => {
+    const fn = {} as typeof mapValues
+    const obj: Record<string, number> = {}
+    const result = fn(obj, value => String(value))
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<Record<string, string>>()
+  })
+
+  it('property shorthand extracts nested value', () => {
+    const fn = {} as typeof mapValues
+    const obj: Record<string, { nested: number }> = {}
+    const result = fn(obj, 'nested')
+    expectTypeOf(result).not.toBeAny()
+    expectTypeOf(result).toEqualTypeOf<Record<string, number>>()
+  })
+})

package/types/tests/promise.test-d.ts

@@ -0,0 +1,66 @@
+import { describe, expectTypeOf, it } from 'vitest'
+import type { mapConcurrently, mapSequentially } from '../index.d.ts'
+
+describe('mapConcurrently', () => {
+  it('infers callback param from input array type', () => {
+    const fn = {} as typeof mapConcurrently
+    fn([1, 2, 3], async (value, index, array) => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(value).toBeNumber()
+      expectTypeOf(index).toBeNumber()
+      expectTypeOf(array).toEqualTypeOf<number[]>()
+      return String(value)
+    })
+  })
+
+  it('result type matches callback return', () => {
+    const fn = {} as typeof mapConcurrently
+    const result = fn(
+      [1, 2],
+      async value => ({ doubled: value * 2 })
+    )
+    expectTypeOf(result)
+      .resolves.items.not.toBeAny()
+    expectTypeOf(result)
+      .resolves.items.toEqualTypeOf<{ doubled: number }>()
+  })
+
+  it('accepts promise input', () => {
+    const fn = {} as typeof mapConcurrently
+    const input = Promise.resolve(['a', 'b'])
+    fn(input, async value => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(value).toBeString()
+      return value.length
+    })
+  })
+
+  it('accepts synchronous callback', () => {
+    const fn = {} as typeof mapConcurrently
+    const result = fn([1, 2], value => `${value}`)
+    expectTypeOf(result).resolves.items.not.toBeAny()
+    expectTypeOf(result).resolves.items.toBeString()
+  })
+})
+
+describe('mapSequentially', () => {
+  it('infers callback param from input array type', () => {
+    const fn = {} as typeof mapSequentially
+    fn(['a', 'b'], async (value, index) => {
+      expectTypeOf(value).not.toBeAny()
+      expectTypeOf(value).toBeString()
+      expectTypeOf(index).toBeNumber()
+      return value.length
+    })
+  })
+
+  it('result type matches callback return', () => {
+    const fn = {} as typeof mapSequentially
+    const result = fn(
+      [{ id: 1 }],
+      async item => item.id
+    )
+    expectTypeOf(result).resolves.items.not.toBeAny()
+    expectTypeOf(result).resolves.items.toBeNumber()
+  })
+})