@carlwr/fastcheck-utils 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Carl Wernhoff
+
+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.

package/README.md

@@ -0,0 +1,144 @@
+
+# fastcheck-utils
+
+_improved generators for [fast-check](https://github.com/dubzzz/fast-check)_
+
+Links:
+* github: [github.com/carlwr/fastcheck-utils](https://github.com/carlwr/fastcheck-utils)
+* npm: [www.npmjs.com/package/fastcheck-utils](https://www.npmjs.com/package/fastcheck-utils)
+
+## Installation
+
+```bash
+npm install @carlwr/fastcheck-utils
+```
+
+`fast-check` is a peer dependency of this package. It should be picked up by the package manager also if you depend on e.g. `@fast-check/vitest` or `@fast-check/jest` rather than on `fast-check` directly.
+
+to run checks and tests:
+```bash
+npm qa
+```
+
+---
+
+## Generators
+
+
+### `element`
+
+```ts
+function element<T>(xs: readonly [T, T]): Arbitrary<T>
+```
+Randomly choose one of the constant array values.
+
+Shrinking is done towards the first element.
+
+Similar to fc.constantFrom, but _shrinks across all elements_ - fc.constantFrom only shrinks towards the first element.
+
+example:
+
+```ts
+import * as fcu from 'fastcheck-utils'
+import * as fc from 'fast-check'
+
+const arb = fcu.element(['a', 'b', 'c'] as const)
+const samples = fc.sample(arb, {seed:1, numRuns:3})
+console.log(samples)  // ['b', 'c', 'b']
+```
+
+### `getNext`
+
+```ts
+function getNext<T>(stream: InfiniteStream<T>): T
+```
+Get next value from an `InfiniteStream` object yielded by `infiniteStream`.
+
+Throws if the stream is unexpectedly done (it is my understanding that this should never happen).
+
+### `infiniteStream`
+
+```ts
+function infiniteStream<T>(arb: Arbitrary<T>): Arbitrary<InfiniteStream<T>>
+```
+Generate an infinite stream of values.
+
+This arbitrary is a minimal wrapper around fc.infiniteStream allowing access to the generated values in a type-safe way through the `getNext` helper.
+
+features and non-features:
+- does _not_ shrink at all unfortunately - since fc.infiniteStream doesn't
+- _does_ print a meaningful counterexample and execution summary on failure, that includes some of the previously tried values in the stream
+
+example:
+
+```ts
+import * as fcu from 'fastcheck-utils'
+import * as fc from 'fast-check'
+
+const arb = fcu.infiniteStream(fc.nat({max:10}))
+const stream = fc.sample(arb, {seed:1})[0] ?? fail()
+console.log(fcu.getNext(stream))  // 8
+console.log(fcu.getNext(stream))  // 2
+```
+
+### `nonEmptyArray`
+
+```ts
+function nonEmptyArray<T>(arb: Arbitrary<T>, constraints?: ArrayConstraints): Arbitrary<[T, ...T[]]>
+```
+Generate a non-empty array.
+
+If a `constraints` parameter object is passed, it will be honored (function throws if `{minLength: 0}` is specified).
+
+example:
+
+```ts
+import * as fcu from 'fastcheck-utils'
+import * as fc from 'fast-check'
+
+const arb = fcu.nonEmptyArray(fc.nat({max:5}))
+const sample = fc.sample(arb, {seed:1})[0]
+console.log(sample)  // [5, 4, 2, 2, 5, 0, 3, 1, 5, 3, 1]
+```
+
+### `nonEmptyUniqueArray`
+
+```ts
+function nonEmptyUniqueArray<T, U>(arb: Arbitrary<T>, constraints?: UniqueArrayConstraints<T, U>): Arbitrary<[T, ...T[]]>
+```
+Generate a non-empty array of unique values.
+
+example:
+
+```ts
+import * as fcu from 'fastcheck-utils'
+import * as fc from 'fast-check'
+
+const arb = fcu.nonEmptyUniqueArray(fc.nat({max:10}))
+const sample = fc.sample(arb, {seed:1})[0]
+console.log(sample)  // [2, 6, 5, 9, 4, 7, 10, 3, 1, 0, 8]
+```
+
+### `record`
+
+```ts
+function record<T>(model: Model<T>): Arbitrary<ExactRecord<T>>
+
+function record<T>(model: Model<T>, constr: AllKeysRequired<T>): Arbitrary<ExactRecord<T>>
+
+function record<T, K>(model: Model<T>, constr: SomeKeysRequired<T, K>): Arbitrary<{ [K in string | number | symbol]: (Partial<T> & Pick<T, K & keyof T>)[K] }>
+```
+like fc.record, but with
+- `noNullPrototype` _true_ by default
+- stronger typing
+
+example:
+
+```ts
+import * as fcu from 'fastcheck-utils'
+import * as fc from 'fast-check'
+
+const arb = fcu.record({name: fc.string(), age: fc.nat({max: 100})})
+const sample = fc.sample(arb, {seed:1})[0] ?? fail()
+console.log(sample)  // {name: 'TVb~o"nP', age: 36}
+```

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+import * as fc from 'fast-check';
+
+/**
+ * Randomly choose one of the constant array values.
+ *
+ * Shrinking is done towards the first element.
+ *
+ * Similar to {@link fc.constantFrom}, but _shrinks across all elements_ - {@link fc.constantFrom} only shrinks towards the first element.
+ *
+ * @example
+ * import * as fcu from 'fastcheck-utils'
+ * import * as fc from 'fast-check'
+ *
+ * const arb = fcu.element(['a', 'b', 'c'] as const)
+ * const samples = fc.sample(arb, {seed:1, numRuns:3})
+ * console.log(samples)  // ['b', 'c', 'b']
+ */
+declare function element<T>(xs: readonly [T, ...T[]]): fc.Arbitrary<T>;
+
+interface InfiniteStream<T> extends fc.Stream<T> {
+}
+/**
+ * Generate an infinite stream of values.
+ *
+ * This arbitrary is a minimal wrapper around {@link fc.infiniteStream} allowing access to the generated values in a type-safe way through the {@link getNext} helper.
+ *
+ * features and non-features:
+ * - does _not_ shrink at all unfortunately - since {@link fc.infiniteStream} doesn't
+ * - _does_ print a meaningful counterexample and execution summary on failure, that includes some of the previously tried values in the stream
+ *
+ * @example
+ * import * as fcu from 'fastcheck-utils'
+ * import * as fc from 'fast-check'
+ *
+ * const arb = fcu.infiniteStream(fc.nat({max:10}))
+ * const stream = fc.sample(arb, {seed:1})[0] ?? fail()
+ * console.log(fcu.getNext(stream))  // 8
+ * console.log(fcu.getNext(stream))  // 2
+ */
+declare function infiniteStream<T>(arb: fc.Arbitrary<T>): fc.Arbitrary<InfiniteStream<T>>;
+/**
+ * Get next value from an {@link InfiniteStream} object yielded by {@link infiniteStream}.
+ *
+ * Throws if the stream is unexpectedly done (it is my understanding that this should never happen).
+ */
+declare function getNext<T>(stream: InfiniteStream<T>): T;
+
+/**
+ * Generate a non-empty array.
+ *
+ * If a {@link constraints} parameter object is passed, it will be honored (function throws if `{minLength: 0}` is specified).
+ *
+ * @example
+ * import * as fcu from 'fastcheck-utils'
+ * import * as fc from 'fast-check'
+ *
+ * const arb = fcu.nonEmptyArray(fc.nat({max:5}))
+ * const sample = fc.sample(arb, {seed:1})[0]
+ * console.log(sample)  // [5, 4, 2, 2, 5, 0, 3, 1, 5, 3, 1]
+ */
+declare function nonEmptyArray<T>(arb: fc.Arbitrary<T>, constraints?: fc.ArrayConstraints): fc.Arbitrary<[T, ...T[]]>;
+
+/**
+ * like {@link fc.record}, but with
+ * - `noNullPrototype` _true_ by default
+ * - stronger typing
+ *
+ * @example
+ * import * as fcu from 'fastcheck-utils'
+ * import * as fc from 'fast-check'
+ *
+ * const arb = fcu.record({name: fc.string(), age: fc.nat({max: 100})})
+ * const sample = fc.sample(arb, {seed:1})[0] ?? fail()
+ * console.log(sample)  // {name: 'TVb~o"nP', age: 36}
+ */
+declare function record<T>(model: Model<T>): fc.Arbitrary<ExactRecord<T>>;
+declare function record<T>(model: Model<T>, constr: AllKeysRequired<T>): fc.Arbitrary<ExactRecord<T>>;
+declare function record<T, K extends keyof T>(model: Model<T>, constr: SomeKeysRequired<T, K>): fc.Arbitrary<fc.RecordValue<T, K>>;
+type Model<T> = {
+    [K in keyof T]: fc.Arbitrary<T[K]>;
+};
+type ExactRecord<T> = {
+    [K in keyof T]: T[K];
+};
+type AllKeysRequired<T> = fc.RecordConstraints<keyof T> & {
+    requiredKeys: readonly (keyof T)[];
+};
+type SomeKeysRequired<T, K extends keyof T> = fc.RecordConstraints<K> & {
+    requiredKeys: readonly K[];
+};
+
+/**
+ * Generate a non-empty array of unique values.
+ *
+ * @example
+ * import * as fcu from 'fastcheck-utils'
+ * import * as fc from 'fast-check'
+ *
+ * const arb = fcu.nonEmptyUniqueArray(fc.nat({max:10}))
+ * const sample = fc.sample(arb, {seed:1})[0]
+ * console.log(sample)  // [2, 6, 5, 9, 4, 7, 10, 3, 1, 0, 8]
+ */
+declare function nonEmptyUniqueArray<T, U = T>(arb: fc.Arbitrary<T>, constraints?: fc.UniqueArrayConstraints<T, U>): fc.Arbitrary<[T, ...T[]]>;
+
+export { type InfiniteStream, element, getNext, infiniteStream, nonEmptyArray, nonEmptyUniqueArray, record };

package/dist/index.js

@@ -0,0 +1,2 @@
+function a(r,t){if(t<0||t>=r.length)throw new Error(`index ${t} out of bounds for array of length ${r.length}`);return r[t]}function c(r){return r.length>=1}import*as f from"fast-check";function h(r){return f.nat({max:r.length-1}).map(e=>a(r,e))}import*as s from"fast-check";function b(r){return s.infiniteStream(r)}function g(r){let{value:t,done:e}=r.next();if(e)throw new Error("infinite stream unexpectedly done");return t}import*as u from"fast-check";function E(r,t){if(t?.minLength===0)throw new Error("minLength cannot be 0 for non-empty array");let e=t??{minLength:1},n=e.minLength!==void 0?e:{...e,minLength:1};return u.array(r,n)}import*as i from"fast-check";function R(r,t){let e=t?.noNullPrototype??!0;if(!t?.requiredKeys)return i.record(r,{noNullPrototype:e});let n={noNullPrototype:e,requiredKeys:t.requiredKeys},o=i.record(r,n),l=Object.keys(r);return m(t.requiredKeys,l),o}function m(r,t){return r.length===t.length&&t.every(r.includes)}import*as y from"fast-check";function k(r,t){let e=t??{},n={...e,minLength:Math.max(e.minLength??1,1)};return y.uniqueArray(r,n).filter(c)}export{h as element,g as getNext,b as infiniteStream,E as nonEmptyArray,k as nonEmptyUniqueArray,R as record};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../typescript-extra/src/misc.ts","../../typescript-extra/src/extract.ts","../src/generators/element.ts","../src/generators/infiniteStream.ts","../src/generators/nonEmptyArray.ts","../src/generators/record.ts","../src/generators/nonEmptyUniqueArray.ts"],"sourcesContent":["import { rm } from \"node:fs/promises\";\n\n/**\n * A non-empty array\n */\nexport type NonEmpty<T> = [T, ...T[]]\n\nexport type Primitive =\n  | string\n  | number\n  | boolean\n  | bigint\n  | symbol\n  | null\n  | undefined\n\n\n/**\n * Cached, lazy, single-flight evaluation of a promise.\n *\n * A rejected promise is cached as well, i.e. no re-attempts (failures are assumed to be permanent).\n */\nexport function memoized<T>(f: () => Promise<T>): () => Promise<T> {\n  let p: Promise<T> | null = null;\n  return () => p ?? (p = f())\n}\n\n\n/**\n * whether the elements of {@link xs} are unique, in the `===` sense\n *\n * O(n)\n * (if the hash tables behave, and they should for primitives)\n * (constants likely not too great)\n*/\nexport function allUnique<T extends Primitive>(xs: T[]): boolean {\n  return new Set(xs).size === xs.length\n}\n\n\n/**\n * Map over non-empty array while preserving the type as non-empty\n */\nexport function mapNonEmpty<T,U>(\n  xs: readonly [T,...T[]],\n  fn: (x: T) => U\n): [U,...U[]] {\n  const mapped = xs.map(fn)\n  return mapped as [U,...U[]]\n}\n\n/**\n * Map over non-empty array with a function that returns a non-empty array, and return a flattened non-empty array\n */\nexport function flatmapNonEmpty<T,U>(\n  xs: readonly [T,...T[]],\n  fn: (x: T) => [U,...U[]]\n): [U,...U[]] {\n  const mapped = xs.map(fn)\n  const flattened = mapped.flat()\n  return flattened as [U,...U[]]\n}\n\n\n/**\n * Stateful iterator yielding the elements of {@link xs}.\n *\n * When the last element is reached, calls will continue to return that element indefinitely.\n *\n * @example\n * const next = drain([1, 2, 3]);\n * next(); // => 1\n * next(); // => 2\n * next(); // => 3\n * next(); // => 3\n * next(); // => 3 (returns 3 forever)\n */\nexport function drain<T>(xs: NonEmpty<T>): () => T {\n  let state: NonEmpty<T> = xs\n  return () => {\n    if (hasAtleastTwo(state)) {\n      const [x0,...xs_rest] = state\n      state = xs_rest\n      return x0\n    }\n    return state[0]\n  }\n}\n\n/**\n * return the `i`th element of `xs`, or throw if `i` is out of bounds\n */\nexport function safeIndex<T>(xs: readonly [T, ...T[]], i: number): T {\n  if (i<0 || i>=xs.length) {\n    throw new Error(`index ${i} out of bounds for array of length ${xs.length}`)\n  }\n  return xs[i] as T\n}\n\nexport function mapFilterAsync<T, U>(\n  xs: readonly T[],\n  f: (x: T) => Promise<U|null|undefined>\n): Promise<U[]> {\n  return Promise.all(xs.map(f)).then(results => results.filter(isDefined));\n}\n\nexport function mapAsync<T, U>(\n  xs: readonly T[],\n  f: (x: T) => Promise<U>\n): Promise<U[]> {\n  return Promise.all(xs.map(f));\n}\n\nexport async function partitionAsync<A, B extends boolean>(\n  items: readonly A[],\n  pred: (a: A) => Promise<B>\n): Promise<readonly [A[], A[]]> {\n  const results = await Promise.all(items.map(pred));\n\n  const yes: A[] = [];\n  const no : A[] = [];\n\n  for (let i = 0; i < items.length; i++) {\n    (results[i] ? yes : no).push(items[i] as A);\n  }\n  return [yes, no] as const;\n}\n\n/**\n * remove a substring from the beginning of a string; throw if {@link str} does not start with {@link first}\n *\n * @example\n * withoutFirstSubstring('e', 'ego') // => 'go'\n */\nexport function withoutFirstSubstring(first: string, str: string) {\n  if (!str.startsWith(first))\n    throw new Error(`expected \"${str}\" to start with \"${first}\"`)\n  return str.slice(first.length)\n}\n\nexport function isDefined<T>(x: T|null|undefined): x is NonNullable<T> {\n  return x != null;\n}\n\nexport function isEmpty<T>(xs: readonly T[]): xs is [] {\n  return xs.length === 0\n}\n\nexport function isNonEmpty<T>(xs: readonly T[]): xs is [T, ...T[]] {\n  return xs.length >= 1;\n}\n\nexport function isSingle<T>(xs: readonly T[]): xs is [T] {\n  return xs.length === 1;\n}\n\nexport function hasAtleastTwo<T>(xs: readonly T[]): xs is [T, T, ...T[]] {\n  return xs.length >= 2;\n}\n\nexport function assertNever(_: never): never {\n  throw new Error(\"unhandled variant\");\n}\n\n/**\n * whether the argument is a {@link Record}\n */\nexport function isRecord<K extends keyof any>(value: unknown): value is Record<string,K> {\n  if (\n       typeof value !== 'object'\n    || value === null\n    || Array.isArray(value)\n  )\n    return false\n\n  return (Object.getOwnPropertySymbols(value).length === 0)\n}\n\n/**\n * remove a file or directory recursively; ignore errors\n */\nexport async function rm_rf(path: string): Promise<void> {\n  return rm(path, {recursive: true}).catch(() => {})\n}\n\n/**\n * if the regex matches the string exactly once, return the match; otherwise throw\n */\nexport function getMatch(re: RegExp, str: string): string {\n  const matches = str.match(re) || []\n  if (matches===undefined || !isSingle(matches))\n    throw new Error(`regex /${re.source}/ did not match '${str}' exactly once`)\n  return matches[0]\n}\n\n/**\n * the `.trim()` method as a function\n *\n * `trim(str) <=> str.trim()`\n */\nexport function trim(str: string): string {\n  return str.trim()\n}\n","import { isRecord } from \"./misc.js\"\n\n/**\n * walk {@link root} recursively while collecting all {@link T}s for which {@link pred} returnes a defined result\n *\n * @example\n * const root = {\n *   A: 1,\n *   b: 0,\n *   c: {\n *     99: [{A:2}, {e:\"zero\"}],\n *     A: 3\n *   }\n * }\n * function pred(k: string, v: any): number|undefined {\n *   if (k === 'A' && typeof v === 'number') { return v }\n *   return undefined\n * }\n * const result = extract<number>(root, pred)\n * // result === [1, 2, 3]\n */\nexport function extract<T>(\n  root: unknown,\n  pred: (k: string, v: any) => T|undefined\n): T[] {\n\n  function handleEntry([k,v]: [string,unknown]): T[] {\n    const r = pred(k,v)\n    return (r !== undefined) ? [r] : go(v)\n  }\n\n  function go(node: unknown): T[] {\n\n    const ret =\n        Array.isArray    (node) ? flatMapArr_(node, go)\n      : isRecord(node) ? flatMapRec_(node, handleEntry)\n      : [] // null, primitives, functions, other records\n    return ret\n  }\n\n  return go(root)\n}\n\nfunction flatMapArr_<U,T>(\n  xs: U[],\n  fn: (x:U) => T[]\n): T[] {\n  return xs.flatMap(fn)\n}\n\nfunction flatMapRec_<T>(\n  rec: Record<string,unknown>,\n  fn : (t:[string,unknown]) => T[]\n): T[] {\n  return Object.entries(rec).flatMap(fn)\n}\n","import { safeIndex } from '@carlwr/typescript-extra';\nimport * as fc from 'fast-check';\n\n/**\n * Randomly choose one of the constant array values.\n *\n * Shrinking is done towards the first element.\n *\n * Similar to {@link fc.constantFrom}, but _shrinks across all elements_ - {@link fc.constantFrom} only shrinks towards the first element.\n *\n * @example\n * import * as fcu from 'fastcheck-utils'\n * import * as fc from 'fast-check'\n *\n * const arb = fcu.element(['a', 'b', 'c'] as const)\n * const samples = fc.sample(arb, {seed:1, numRuns:3})\n * console.log(samples)  // ['b', 'c', 'b']\n */\nexport function element<T>(xs: readonly [T, ...T[]]): fc.Arbitrary<T> {\n  const arb = fc.nat({max: xs.length - 1})\n  return arb.map(i => safeIndex(xs, i))\n}\n","import * as fc from 'fast-check'\n\nexport { infiniteStream, getNext }\nexport type { InfiniteStream }\n\ninterface InfiniteStream<T> extends fc.Stream<T> {}\n\n/**\n * Generate an infinite stream of values.\n *\n * This arbitrary is a minimal wrapper around {@link fc.infiniteStream} allowing access to the generated values in a type-safe way through the {@link getNext} helper.\n *\n * features and non-features:\n * - does _not_ shrink at all unfortunately - since {@link fc.infiniteStream} doesn't\n * - _does_ print a meaningful counterexample and execution summary on failure, that includes some of the previously tried values in the stream\n *\n * @example\n * import * as fcu from 'fastcheck-utils'\n * import * as fc from 'fast-check'\n *\n * const arb = fcu.infiniteStream(fc.nat({max:10}))\n * const stream = fc.sample(arb, {seed:1})[0] ?? fail()\n * console.log(fcu.getNext(stream))  // 8\n * console.log(fcu.getNext(stream))  // 2\n */\nfunction infiniteStream<T>(arb: fc.Arbitrary<T>): fc.Arbitrary<InfiniteStream<T>> {\n  return fc.infiniteStream(arb) as fc.Arbitrary<InfiniteStream<T>>\n}\n\n/**\n * Get next value from an {@link InfiniteStream} object yielded by {@link infiniteStream}.\n *\n * Throws if the stream is unexpectedly done (it is my understanding that this should never happen).\n */\nfunction getNext<T>(stream: InfiniteStream<T>): T {\n  const {value, done} = stream.next()\n  if (done) {\n    throw new Error('infinite stream unexpectedly done')\n  }\n  return value\n}\n","import * as fc from 'fast-check';\n\nexport { nonEmptyArray }\n\n/**\n * Generate a non-empty array.\n *\n * If a {@link constraints} parameter object is passed, it will be honored (function throws if `{minLength: 0}` is specified).\n *\n * @example\n * import * as fcu from 'fastcheck-utils'\n * import * as fc from 'fast-check'\n *\n * const arb = fcu.nonEmptyArray(fc.nat({max:5}))\n * const sample = fc.sample(arb, {seed:1})[0]\n * console.log(sample)  // [5, 4, 2, 2, 5, 0, 3, 1, 5, 3, 1]\n */\nfunction nonEmptyArray<T>(\n  arb         : fc.Arbitrary<T>,\n  constraints?: fc.ArrayConstraints\n): fc.Arbitrary<[T,...T[]]> {\n\n  if (constraints?.minLength === 0) {\n    throw new Error(\"minLength cannot be 0 for non-empty array\");\n  }\n\n  const base = constraints ?? { minLength: 1 };\n  const constr: fc.ArrayConstraints = base.minLength !== undefined\n    ? base\n    : { ...base, minLength: 1 };\n\n  return fc.array(arb, constr) as fc.Arbitrary<[T,...T[]]>\n}\n","import * as fc from 'fast-check';\n\n\n/**\n * like {@link fc.record}, but with\n * - `noNullPrototype` _true_ by default\n * - stronger typing\n *\n * @example\n * import * as fcu from 'fastcheck-utils'\n * import * as fc from 'fast-check'\n *\n * const arb = fcu.record({name: fc.string(), age: fc.nat({max: 100})})\n * const sample = fc.sample(arb, {seed:1})[0] ?? fail()\n * console.log(sample)  // {name: 'TVb~o\"nP', age: 36}\n */\nexport function record<T>(\n  model: Model<T>\n): fc.Arbitrary<ExactRecord<T>>\n\nexport function record<T>(\n  model : Model<T>,\n  constr: AllKeysRequired<T>\n): fc.Arbitrary<ExactRecord<T>>\n\nexport function record<T, K extends keyof T>(\n  model  : Model<T>,\n  constr : SomeKeysRequired<T,K>\n): fc.Arbitrary<fc.RecordValue<T,K>>\n\nexport function record<T, K extends keyof T = keyof T>(\n  model  : Model<T>,\n  constr?: fc.RecordConstraints<K>\n):| fc.Arbitrary<ExactRecord<T>>\n  | fc.Arbitrary<fc.RecordValue<T,K>>\n  {\n\n  const nnp = constr?.noNullPrototype ?? true\n\n  if (!constr?.requiredKeys) {\n    // No constraints or no requiredKeys specified - default to all keys required\n    const constr_ = { noNullPrototype: nnp }\n    return fc.record(model, constr_) as fc.Arbitrary<ExactRecord<T>>\n  }\n\n  const constr_ = {\n    noNullPrototype: nnp,\n    requiredKeys   : constr.requiredKeys\n  }\n\n  const arb = fc.record(model, constr_)\n\n  const allKeys = Object.keys(model)\n  const typedArb = isAllKeysRequired(constr.requiredKeys, allKeys)\n    ? arb as fc.Arbitrary<ExactRecord<T>>\n    : arb as fc.Arbitrary<fc.RecordValue<T,K>>\n\n  return typedArb\n}\n\nfunction isAllKeysRequired(\n  requiredKeys: PropertyKey[],\n  allKeys     : PropertyKey[]\n): boolean {\n  return (\n    requiredKeys.length === allKeys.length &&\n    allKeys.every(requiredKeys.includes)\n  )\n}\n\ntype Model<T>       = { [K in keyof T]: fc.Arbitrary<T[K]> }\ntype ExactRecord<T> = { [K in keyof T]:              T[K] }\n\ntype AllKeysRequired<T> =\n  fc.RecordConstraints<keyof T> &\n  { requiredKeys: readonly (keyof T)[] }\n\ntype SomeKeysRequired<T, K extends keyof T> =\n  fc.RecordConstraints<K> &\n  { requiredKeys: readonly K[] }\n","import { isNonEmpty } from \"@carlwr/typescript-extra\";\nimport * as fc from 'fast-check';\n\nexport { nonEmptyUniqueArray }\n\n/**\n * Generate a non-empty array of unique values.\n *\n * @example\n * import * as fcu from 'fastcheck-utils'\n * import * as fc from 'fast-check'\n *\n * const arb = fcu.nonEmptyUniqueArray(fc.nat({max:10}))\n * const sample = fc.sample(arb, {seed:1})[0]\n * console.log(sample)  // [2, 6, 5, 9, 4, 7, 10, 3, 1, 0, 8]\n */\nfunction nonEmptyUniqueArray<T, U = T>(\n  arb         : fc.Arbitrary<T>,\n  constraints?: fc.UniqueArrayConstraints<T, U>\n): fc.Arbitrary<[T,...T[]]> {\n\n  const base = constraints ?? {} as fc.UniqueArrayConstraints<T, U>;\n  const constr: fc.UniqueArrayConstraints<T, U> = {\n    ...base,\n    minLength: Math.max(base.minLength ?? 1, 1)\n  };\n\n  const ret = fc.uniqueArray(arb, constr).filter(isNonEmpty)\n  return ret as fc.Arbitrary<[T,...T[]]>\n}\n"],"mappings":"AA4FO,SAASA,EAAaC,EAA0BC,EAAc,CACnE,GAAIA,EAAE,GAAKA,GAAGD,EAAG,OACf,MAAM,IAAI,MAAM,SAASC,CAAC,sCAAsCD,EAAG,MAAM,EAAE,EAE7E,OAAOA,EAAGC,CAAC,CACb,CAmDO,SAASC,EAAcC,EAAqC,CACjE,OAAOA,EAAG,QAAU,CACtB,CErJA,UAAYC,MAAQ,aAiBb,SAASC,EAAWC,EAA2C,CAEpE,OADe,MAAI,CAAC,IAAKA,EAAG,OAAS,CAAC,CAAC,EAC5B,IAAIC,GAAKC,EAAUF,EAAIC,CAAC,CAAC,CACtC,CCrBA,UAAYE,MAAQ,aAyBpB,SAASC,EAAkBC,EAAuD,CAChF,OAAU,iBAAeA,CAAG,CAC9B,CAOA,SAASC,EAAWC,EAA8B,CAChD,GAAM,CAAC,MAAAC,EAAO,KAAAC,CAAI,EAAIF,EAAO,KAAK,EAClC,GAAIE,EACF,MAAM,IAAI,MAAM,mCAAmC,EAErD,OAAOD,CACT,CCxCA,UAAYE,MAAQ,aAiBpB,SAASC,EACPC,EACAC,EAC0B,CAE1B,GAAIA,GAAa,YAAc,EAC7B,MAAM,IAAI,MAAM,2CAA2C,EAG7D,IAAMC,EAAOD,GAAe,CAAE,UAAW,CAAE,EACrCE,EAA8BD,EAAK,YAAc,OACnDA,EACA,CAAE,GAAGA,EAAM,UAAW,CAAE,EAE5B,OAAU,QAAMF,EAAKG,CAAM,CAC7B,CChCA,UAAYC,MAAQ,aA8Bb,SAASC,EACdC,EACAC,EAGA,CAEA,IAAMC,EAAMD,GAAQ,iBAAmB,GAEvC,GAAI,CAACA,GAAQ,aAGX,OAAU,SAAOD,EADD,CAAE,gBAAiBE,CAAI,CACR,EAGjC,IAAMC,EAAU,CACd,gBAAiBD,EACjB,aAAiBD,EAAO,YAC1B,EAEMG,EAAS,SAAOJ,EAAOG,CAAO,EAE9BE,EAAU,OAAO,KAAKL,CAAK,EAKjC,OAJiBM,EAAkBL,EAAO,aAAcI,CAAO,EAC3DD,CAIN,CAEA,SAASE,EACPC,EACAF,EACS,CACT,OACEE,EAAa,SAAWF,EAAQ,QAChCA,EAAQ,MAAME,EAAa,QAAQ,CAEvC,CCnEA,UAAYC,MAAQ,aAepB,SAASC,EACPC,EACAC,EAC0B,CAE1B,IAAMC,EAAOD,GAAe,CAAC,EACvBE,EAA0C,CAC9C,GAAGD,EACH,UAAW,KAAK,IAAIA,EAAK,WAAa,EAAG,CAAC,CAC5C,EAGA,OADe,cAAYF,EAAKG,CAAM,EAAE,OAAOC,CAAU,CAE3D","names":["safeIndex","xs","i","isNonEmpty","xs","fc","element","xs","i","U","fc","infiniteStream","arb","getNext","stream","value","done","fc","nonEmptyArray","arb","constraints","base","constr","fc","record","model","constr","nnp","constr_","arb","allKeys","isAllKeysRequired","requiredKeys","fc","nonEmptyUniqueArray","arb","constraints","base","constr","N"]}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@carlwr/fastcheck-utils",
+  "description": "improved generators for fast-check",
+  "keywords": [
+    "fast-check",
+    "arbitraries",
+    "generators"
+  ],
+  "author": {
+    "name": "carlwr",
+    "url": "https://github.com/carlwr"
+  },
+  "publisher": "carlwr",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/carlwr/fastcheck-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/carlwr/fastcheck-utils/issues"
+  },
+  "homepage": "https://github.com/carlwr/fastcheck-utils#README.md",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.2.0",
+  "license": "MIT",
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "fast-check": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@carlwr/typescript-extra": "0.2.0",
+    "@fast-check/vitest": "^0.2.1",
+    "@types/node": "^22.15.21",
+    "arg": "^5.0.2",
+    "read-pkg": "^9.0.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.4",
+    "typedoc": "^0.28.5",
+    "typedoc-plugin-markdown": "^4.6.4",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4",
+    "zod": "^3.25.56",
+    "zzz_LAST_dummy": "npm:empty-npm-package@1.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsx build.ts",
+    "build:dev": "tsx build.ts --dev",
+    "prebuild": "pnpm run lint && pnpm run typecheck",
+    "publish:dry": "pnpm publish --dry-run",
+    "publish:release": "pnpm publish",
+    "version:patch": "pnpm version patch",
+    "version:minor": "pnpm version minor",
+    "version:major": "pnpm version major",
+    "lint": "biome check",
+    "imports:sort": "biome check --linter-enabled=false --organize-imports-enabled=true --write",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "qa": "pnpm typecheck && pnpm lint && pnpm test",
+    "readme": "tsx scripts/makeReadme.ts",
+    "LAST_dummy": "false"
+  }
+}