feat: add arbitrary sizing

package.json

@@ -40,10 +40,10 @@
     "tslib": "^2.6.2"
   },
   "devDependencies": {
-    "@skyleague/node-standards": "^5.1.1",
-    "date-fns": "^3.3.1",
-    "esbuild": "^0.20.0",
-    "typescript": "5.3.3"
+    "@skyleague/node-standards": "^5.1.9",
+    "date-fns": "^3.6.0",
+    "esbuild": "^0.20.2",
+    "typescript": "5.4.2"
   },
   "engines": {
     "node": ">=20"
@@ -62,4 +62,4 @@
   "workspaces": [
     "docs"
   ]
-}
+}

src/array/zip/zip.ts

@@ -20,6 +20,9 @@ export function* zip<T extends readonly [...Traversable<unknown>[]]>(...xs: [...
     return
 }
 
+/**
+ * @deprecated
+ */
 export function* zipWith<T extends readonly [...unknown[]], R>(f: (...args: [...T]) => R, ...xs: Unzip<[...T]>) {
     if (xs.length === 0) {
         return

src/async/parallel-limit/parallel-limit.ts

@@ -46,6 +46,7 @@ export function parallelLimit(concurrency: number) {
                 try {
                     resolve(await task())
                 } catch (err) {
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(err)
                 } finally {
                     next()

src/guard/has-properties-defined/has-properties-defined.spec.ts

@@ -1,11 +1,12 @@
 import { hasPropertiesDefined } from './has-properties-defined.js'
 
-import { all, collect, dict, float, forAll, keysOf, shuffle, take, tuple, unknown } from '../../index.js'
+import { all, collect, float, forAll, keysOf, shuffle, take, tuple, unknown } from '../../index.js'
+import { record } from '../../random/types/record/record.js'
 
 import { expect, it } from 'vitest'
 
 it('defined properties are defined', () => {
-    forAll(tuple(dict(unknown()), float({ min: 0, max: 1 })), ([xs, r]) => {
+    forAll(tuple(record(unknown()), float({ min: 0, max: 1 })), ([xs, r]) => {
         const keys = keysOf(xs)
         const selectedKeys = collect(take(shuffle(keys), r * keys.length))
         return hasPropertiesDefined(selectedKeys)(xs) === all(selectedKeys, (k) => xs[k] !== undefined)

src/iterator/at/at.spec.ts

@@ -33,7 +33,7 @@ describe('at', () => {
 
     it('ith index on array - index in bounds', () => {
         forAll(
-            integer({ min: 1, max: 50 }).chain((n) => tuple(array(unknown(), { minLength: n }), integer({ min: 0, max: n }))),
+            integer({ min: 1, max: 50 }).chain((n) => tuple(array(unknown(), { minLength: n }), integer({ min: 0, max: n - 1 }))),
             ([xs, i]) => {
                 return at(xs, i) === xs[i]
             }

src/iterator/at/at.ts

@@ -34,7 +34,7 @@ export function at<Xs extends any[], N extends number>(
 export function at<T, N extends number = number>(xs: Traversable<T>, n: N): Maybe<T>
 export function at<T, N extends number = number>(xs: Traversable<T>, n: N): Maybe<T> {
     if (isArray<T>(xs)) {
-        return n >= xs.length ? Nothing : xs[n]!
+        return (n >= xs.length ? Nothing : xs[n]) as Maybe<T>
     }
     // slow iterator compatible version
     return head(drop(xs, n))

src/object/ensure-values/ensure-values.spec.ts

@@ -1,11 +1,12 @@
 import { ensureValues } from './ensure-values.js'
 
-import { constant, dict, forAll, oneOf, unknown } from '../../random/index.js'
+import { constant, forAll, oneOf, unknown } from '../../random/index.js'
+import { record } from '../../random/types/record/record.js'
 
 import { it } from 'vitest'
 
 it('ensure-values', () => {
-    forAll(dict(oneOf(constant(undefined), unknown({ undefined: false }))), (x) => {
+    forAll(record(oneOf(constant(undefined), unknown({ undefined: false }))), (x) => {
         const config = ensureValues(x)
         for (const k of [...Object.keys(x), ...Object.getOwnPropertySymbols(x)] as (keyof typeof x)[]) {
             if (x[k] === undefined) {

src/object/entries-of/entries-of.spec.ts

@@ -1,11 +1,11 @@
 import { entriesOf } from './index.js'
 
-import { forAll, dict, unknown, string, array, oneOf, integer } from '../../random/index.js'
+import { forAll, record, unknown, string, array, oneOf, integer } from '../../random/index.js'
 
 import { expect, it } from 'vitest'
 
 it('entriesOf === Object.entries', () => {
-    forAll(dict(unknown()), (o) => {
+    forAll(record(unknown()), (o) => {
         expect(entriesOf(o)).toStrictEqual(Object.entries(o))
     })
 })
@@ -36,7 +36,7 @@ it('entriesOf [1, 2, 3]', () => {
 })
 
 it('entriesOf union object and array', () => {
-    forAll(oneOf(array(string()), dict([integer(), integer()])), (o) => {
+    forAll(oneOf(array(string()), record([integer(), integer()])), (o) => {
         expect(entriesOf(o)).toStrictEqual(Object.entries(o))
     })
     const _foo: [string, number][] = entriesOf([1, 2, 3])

src/object/from-entries/from-entries.spec.ts

@@ -1,13 +1,14 @@
 import { fromEntries } from './from-entries.js'
 
 import { equal } from '../../iterator/index.js'
-import { dict, forAll, unknown } from '../../random/index.js'
+import { forAll, unknown } from '../../random/index.js'
+import { record } from '../../random/types/record/record.js'
 import { entriesOf } from '../entries-of/index.js'
 
 import { expect, it } from 'vitest'
 
 it('fromEntries o entriesOf === identity', () => {
-    forAll(dict(unknown()), (x) => equal(fromEntries(entriesOf(x)), x))
+    forAll(record(unknown()), (x) => equal(fromEntries(entriesOf(x)), x))
 })
 
 it('infers correct type', () => {

src/object/get-prop/get-prop.spec.ts

@@ -1,6 +1,7 @@
 import { getProp } from './get-prop.js'
 
-import { Nothing, dict, enumerate, forAll, isObject, string, tuple, unknown } from '../../index.js'
+import { Nothing, enumerate, forAll, isObject, string, tuple, unknown } from '../../index.js'
+import { record } from '../../random/types/record/record.js'
 
 import { it, expect, assertType } from 'vitest'
 
@@ -32,7 +33,7 @@ it('returns undefined for non-existent properties', () => {
 })
 
 it('returns the correct value for existing properties', () => {
-    forAll(tuple(dict(unknown()), string(), unknown()), ([obj, path, value]) => {
+    forAll(tuple(record(unknown()), string(), unknown()), ([obj, path, value]) => {
         const pathArr = path.split('.')
         let current = obj as any
         for (const [i, key] of enumerate(pathArr)) {

src/object/has/has.spec.ts

@@ -2,12 +2,13 @@ import { has } from './index.js'
 
 import { all } from '../../iterator/index.js'
 import { keysOf } from '../../object/index.js'
-import { forAll, dict, unknown } from '../../random/index.js'
+import { forAll, unknown } from '../../random/index.js'
+import { record } from '../../random/types/record/record.js'
 
 import { expect, it } from 'vitest'
 
 it('all has keysOf o', () => {
-    forAll(dict(unknown()), (o) => all(keysOf(o), (k) => has(o, k)))
+    forAll(record(unknown()), (o) => all(keysOf(o), (k) => has(o, k)))
 })
 
 it('typing', () => {

src/object/keys-of/keys-of.spec.ts

@@ -1,11 +1,11 @@
 import { keysOf } from './index.js'
 
-import { forAll, dict, unknown, string, array, oneOf, integer } from '../../random/index.js'
+import { forAll, record, unknown, string, array, oneOf, integer } from '../../random/index.js'
 
 import { expect, it } from 'vitest'
 
 it('keysOf === Object.keys', () => {
-    forAll(dict(unknown()), (o) => {
+    forAll(record(unknown()), (o) => {
         expect(keysOf(o)).toStrictEqual(Object.keys(o))
     })
 })
@@ -27,7 +27,7 @@ it('keysOf [1, 2, 3]', () => {
 })
 
 it('keysOf union object and array', () => {
-    forAll(oneOf(array(string()), dict([integer(), integer()])), (o) => {
+    forAll(oneOf(array(string()), record([integer(), integer()])), (o) => {
         expect(keysOf(o)).toStrictEqual(Object.keys(o))
     })
     const _foo: string[] = keysOf([1, 2, 3])

src/object/merge-deep/merge-deep.ts

@@ -23,14 +23,15 @@ export function mergeDeep<T, U>(source: U, target: T): T | U {
     const output: Record<string, unknown> = Object.assign({}, target)
     if (isObject(target) && isObject(source)) {
         for (const key of Object.keys(source)) {
-            const obj = source[key]
+            const obj: any = source[key]
             if (isObject(obj)) {
                 if (!(key in target)) {
                     Object.assign(output, { [key]: obj })
                 } else {
                     output[key] = mergeDeep(obj, target[key])
                 }
             } else {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 Object.assign(output, { [key]: obj })
             }
         }

src/object/omit/omit.spec.ts

@@ -3,25 +3,25 @@ import { omitUndefined, omit, omitBy } from './index.js'
 import type { OmitUndefined } from './omit.js'
 
 import { all, equal } from '../../iterator/index.js'
-import { forAll, dict, unknown, deterministicBoolean } from '../../random/index.js'
+import { forAll, record, unknown, deterministicBoolean } from '../../random/index.js'
 import { keysOf, pickBy } from '../index.js'
 
 import { expect, describe, it } from 'vitest'
 
 describe('omitUndefined', () => {
     it('omitUndefined x === identity, if all values defined', () => {
-        forAll(dict(unknown({ undefined: false })), (x) => equal(omitUndefined(x), x))
+        forAll(record(unknown({ undefined: false })), (x) => equal(omitUndefined(x), x))
     })
 
     it('key filtered in both filtered and original', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omitUndefined(x)
             return all(keysOf(filtered), (k) => k in x && k in filtered)
         })
     })
 
     it('key in filtered if not omitted', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omitUndefined(x)
             return all(keysOf(x), (k) => (x[k] !== undefined ? k in filtered : !(k in filtered) && k in x))
         })
@@ -41,7 +41,7 @@ describe('omitUndefined', () => {
 
 describe('omitBy', () => {
     it('omitBy false x === identity', () => {
-        forAll(dict(unknown()), (x) =>
+        forAll(record(unknown()), (x) =>
             equal(
                 omitBy(x, () => false),
                 x
@@ -50,11 +50,11 @@ describe('omitBy', () => {
     })
 
     it('omitBy false x !== [ref] x', () => {
-        forAll(dict(unknown()), (x) => omitBy(x, () => false) !== x)
+        forAll(record(unknown()), (x) => omitBy(x, () => false) !== x)
     })
 
     it('omitBy true x == {}', () => {
-        forAll(dict(unknown()), (x) =>
+        forAll(record(unknown()), (x) =>
             equal(
                 omitBy(x, () => true),
                 {}
@@ -63,21 +63,21 @@ describe('omitBy', () => {
     })
 
     it('key filtered in both filtered and original', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omitBy(x, (key) => deterministicBoolean(key))
             return all(keysOf(filtered), (k) => k in x && k in filtered)
         })
     })
 
     it('key filtered if not picked', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omitBy(x, ([k]) => deterministicBoolean(k))
             return all(keysOf(x), (k) => !(deterministicBoolean(k) ? k in filtered : !(k in filtered) && k in x))
         })
     })
 
     it('omitBy ~ pickBy', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const omitted = omitBy(x, ([k]) => deterministicBoolean(k))
             const picked = pickBy(x, ([k]) => !deterministicBoolean(k))
             return equal(omitted, picked)
@@ -95,26 +95,26 @@ describe('omit', () => {
     })
 
     it('omit [] x === identity', () => {
-        forAll(dict(unknown()), (x) => equal(omit(x, []), x))
+        forAll(record(unknown()), (x) => equal(omit(x, []), x))
     })
 
     it('omit [] x !== [ref] x', () => {
-        forAll(dict(unknown()), (x) => omit(x, []) !== x)
+        forAll(record(unknown()), (x) => omit(x, []) !== x)
     })
 
     it('omit keysOf x x == {}', () => {
-        forAll(dict(unknown()), (x) => equal(omit(x, keysOf(x)), {}))
+        forAll(record(unknown()), (x) => equal(omit(x, keysOf(x)), {}))
     })
 
     it('key filtered in both filtered and original', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omit(x, keysOf(x).filter(deterministicBoolean))
             return all(keysOf(filtered), (k) => k in x && k in filtered)
         })
     })
 
     it('key filtered if not omited', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = omit(x, keysOf(x).filter(deterministicBoolean))
             return all(keysOf(x), (k) => (!deterministicBoolean(k) ? k in filtered : !(k in filtered) && k in x))
         })

src/object/pick/pick.spec.ts

@@ -2,7 +2,7 @@ import { pick, pickBy } from './index.js'
 
 import { isNumber } from '../../guard/index.js'
 import { all, equal } from '../../iterator/index.js'
-import { forAll, dict, unknown, deterministicBoolean } from '../../random/index.js'
+import { forAll, record, unknown, deterministicBoolean } from '../../random/index.js'
 import { keysOf } from '../index.js'
 
 import { expect, describe, it } from 'vitest'
@@ -17,7 +17,7 @@ describe('pickBy', () => {
     })
 
     it('pickBy true x === identity', () => {
-        forAll(dict(unknown()), (x) =>
+        forAll(record(unknown()), (x) =>
             equal(
                 pickBy(x, () => true),
                 x
@@ -26,11 +26,11 @@ describe('pickBy', () => {
     })
 
     it('pickBy true x !== [ref] x', () => {
-        forAll(dict(unknown()), (x) => pickBy(x, () => true) !== x)
+        forAll(record(unknown()), (x) => pickBy(x, () => true) !== x)
     })
 
     it('pickBy false x == {}', () => {
-        forAll(dict(unknown()), (x) =>
+        forAll(record(unknown()), (x) =>
             equal(
                 pickBy(x, () => false),
                 {}
@@ -39,14 +39,14 @@ describe('pickBy', () => {
     })
 
     it('key filtered in both filtered and original', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = pickBy(x, (key) => deterministicBoolean(key))
             return all(keysOf(filtered), (k) => k in x && k in filtered)
         })
     })
 
     it('key filtered if not picked', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = pickBy(x, ([k]) => deterministicBoolean(k))
             return all(keysOf(x), (k) => (deterministicBoolean(k) ? k in filtered : !(k in filtered) && k in x))
         })
@@ -64,26 +64,26 @@ describe('pick', () => {
     })
 
     it('pick keysOf x x === identity', () => {
-        forAll(dict(unknown()), (x) => equal(pick(x, keysOf(x)), x))
+        forAll(record(unknown()), (x) => equal(pick(x, keysOf(x)), x))
     })
 
     it('pick keysOf x x !== [ref] x', () => {
-        forAll(dict(unknown()), (x) => pick(x, keysOf(x)) !== x)
+        forAll(record(unknown()), (x) => pick(x, keysOf(x)) !== x)
     })
 
     it('pick [] x == {}', () => {
-        forAll(dict(unknown()), (x) => equal(pick(x, []), {}))
+        forAll(record(unknown()), (x) => equal(pick(x, []), {}))
     })
 
     it('key filtered in both filtered and original', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = pick(x, keysOf(x).filter(deterministicBoolean))
             return all(keysOf(filtered), (k) => k in x && k in filtered)
         })
     })
 
     it('key filtered if not picked', () => {
-        forAll(dict(unknown()), (x) => {
+        forAll(record(unknown()), (x) => {
             const filtered = pick(x, keysOf(x).filter(deterministicBoolean))
             return all(keysOf(x), (k) => (deterministicBoolean(k) ? k in filtered : !(k in filtered) && k in x))
         })