@ghostry/fabricator 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Rebsch
+
+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,47 @@
+# fabricator
+
+Fabricate typed data from composable schemas.
+
+## Install
+
+```bash
+npm install @ghostry/fabricator
+```
+
+Also available via `bun add @ghostry/fabricator` or `bunx jsr add @ghostry/fabricator`.
+
+## Example
+
+```ts
+import { initialize } from "@ghostry/fabricator";
+
+const { T, Fabricator } = initialize({ seed: "1234" });
+
+const ProductSchema = T.object({
+  name: T.string.whereby({ length: { min: 1, max: 25 } }),
+  price: T.number.whereby({ min: 1, max: 500 }),
+  inStock: T.boolean,
+  createdAt: T.date.past,
+  tags: T.array(T.string.whereby({ length: { max: 15 } })).whereby({
+    length: { max: 5 },
+  }),
+});
+
+const Product = new Fabricator(ProductSchema);
+
+const item = Product.fabricate();
+// { name: "...", price: ..., inStock: ..., createdAt: ..., tags: [...] }
+
+/**
+ * Fabricate with everything random except a few fields you care about.
+ */
+const widget = Product.fabricate({ name: "Widget", inStock: true });
+```
+
+`seed: "1234"` is an optional mixer; `clock` (the wall-clock instant of this call, by default) is the run's entropy. Pass the same seed and clock to replay. See the [docs site](https://ghostry-dev.github.io/fabricator/) for the full guide: the mental model behind Schemas and Fabricators, composing and overriding schemas, custom types, distributions, and the [TypeBox adapter](https://www.npmjs.com/package/@ghostry/fabricator-adapter-typebox-v0).
+
+## Similar
+
+https://www.npmjs.com/package/@anatine/zod-mock
+
+https://www.npmjs.com/package/@travelperksl/fabricator

package/dist/esm/Adapter/Core.js

@@ -0,0 +1,47 @@
+import { Adaptation, Meta } from "../Types.js";
+function withAdaptations(schema, adapter, produce) {
+    return patched(schema, {
+        [adapter.key]: toSchemaAdaptation(produce)
+    });
+}
+function mergeAdaptations(prior, adapter, produce) {
+    return patched({
+        [Adaptation]: prior
+    }, {
+        [adapter.key]: toSchemaAdaptation(produce)
+    })[Adaptation];
+}
+function toSchemaAdaptation(produce) {
+    return (schema)=>produce({
+            schema,
+            meta: schema[Meta]
+        });
+}
+function patched(schema, patch) {
+    const prior = schema[Adaptation];
+    const merged = {
+        ...prior
+    };
+    for (const [key, adaptation] of Object.entries(patch))if (void 0 === adaptation) delete merged[key];
+    else merged[key] = Core_layer(key, adaptation, merged[key]);
+    if (0 === Object.keys(merged).length) {
+        const { [Adaptation]: _, ...rest } = schema;
+        return rest;
+    }
+    return {
+        ...schema,
+        [Adaptation]: merged
+    };
+}
+function Core_layer(key, adaptation, prior) {
+    return (schema)=>adaptation(patched(schema, {
+            [key]: prior
+        }));
+}
+function drive(adapter, schema, context) {
+    var _schema_Adaptation;
+    const adaptation = null == (_schema_Adaptation = schema[Adaptation]) ? void 0 : _schema_Adaptation[adapter.key];
+    if (adaptation) return adaptation(schema);
+    return adapter.convert(schema, (child, childContext)=>drive(adapter, child, childContext), context);
+}
+export { drive, mergeAdaptations, withAdaptations };

package/dist/esm/Adapter/Types.js

@@ -0,0 +1 @@
+export { };

package/dist/esm/Bound.js

@@ -0,0 +1,81 @@
+import { FabricatorError } from "./Error/index.js";
+import { isPlainObject } from "./Utility/Core.js";
+function toBound(input) {
+    if (isCanonicalBound(input)) return {
+        value: input.value,
+        exclusive: input.exclusive
+    };
+    return {
+        value: input,
+        exclusive: false
+    };
+}
+function isCanonicalBound(input) {
+    return isPlainObject(input) && "value" in input && "boolean" == typeof input.exclusive;
+}
+function effectiveDiscrete(min, max) {
+    return {
+        min: min.exclusive ? min.value + 1 : min.value,
+        max: max.exclusive ? max.value - 1 : max.value
+    };
+}
+function effectiveDiscreteBigint(min, max) {
+    return {
+        min: min.exclusive ? min.value + BigInt(1) : min.value,
+        max: max.exclusive ? max.value - BigInt(1) : max.value
+    };
+}
+function assertNonemptyDiscrete(label, min, max) {
+    const range = effectiveDiscrete(min, max);
+    if (range.min > range.max) throw new FabricatorError.EmptyRangeError(label, min, max);
+}
+function assertNonemptyDiscreteBigint(label, min, max) {
+    const range = effectiveDiscreteBigint(min, max);
+    if (range.min > range.max) throw new FabricatorError.EmptyRangeError(label, min, max);
+}
+function assertNonemptyContinuous(label, min, max) {
+    if (isEmptyContinuous(min, max)) throw new FabricatorError.EmptyRangeError(label, min, max);
+}
+function isEmptyContinuous(min, max) {
+    if (min.value > max.value) return true;
+    if (min.value === max.value) return min.exclusive || max.exclusive;
+    if (min.exclusive && max.exclusive) return towardInterior(min.value, max.value) >= max.value;
+    return false;
+}
+function towardInterior(value, toward) {
+    if (value === toward) return value;
+    const direction = toward > value ? 1 : -1;
+    if (0 === value) return 5e-324 * direction;
+    const scaled = value + direction * Number.EPSILON * Math.abs(value);
+    if (scaled !== value) return scaled;
+    return value + 5e-324 * direction;
+}
+function constrainContinuous(next, min, max) {
+    return ()=>{
+        let value = next();
+        if (min.exclusive && value === min.value) value = towardInterior(value, max.value);
+        if (max.exclusive && value === max.value) value = towardInterior(value, min.value);
+        return value;
+    };
+}
+function epochBound(bound) {
+    return {
+        value: bound.value.getTime(),
+        exclusive: bound.exclusive
+    };
+}
+function toLengthRange(length, label) {
+    const range = "number" == typeof length ? {
+        min: toBound(length),
+        max: toBound(length)
+    } : {
+        min: void 0 === length.min ? {
+            value: 0,
+            exclusive: false
+        } : toBound(length.min),
+        max: toBound(length.max)
+    };
+    assertNonemptyDiscrete(label, range.min, range.max);
+    return range;
+}
+export { assertNonemptyContinuous, assertNonemptyDiscrete, assertNonemptyDiscreteBigint, constrainContinuous, effectiveDiscrete, effectiveDiscreteBigint, epochBound, toBound, toLengthRange, towardInterior };

package/dist/esm/Distribution/index.js

@@ -0,0 +1,200 @@
+import { FabricatorError } from "../Error/index.js";
+(function(Distribution) {
+    Distribution.uniform = ()=>({
+            kind: "uniform"
+        });
+    Distribution.normal = (params)=>({
+            kind: "normal",
+            mean: null == params ? void 0 : params.mean,
+            spread: null == params ? void 0 : params.spread
+        });
+    Distribution.skew = (exponent)=>({
+            kind: "skew",
+            exponent
+        });
+    Distribution.triangular = (params)=>({
+            kind: "triangular",
+            mode: null == params ? void 0 : params.mode
+        });
+    Distribution.logarithmic = ()=>({
+            kind: "logarithmic"
+        });
+    Distribution.multi = (components)=>({
+            kind: "multi",
+            components
+        });
+    Distribution.custom = (shape)=>({
+            kind: "custom",
+            shape
+        });
+})(Distribution_Distribution || (Distribution_Distribution = {}));
+function at(u, min, max) {
+    return (1 - u) * min + u * max;
+}
+function unitPosition(x, min, max) {
+    if (x === min) return 0;
+    if (x === max) return 1;
+    const span = max - min;
+    if (Number.isFinite(span)) return 0 === span ? 0 : (x - min) / span;
+    const left = x - min;
+    if (0 === left) return 0;
+    const ratio = (max - x) / left;
+    if (!Number.isFinite(ratio)) return 0;
+    return 1 / (1 + ratio);
+}
+function sampler(distribution, range, stream) {
+    const { min, max } = range;
+    const span = max - min;
+    switch(distribution.kind){
+        case "uniform":
+            return ()=>at(stream.next(), min, max);
+        case "skew":
+            {
+                const exponent = distribution.exponent;
+                return ()=>at(stream.next() ** exponent, min, max);
+            }
+        case "triangular":
+            {
+                var _distribution_mode;
+                const mode = null != (_distribution_mode = distribution.mode) ? _distribution_mode : at(0.5, min, max);
+                const split = unitPosition(mode, min, max);
+                return ()=>{
+                    const u = stream.next();
+                    const t = u < split ? Math.sqrt(u * split) : 1 - Math.sqrt((1 - u) * (1 - split));
+                    return at(t, min, max);
+                };
+            }
+        case "normal":
+            {
+                var _distribution_mean, _distribution_spread;
+                const mean = null != (_distribution_mean = distribution.mean) ? _distribution_mean : at(0.5, min, max);
+                const spread = null != (_distribution_spread = distribution.spread) ? _distribution_spread : Number.isFinite(span) && 0 !== span ? span / 6 : Math.max(Math.abs(min), Math.abs(max)) / 6 || 1;
+                const lower = normalCdf((min - mean) / spread);
+                const upper = normalCdf((max - mean) / spread);
+                return ()=>{
+                    const p = lower + stream.next() * (upper - lower);
+                    const value = mean + spread * normalInv(p);
+                    return clamp(value, min, max);
+                };
+            }
+        case "logarithmic":
+            {
+                if (min <= 0) throw new FabricatorError.InvalidDistributionBoundError("logarithmic", min, max);
+                const ratio = max / min;
+                return ()=>min * ratio ** stream.next();
+            }
+        case "multi":
+            {
+                const pick = weighted(distribution.components.map((component)=>[
+                        component.weight,
+                        sampler(component.distribution, range, stream)
+                    ]), stream, "Distribution.multi");
+                return ()=>{
+                    const distribution = pick();
+                    const value = distribution();
+                    return value;
+                };
+            }
+        case "custom":
+            {
+                const shape = distribution.shape;
+                return ()=>at(clamp(shape(stream.next()), 0, 1), min, max);
+            }
+    }
+}
+function clamp(value, min, max) {
+    if (value < min) return min;
+    if (value > max) return max;
+    return value;
+}
+function normalCdf(x) {
+    return 0.5 * (1 + erf(x / Math.SQRT2));
+}
+function erf(x) {
+    const sign = x < 0 ? -1 : 1;
+    const z = Math.abs(x);
+    const t = 1 / (1 + 0.3275911 * z);
+    const poly = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;
+    return sign * (1 - poly * Math.exp(-z * z));
+}
+function normalInv(p) {
+    if (p <= 0) return -1 / 0;
+    if (p >= 1) return 1 / 0;
+    const low = 0.02425;
+    const high = 1 - low;
+    if (p < low) {
+        const q = Math.sqrt(-2 * Math.log(p));
+        return (((((-0.007784894002430293 * q - 3.223964580411365e-1) * q - 2.400758277161838) * q - 2.549732539343734) * q + 4.374664141464968) * q + 2.938163982698783) / ((((7.784695709041462e-3 * q + 3.224671290700398e-1) * q + 2.445134137142996) * q + 3.754408661907416) * q + 1);
+    }
+    if (p <= high) {
+        const q = p - 0.5;
+        const r = q * q;
+        return (((((-39.69683028665376 * r + 2.209460984245205e2) * r - 2.759285104469687e2) * r + 1.38357751867269e2) * r - 3.066479806614716e1) * r + 2.506628277459239) * q / (((((-54.47609879822406 * r + 1.615858368580409e2) * r - 1.556989798598866e2) * r + 6.680131188771972e1) * r - 1.328068155288572e1) * r + 1);
+    }
+    const q = Math.sqrt(-2 * Math.log(1 - p));
+    return -(((((-0.007784894002430293 * q - 3.223964580411365e-1) * q - 2.400758277161838) * q - 2.549732539343734) * q + 4.374664141464968) * q + 2.938163982698783) / ((((7.784695709041462e-3 * q + 3.224671290700398e-1) * q + 2.445134137142996) * q + 3.754408661907416) * q + 1);
+}
+function sample(list, stream) {
+    const index = Math.floor(stream.next() * list.length);
+    const item = list[index];
+    return item;
+}
+function shuffle(items, stream) {
+    const shuffled = [
+        ...items
+    ];
+    for(let i = 1; i < shuffled.length; i++){
+        const j = Math.floor(stream.next() * (i + 1));
+        const swap = shuffled[i];
+        shuffled[i] = shuffled[j];
+        shuffled[j] = swap;
+    }
+    return shuffled;
+}
+function isDrawable(weight) {
+    return weight > 0;
+}
+function isValidWeight(weight) {
+    return weight >= 0 && Number.isFinite(weight);
+}
+function drawableOutcomes(outcomes, weights) {
+    return outcomes.filter((outcome)=>{
+        var _ref;
+        return isDrawable(null != (_ref = null == weights ? void 0 : weights[outcome]) ? _ref : 1);
+    });
+}
+function assertDrawableWeights(label, noun, items) {
+    for(let i = 0; i < items.length; i++){
+        const weight = items[i][0];
+        if (!isValidWeight(weight)) throw new FabricatorError.InvalidWeightError(label, weight, {
+            kind: "index",
+            index: i,
+            noun
+        });
+    }
+    if (!items.some(([weight])=>isDrawable(weight))) throw new FabricatorError.NoDrawableOutcomesError(label, noun);
+}
+function assertDrawableKeyedWeights(label, outcomes, weights) {
+    for (const [key, weight] of Object.entries(weights))if (void 0 !== weight) {
+        if (!isValidWeight(weight)) throw new FabricatorError.InvalidWeightError(label, weight, {
+            kind: "name",
+            name: key
+        });
+    }
+    if (0 === drawableOutcomes(outcomes, weights).length) throw new FabricatorError.NoDrawableOutcomesError(label, "outcome");
+}
+function weighted(weights, stream, label) {
+    let sum = 0;
+    const weightings = weights.filter(([weight])=>isDrawable(weight)).map(([weight, item])=>[
+            sum += weight,
+            item
+        ]);
+    if (0 === weightings.length) throw new FabricatorError.NoDrawableOutcomesError(label, "outcome");
+    return ()=>{
+        const x = stream.next() * sum;
+        const chosen = weightings.find(([weight])=>x < weight);
+        return chosen[1];
+    };
+}
+var Distribution_Distribution;
+export { Distribution_Distribution as Distribution, assertDrawableKeyedWeights, assertDrawableWeights, drawableOutcomes, isDrawable, isValidWeight, sample, sampler, shuffle, weighted };

package/dist/esm/Enumeration/Enumerate.js

@@ -0,0 +1,103 @@
+import { shuffle } from "../Distribution/index.js";
+import { FabricatorError } from "../Error/index.js";
+import { Constructor } from "../Fabricator/Constructor.js";
+import { toStreamFromTrace } from "../Random/index.js";
+import { plan, resolve } from "./Plan.js";
+function enumerables(source, limits, stack) {
+    const Fabricator = Constructor(source, stack);
+    function effectiveSource() {
+        var _ref;
+        var _stack_current;
+        return null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.source) ? _ref : source;
+    }
+    function iterable(rebuild) {
+        return {
+            [Symbol.iterator] () {
+                const { built, axis } = rebuild();
+                const width = Number(axis.width);
+                let index = 0;
+                return {
+                    next: ()=>{
+                        if (index >= width) return {
+                            done: true,
+                            value: void 0
+                        };
+                        const value = resolve(built, axis.at(BigInt(index)));
+                        index++;
+                        return {
+                            done: false,
+                            value
+                        };
+                    }
+                };
+            }
+        };
+    }
+    function combinatorial(schema) {
+        const combinatorialSeed = [
+            ...effectiveSource().seed,
+            "combinatorial"
+        ];
+        const probe = plan(new Fabricator(schema, {
+            seed: combinatorialSeed
+        }), {
+            strategy: "product"
+        });
+        if (probe.width > BigInt(limits.combinatorial)) throw new FabricatorError.CombinatorialLimitExceededError(probe.width, limits.combinatorial);
+        return iterable(()=>{
+            const built = new Fabricator(schema, {
+                seed: combinatorialSeed
+            });
+            return {
+                built,
+                axis: plan(built, {
+                    strategy: "product"
+                })
+            };
+        });
+    }
+    function coverage(schema) {
+        const base = effectiveSource();
+        const coverageSeed = [
+            ...base.seed,
+            "coverage"
+        ];
+        const orderSeed = [
+            ...base.seed,
+            "coverage",
+            "order"
+        ];
+        return iterable(()=>{
+            const built = new Fabricator(schema, {
+                seed: coverageSeed
+            });
+            return {
+                built,
+                axis: plan(built, {
+                    strategy: "cycle",
+                    orderer: orderer(base, orderSeed)
+                })
+            };
+        });
+    }
+    return {
+        combinatorial,
+        coverage
+    };
+}
+function orderer(source, seed) {
+    const forked = source.fork(seed);
+    const root = forked.toRoot("unattributed");
+    const stream = toStreamFromTrace(forked.algorithm, {
+        ...root,
+        path: [],
+        kind: "order"
+    });
+    return (width)=>{
+        const identity = Array.from({
+            length: Number(width)
+        }, (_, i)=>BigInt(i));
+        return shuffle(identity, stream);
+    };
+}
+export { enumerables };