@ghostry/fabricator 0.0.1

package/dist/esm/Fabricator/Constructor.js

@@ -0,0 +1,328 @@
+import { FabricatorError } from "../Error/index.js";
+import { Primitive } from "../Primitive/index.js";
+import { isLayered, normalizeSeed } from "../Random/index.js";
+import { toSchema } from "../Schema/Core.js";
+import { Adaptation, Fixed, Kind, Layer, Meta } from "../Types.js";
+import { inline } from "../Utility/Core.js";
+function Constructor(source, stack) {
+    function make(schema, path, context) {
+        schema = toSchema(schema);
+        const kind = schema[Kind];
+        const common = {
+            algorithm: context.algorithm,
+            trace: context.toTrace(path, kind)
+        };
+        switch(kind){
+            case "number":
+                {
+                    const s = schema;
+                    return Primitive.number.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "date":
+                {
+                    const s = schema;
+                    return Primitive.date.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "boolean":
+                {
+                    const s = schema;
+                    return Primitive.boolean.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "enum":
+                {
+                    const s = schema;
+                    return Primitive["enum"].Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "choice":
+                {
+                    const s = schema;
+                    const options = s[Meta].items.map(([weight, item], i)=>[
+                            weight,
+                            make(item, [
+                                ...path,
+                                i.toString(10)
+                            ], context)
+                        ]);
+                    return Primitive.choice.Fabricator({
+                        ...common,
+                        schema: s
+                    }, options);
+                }
+            case "always":
+                {
+                    const s = schema;
+                    return Primitive.always.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "opaque":
+                {
+                    const s = schema;
+                    return Primitive.opaque.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "symbol":
+                {
+                    const s = schema;
+                    return Primitive.symbol.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "undefined":
+                {
+                    const s = schema;
+                    return Primitive.undefined.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "undefinable":
+                {
+                    const s = schema;
+                    const inner = make(s[Meta].definition, [
+                        ...path,
+                        "definition"
+                    ], context);
+                    return Primitive.undefinable.Fabricator({
+                        ...common,
+                        schema: s
+                    }, inner);
+                }
+            case "null":
+                {
+                    const s = schema;
+                    return Primitive["null"].Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "nullable":
+                {
+                    const s = schema;
+                    const inner = make(s[Meta].definition, [
+                        ...path,
+                        "definition"
+                    ], context);
+                    return Primitive.nullable.Fabricator({
+                        ...common,
+                        schema: s
+                    }, inner);
+                }
+            case "nullish":
+                {
+                    const s = schema;
+                    const inner = make(s[Meta].definition, [
+                        ...path,
+                        "definition"
+                    ], context);
+                    return Primitive.nullish.Fabricator({
+                        ...common,
+                        schema: s
+                    }, inner);
+                }
+            case "string":
+                {
+                    const s = schema;
+                    return Primitive.string.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "bigint":
+                {
+                    const s = schema;
+                    return Primitive.bigint.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "array":
+                {
+                    const s = schema;
+                    const element = make(s[Meta].definition, [
+                        ...path,
+                        "element"
+                    ], context);
+                    return Primitive.array.Fabricator({
+                        ...common,
+                        schema: s
+                    }, element);
+                }
+            case "record":
+                {
+                    const s = schema;
+                    const key = make(s[Meta].key, [
+                        ...path,
+                        "key"
+                    ], context);
+                    const value = make(s[Meta].value, [
+                        ...path,
+                        "value"
+                    ], context);
+                    return Primitive.record.Fabricator({
+                        ...common,
+                        schema: s
+                    }, key, value);
+                }
+            case "recursive":
+                {
+                    const s = schema;
+                    return Primitive.recursive.Fabricator({
+                        ...common,
+                        schema: s
+                    }, source.fork, make);
+                }
+            case "recursive.self":
+                {
+                    const s = schema;
+                    return Primitive.recursive.self.Fabricator({
+                        ...common,
+                        schema: s
+                    }, context.self);
+                }
+            case "tuple":
+                {
+                    const s = schema;
+                    const elements = s[Meta].items.map((item, i)=>make(item, [
+                            ...path,
+                            i.toString(10)
+                        ], context));
+                    return Primitive.tuple.Fabricator({
+                        ...common,
+                        schema: s
+                    }, elements);
+                }
+            case "object.compute":
+                {
+                    const s = schema;
+                    return Primitive.object.compute.Fabricator({
+                        ...common,
+                        schema: s
+                    });
+                }
+            case "object.omittable":
+                {
+                    const s = schema;
+                    const inner = make(s[Meta].definition, [
+                        ...path,
+                        "definition"
+                    ], context);
+                    return Primitive.object.omittable.Fabricator({
+                        ...common,
+                        schema: s
+                    }, inner);
+                }
+            case "object.optional":
+                {
+                    const s = schema;
+                    const inner = make(s[Meta].definition, [
+                        ...path,
+                        "definition"
+                    ], context);
+                    return Primitive.object.optional.Fabricator({
+                        ...common,
+                        schema: s
+                    }, inner);
+                }
+            case "object":
+                {
+                    const s = schema;
+                    const definition = s[Meta].definition;
+                    const fields = {};
+                    for(const key in definition){
+                        const fieldSchema = definition[key];
+                        const fieldPath = [
+                            ...path,
+                            key
+                        ];
+                        fields[key] = inline(()=>{
+                            if (Fixed in fieldSchema) {
+                                const built = make(fieldSchema, fieldPath, context);
+                                const value = fieldSchema[Fixed];
+                                if (Primitive.object.compute.isObjectComputeFabricator(built)) return {
+                                    ...built,
+                                    [Kind]: built[Meta].source[Kind],
+                                    fabricate: ()=>value
+                                };
+                                return {
+                                    ...built,
+                                    fabricate: ()=>value
+                                };
+                            }
+                            return make(fieldSchema, fieldPath, context);
+                        });
+                    }
+                    return Primitive.object.Fabricator({
+                        ...common,
+                        schema: Primitive.object.rehydrate(s)
+                    }, fields);
+                }
+            default:
+                throw new FabricatorError.UnknownKindError(String(kind), "construction");
+        }
+    }
+    function construct(schema, options = {}) {
+        var _options_path;
+        if ("string" == typeof options.kind && options.kind !== schema[Kind]) throw new FabricatorError.TraceKindMismatchError(schema[Kind], options.kind);
+        const context = toConstructionContext(source, options, stack);
+        const made = make(schema, null != (_options_path = options.path) ? _options_path : [], context);
+        const adaptations = schema[Adaptation];
+        return adaptations ? {
+            ...made,
+            [Adaptation]: adaptations
+        } : made;
+    }
+    return construct;
+}
+function toConstructionContext(source, options, stack) {
+    const { source: rooted, root: construction } = resolveScope(source, options, stack);
+    return {
+        toTrace: (path, kind)=>({
+                ...construction,
+                path,
+                kind
+            }),
+        algorithm: rooted.algorithm
+    };
+}
+function resolveScope(source, options, stack) {
+    var _ref;
+    const frame = stack.current();
+    const base = null != (_ref = null == frame ? void 0 : frame.source) ? _ref : source;
+    const pins = {
+        clock: options.clock,
+        root: options.root,
+        file: options.file,
+        ordinal: options.ordinal
+    };
+    if (!options.seed) return {
+        source: base,
+        root: base.toRoot("attributed", pins)
+    };
+    const seed = isLayered(options.seed) ? [
+        ...base.seed,
+        ...normalizeSeed(options.seed[Layer])
+    ] : options.seed;
+    const forked = base.fork(seed);
+    return {
+        source: forked,
+        root: forked.toRoot("unattributed", pins)
+    };
+}
+export { Constructor };

package/dist/esm/Fabricator/Types.js

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

package/dist/esm/Instance/Core.js

@@ -0,0 +1,119 @@
+import { enumerables } from "../Enumeration/Enumerate.js";
+import { FabricatorError } from "../Error/index.js";
+import { Constructor } from "../Fabricator/Constructor.js";
+import { defaultAlgorithm, deriveClock, isLayered, normalizeSeed, resolveAttribution, toRandomSource } from "../Random/index.js";
+import { registry } from "../Schema/Registry.js";
+import { Layer } from "../Types.js";
+import { inline } from "../Utility/Core.js";
+const DEFAULT_COMBINATORIAL_LIMIT = 1024;
+function resolveCombinatorialLimit(limit) {
+    if (void 0 === limit) return DEFAULT_COMBINATORIAL_LIMIT;
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new FabricatorError.InvalidCombinatorialLimitError(limit);
+    return limit;
+}
+function resolveClock(config) {
+    return "number" == typeof config.clock ? config.clock : deriveClock(config.algorithm, normalizeSeed(config.seed));
+}
+function overlay(base, over) {
+    var _ref, _over_algorithm, _base_attribution, _ref1, _over_types, _over_limits;
+    var _this;
+    const seed = inline(()=>{
+        if (void 0 === over.seed) return normalizeSeed(base.seed);
+        if (isLayered(over.seed)) return [
+            ...normalizeSeed(base.seed),
+            ...normalizeSeed(over.seed[Layer])
+        ];
+        return normalizeSeed(over.seed);
+    });
+    const clock = inline(()=>{
+        var _base_clock;
+        if ("seeded" === over.clock) return "seeded";
+        if (void 0 !== over.clock) return over.clock.valueOf();
+        return null != (_base_clock = base.clock) ? _base_clock : Date.now();
+    });
+    return {
+        seed,
+        clock,
+        algorithm: null != (_ref = null != (_over_algorithm = over.algorithm) ? _over_algorithm : base.algorithm) ? _ref : defaultAlgorithm,
+        attribution: over.attribution ? resolveAttribution(over.attribution) : null != (_base_attribution = base.attribution) ? _base_attribution : resolveAttribution(void 0),
+        types: null != (_ref1 = null != (_over_types = over.types) ? _over_types : base.types) ? _ref1 : registry,
+        limits: {
+            combinatorial: resolveCombinatorialLimit(null == (_this = null != (_over_limits = over.limits) ? _over_limits : base.limits) ? void 0 : _this.combinatorial)
+        }
+    };
+}
+function toStack() {
+    const frames = [];
+    return {
+        current: ()=>frames[frames.length - 1],
+        enter: (frame, block)=>{
+            frames.push(frame);
+            try {
+                return block();
+            } finally{
+                frames.pop();
+            }
+        }
+    };
+}
+function instantiate(config, stack) {
+    const source = toRandomSource({
+        seed: config.seed,
+        algorithm: config.algorithm,
+        attribution: config.attribution,
+        clock: resolveClock(config)
+    });
+    const Fabricator = Constructor(source, stack);
+    const { combinatorial, coverage } = enumerables(source, config.limits, stack);
+    function fork(forkOverlay = {}) {
+        return instantiate(overlay(config, forkOverlay), stack).instance;
+    }
+    function wrap(wrapOverlay, block) {
+        var _ref;
+        var _stack_current;
+        const base = null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.config) ? _ref : config;
+        const scopedConfig = overlay(base, wrapOverlay);
+        const scoped = instantiate(scopedConfig, stack);
+        return stack.enter({
+            config: scopedConfig,
+            source: scoped.source
+        }, ()=>block(scoped.instance));
+    }
+    const context = {
+        get seed () {
+            var _ref;
+            var _stack_current;
+            return normalizeSeed((null != (_ref = null == (_stack_current = stack.current()) ? void 0 : _stack_current.config) ? _ref : config).seed);
+        },
+        get algorithm () {
+            var _ref1;
+            var _stack_current1;
+            return (null != (_ref1 = null == (_stack_current1 = stack.current()) ? void 0 : _stack_current1.config) ? _ref1 : config).algorithm;
+        },
+        get attribution () {
+            var _ref2;
+            var _stack_current2;
+            return (null != (_ref2 = null == (_stack_current2 = stack.current()) ? void 0 : _stack_current2.config) ? _ref2 : config).attribution;
+        },
+        get clock () {
+            var _ref3;
+            var _stack_current3;
+            return resolveClock(null != (_ref3 = null == (_stack_current3 = stack.current()) ? void 0 : _stack_current3.config) ? _ref3 : config);
+        }
+    };
+    const instance = {
+        T: config.types,
+        Fabricator,
+        combinatorial,
+        coverage,
+        seed: source.seed,
+        fork,
+        wrap,
+        context
+    };
+    return {
+        instance,
+        source
+    };
+}
+export { DEFAULT_COMBINATORIAL_LIMIT, instantiate, overlay, toStack };

package/dist/esm/Instance/Types.js

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

package/dist/esm/Primitive/always/Fabricator.js

@@ -0,0 +1,13 @@
+import { Kind, Meta } from "../../Types.js";
+function Fabricator(context) {
+    const { schema, trace } = context;
+    const { value } = schema[Meta];
+    return {
+        [Kind]: "always",
+        [Meta]: schema[Meta],
+        trace,
+        fabricate: ()=>value,
+        schema
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/always/Registry.js

@@ -0,0 +1,11 @@
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Registry(value) {
+    return Schema({
+        [Kind]: "always",
+        [Meta]: {
+            value
+        }
+    });
+}
+export default Registry;

package/dist/esm/Primitive/always/Schema.js

@@ -0,0 +1,10 @@
+import { withAdaptations } from "../../Adapter/Core.js";
+import { Kind } from "../../Types.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "always",
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+export { Schema };

package/dist/esm/Primitive/always/Types.js

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

package/dist/esm/Primitive/always/index.js

@@ -0,0 +1,5 @@
+export * from "./Types.js";
+export * from "./Schema.js";
+export * from "./Fabricator.js";
+export * from "./Registry.js";
+export { default } from "./Registry.js";

package/dist/esm/Primitive/array/Fabricator.js

@@ -0,0 +1,45 @@
+import { effectiveDiscrete } from "../../Bound.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { inline } from "../../Utility/Core.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, element) {
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    const rehydrated = Schema(schema);
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        return {
+            [Kind]: "array",
+            [Meta]: meta,
+            trace,
+            [Children]: element,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const whereby = meta.whereby;
+    const fabricate = ()=>{
+        const length = inline(()=>{
+            const { min, max } = effectiveDiscrete(whereby.length.min, whereby.length.max);
+            return min + Math.floor(stream.next() * (max - min + 1));
+        });
+        return Array.from({
+            length
+        }, ()=>element.fabricate());
+    };
+    return {
+        [Kind]: "array",
+        [Meta]: meta,
+        trace,
+        [Children]: element,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/array/Registry.js

@@ -0,0 +1,26 @@
+import { toLengthRange } from "../../Bound.js";
+import { toSchema } from "../../Schema/Core.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Registry(definition) {
+    const normalized = toSchema(definition);
+    return {
+        whereby: (whereby)=>Schema({
+                [Kind]: "array",
+                [Meta]: {
+                    whereby: {
+                        length: toLengthRange(whereby.length, "T.array.whereby")
+                    },
+                    definition: normalized
+                }
+            }),
+        as: (produce)=>Schema({
+                [Kind]: "array",
+                [Meta]: {
+                    produce,
+                    definition: normalized
+                }
+            })
+    };
+}
+export default Registry;

package/dist/esm/Primitive/array/Schema.js

@@ -0,0 +1,17 @@
+import { withAdaptations } from "../../Adapter/Core.js";
+import { Kind, Meta } from "../../Types.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "array",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            }),
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+export { Schema };

package/dist/esm/Primitive/array/Types.js

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

package/dist/esm/Primitive/array/index.js

@@ -0,0 +1,5 @@
+export * from "./Types.js";
+export * from "./Schema.js";
+export * from "./Fabricator.js";
+export * from "./Registry.js";
+export { default } from "./Registry.js";

package/dist/esm/Primitive/bigint/Fabricator.js

@@ -0,0 +1,54 @@
+import { effectiveDiscreteBigint } from "../../Bound.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context) {
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    const rehydrated = Schema(schema);
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        return {
+            [Kind]: "bigint",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const { min, max } = effectiveDiscreteBigint(meta.whereby.min, meta.whereby.max);
+    const range = max - min + BigInt(1);
+    const byteBits = 8;
+    const bitWidth = range.toString(2).length;
+    const byteWidth = Math.ceil(bitWidth / byteBits);
+    const bitMask = (BigInt(1) << BigInt(bitWidth)) - BigInt(1);
+    const fabricate = ()=>{
+        const buffer = new Uint8Array(byteWidth);
+        const readBufferAsBigInt = ()=>{
+            let value = BigInt(0);
+            for (const byte of buffer)value = value << BigInt(byteBits) | BigInt(byte);
+            return value;
+        };
+        const sample = ()=>{
+            for(let i = 0; i < buffer.length; i++)buffer[i] = Math.floor(256 * stream.next());
+            return readBufferAsBigInt() & bitMask;
+        };
+        while(true){
+            const candidate = sample();
+            if (candidate < range) return min + candidate;
+        }
+    };
+    return {
+        [Kind]: "bigint",
+        [Meta]: meta,
+        trace,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/bigint/Registry.js

@@ -0,0 +1,31 @@
+import { assertNonemptyDiscreteBigint, toBound } from "../../Bound.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function toWhereby(input) {
+    const max = toBound(input.max);
+    const min = void 0 === input.min ? {
+        value: -max.value,
+        exclusive: false
+    } : toBound(input.min);
+    assertNonemptyDiscreteBigint("T.bigint.whereby", min, max);
+    return {
+        min,
+        max
+    };
+}
+const Registry = {
+    [Kind]: "bigint",
+    whereby: (whereby)=>Schema({
+            [Kind]: "bigint",
+            [Meta]: {
+                whereby: toWhereby(whereby)
+            }
+        }),
+    as: (produce)=>Schema({
+            [Kind]: "bigint",
+            [Meta]: {
+                produce
+            }
+        })
+};
+export default Registry;