@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,58 @@
+import { weighted } from "../../Distribution/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { never } from "../../Utility/Core.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, source) {
+    var _ref, _ref1;
+    var _meta_weights, _meta_weights1;
+    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]: "nullable",
+            [Meta]: meta,
+            trace,
+            [Children]: source,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const pick = weighted([
+        [
+            null != (_ref = null == (_meta_weights = meta.weights) ? void 0 : _meta_weights.null) ? _ref : 1,
+            "null"
+        ],
+        [
+            null != (_ref1 = null == (_meta_weights1 = meta.weights) ? void 0 : _meta_weights1.value) ? _ref1 : 1,
+            "value"
+        ]
+    ], stream, "T.nullable");
+    const fabricate = ()=>{
+        const picked = pick();
+        switch(picked){
+            case "value":
+                return source.fabricate();
+            case "null":
+                return null;
+            default:
+                return never(picked);
+        }
+    };
+    return {
+        [Kind]: "nullable",
+        [Meta]: meta,
+        trace,
+        [Children]: source,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/nullable/Outcomes.js

@@ -0,0 +1,5 @@
+const outcomes = [
+    "null",
+    "value"
+];
+export { outcomes };

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

@@ -0,0 +1,13 @@
+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 Schema({
+        [Kind]: "nullable",
+        [Meta]: {
+            definition: normalized
+        }
+    });
+}
+export default Registry;

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

@@ -0,0 +1,36 @@
+import { withAdaptations } from "../../Adapter/Core.js";
+import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { outcomes } from "./Outcomes.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "nullable",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            }),
+        weighted: (weights)=>{
+            const merged = {
+                ...schema[Meta].weights,
+                ...weights
+            };
+            assertDrawableKeyedWeights("T.nullable.weighted", outcomes, merged);
+            return Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    weights: merged
+                }
+            });
+        },
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+function isNullableSchema(candidate) {
+    return "nullable" === candidate[Kind];
+}
+export { Schema, isNullableSchema };

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

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

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

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

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

@@ -0,0 +1,64 @@
+import { weighted } from "../../Distribution/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { never } from "../../Utility/Core.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, source) {
+    var _ref, _ref1, _ref2;
+    var _meta_weights, _meta_weights1, _meta_weights2;
+    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]: "nullish",
+            [Meta]: meta,
+            trace,
+            [Children]: source,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const pick = weighted([
+        [
+            null != (_ref = null == (_meta_weights = meta.weights) ? void 0 : _meta_weights.null) ? _ref : 1,
+            "null"
+        ],
+        [
+            null != (_ref1 = null == (_meta_weights1 = meta.weights) ? void 0 : _meta_weights1.undefined) ? _ref1 : 1,
+            "undefined"
+        ],
+        [
+            null != (_ref2 = null == (_meta_weights2 = meta.weights) ? void 0 : _meta_weights2.value) ? _ref2 : 1,
+            "value"
+        ]
+    ], stream, "T.nullish");
+    const fabricate = ()=>{
+        const picked = pick();
+        switch(picked){
+            case "value":
+                return source.fabricate();
+            case "null":
+                return null;
+            case "undefined":
+                return;
+            default:
+                return never(picked);
+        }
+    };
+    return {
+        [Kind]: "nullish",
+        [Meta]: meta,
+        trace,
+        [Children]: source,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/nullish/Outcomes.js

@@ -0,0 +1,6 @@
+const outcomes = [
+    "null",
+    "undefined",
+    "value"
+];
+export { outcomes };

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

@@ -0,0 +1,13 @@
+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 Schema({
+        [Kind]: "nullish",
+        [Meta]: {
+            definition: normalized
+        }
+    });
+}
+export default Registry;

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

@@ -0,0 +1,36 @@
+import { withAdaptations } from "../../Adapter/Core.js";
+import { assertDrawableKeyedWeights } from "../../Distribution/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { outcomes } from "./Outcomes.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "nullish",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            }),
+        weighted: (weights)=>{
+            const merged = {
+                ...schema[Meta].weights,
+                ...weights
+            };
+            assertDrawableKeyedWeights("T.nullish.weighted", outcomes, merged);
+            return Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    weights: merged
+                }
+            });
+        },
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+function isNullishSchema(candidate) {
+    return "nullish" === candidate[Kind];
+}
+export { Schema, isNullishSchema };

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

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

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

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

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

@@ -0,0 +1,73 @@
+import { constrainContinuous, effectiveDiscrete } from "../../Bound.js";
+import { Distribution, sampler } from "../../Distribution/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { unboundedContinuous, unboundedDiscrete } from "./defaults.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context) {
+    var _ref, _ref1, _range_distribution;
+    var _meta_whereby, _meta_whereby1, _meta_whereby2;
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    const rehydrated = Schema({
+        ...schema,
+        [Meta]: meta
+    });
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        return {
+            [Kind]: "number",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    if (meta.sequence) {
+        let next = 1;
+        return {
+            [Kind]: "number",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>next++,
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const defaults = meta.integer ? unboundedDiscrete : unboundedContinuous;
+    const range = {
+        min: null != (_ref = null == (_meta_whereby = meta.whereby) ? void 0 : _meta_whereby.min) ? _ref : defaults.min,
+        max: null != (_ref1 = null == (_meta_whereby1 = meta.whereby) ? void 0 : _meta_whereby1.max) ? _ref1 : defaults.max,
+        distribution: null == (_meta_whereby2 = meta.whereby) ? void 0 : _meta_whereby2.distribution
+    };
+    const distribution = null != (_range_distribution = range.distribution) ? _range_distribution : Distribution.uniform();
+    if (meta.integer) {
+        const { min, max } = effectiveDiscrete(range.min, range.max);
+        const draw = sampler(distribution, {
+            min,
+            max: max + 1
+        }, stream);
+        return {
+            [Kind]: "number",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>Math.min(max, Math.floor(draw())),
+            schema: rehydrated
+        };
+    }
+    return {
+        [Kind]: "number",
+        [Meta]: meta,
+        trace,
+        fabricate: constrainContinuous(sampler(distribution, {
+            min: range.min.value,
+            max: range.max.value
+        }, stream), range.min, range.max),
+        schema: rehydrated
+    };
+}
+export { Fabricator };

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

@@ -0,0 +1,59 @@
+import { assertNonemptyContinuous, assertNonemptyDiscrete, toBound } from "../../Bound.js";
+import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
+import bigint from "../bigint/index.js";
+import { unboundedContinuous, unboundedDiscrete } from "./defaults.js";
+import { Schema } from "./Schema.js";
+function toWhereby(input, integer) {
+    const min = void 0 === input.min ? void 0 : toBound(input.min);
+    const max = void 0 === input.max ? void 0 : toBound(input.max);
+    const defaults = integer ? unboundedDiscrete : unboundedContinuous;
+    const label = integer ? "T.number.integer.whereby" : "T.number.whereby";
+    if (integer) assertNonemptyDiscrete(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
+    else assertNonemptyContinuous(label, null != min ? min : defaults.min, null != max ? max : defaults.max);
+    return void 0 === input.distribution ? {
+        min,
+        max
+    } : {
+        min,
+        max,
+        distribution: input.distribution
+    };
+}
+const Registry = {
+    ...Schema({
+        [Kind]: "number",
+        [Meta]: {},
+        [Produces]: void 0,
+        [Adaptation]: void 0
+    }),
+    whereby: (whereby)=>Schema({
+            [Kind]: "number",
+            [Meta]: {
+                whereby: toWhereby(whereby, false)
+            }
+        }),
+    integer: {
+        ...Schema({
+            [Kind]: "number",
+            [Meta]: {
+                integer: true
+            }
+        }),
+        whereby: (whereby)=>Schema({
+                [Kind]: "number",
+                [Meta]: {
+                    integer: true,
+                    whereby: toWhereby(whereby, true)
+                }
+            }),
+        sequence: Schema({
+            [Kind]: "number",
+            [Meta]: {
+                sequence: true,
+                integer: true
+            }
+        }),
+        big: bigint
+    }
+};
+export default Registry;

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

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

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

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

package/dist/esm/Primitive/number/defaults.js

@@ -0,0 +1,21 @@
+const unboundedContinuous = {
+    min: {
+        value: -Number.MAX_VALUE,
+        exclusive: false
+    },
+    max: {
+        value: Number.MAX_VALUE,
+        exclusive: false
+    }
+};
+const unboundedDiscrete = {
+    min: {
+        value: -Number.MAX_SAFE_INTEGER,
+        exclusive: false
+    },
+    max: {
+        value: Number.MAX_SAFE_INTEGER,
+        exclusive: false
+    }
+};
+export { unboundedContinuous, unboundedDiscrete };

package/dist/esm/Primitive/number/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/object/Fabricator.js

@@ -0,0 +1,77 @@
+import { FabricatorError } from "../../Error/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta, Omitted } from "../../Types.js";
+import { isPollutionKey } from "../../Utility/Core.js";
+import { isObjectComputeFabricator } from "./compute/Fabricator.js";
+import { isObjectOmittableFabricator } from "./omittable/Fabricator.js";
+import { isObjectOptionalFabricator } from "./optional/Fabricator.js";
+function isObjectFabricator(candidate) {
+    return "object" === candidate[Kind];
+}
+function Fabricator(context, fields) {
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        const fabricate = (overrides, config)=>{
+            const produced = produce({
+                random: stream,
+                clock: trace.clock
+            });
+            if (!overrides) return produced;
+            if ((null == config ? void 0 : config.validate) !== false) schema.override(overrides);
+            const result = {
+                ...produced,
+                ...overrides
+            };
+            for (const [k, v] of Object.entries(overrides))if (v === Omitted) delete result[k];
+            return result;
+        };
+        return {
+            [Kind]: "object",
+            [Meta]: meta,
+            trace,
+            [Children]: fields,
+            fabricate,
+            schema
+        };
+    }
+    const fabricate = (overrides, config)=>{
+        if (overrides && (null == config ? void 0 : config.validate) !== false) schema.override(overrides);
+        const fabricated = {};
+        const deferred = [];
+        for (const [k, v] of Object.entries(fields)){
+            if (isPollutionKey(k)) throw new FabricatorError.PrototypePollutionError(k);
+            if (overrides && k in overrides) {
+                const value = overrides[k];
+                if (value === Omitted) continue;
+                fabricated[k] = isObjectFabricator(v) ? v.fabricate(value, {
+                    validate: false
+                }) : value;
+                continue;
+            }
+            if (isObjectOmittableFabricator(v) || isObjectOptionalFabricator(v)) {
+                const value = v.fabricate();
+                if (value !== Omitted) fabricated[k] = value;
+            } else if (isObjectComputeFabricator(v)) deferred.push([
+                k,
+                v
+            ]);
+            else fabricated[k] = v.fabricate();
+        }
+        for (const [k, v] of deferred)fabricated[k] = v.fabricate({
+            fabricated
+        });
+        return fabricated;
+    };
+    return {
+        [Kind]: "object",
+        [Meta]: schema[Meta],
+        trace,
+        [Children]: fields,
+        fabricate,
+        schema
+    };
+}
+export { Fabricator, isObjectFabricator };

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

@@ -0,0 +1,146 @@
+import { mergeAdaptations } from "../../Adapter/Core.js";
+import { FabricatorError } from "../../Error/index.js";
+import { toSchema, violatesKind } from "../../Schema/Core.js";
+import { Adaptation, Fixed, Kind, Meta, Omitted } from "../../Types.js";
+import { isPlainObject } from "../../Utility/Core.js";
+import { shallowMerge } from "../../Utility/ShallowMerge.js";
+import { isNullableSchema } from "../nullable/Schema.js";
+import { isNullishSchema } from "../nullish/Schema.js";
+import { isUndefinableSchema } from "../undefinable/Schema.js";
+import compute_0, { isObjectComputeSchema } from "./compute/index.js";
+import { isObjectOmittableSchema } from "./omittable/Schema.js";
+import { isObjectOptionalSchema } from "./optional/Schema.js";
+import { Schema, isObjectSchema } from "./Schema.js";
+function normalizeDefinition(definition) {
+    return Object.fromEntries(Object.entries(definition).map(([k, v])=>[
+            k,
+            toSchema(v)
+        ]));
+}
+function make(definition, refinements, adaptations) {
+    const schema = Schema({
+        [Kind]: "object",
+        [Meta]: {
+            definition,
+            refinements
+        },
+        ...adaptations ? {
+            [Adaptation]: adaptations
+        } : void 0,
+        extend: (extender)=>{
+            const extension = normalizeDefinition(extender({
+                base: definition
+            }));
+            const merged = shallowMerge(definition, extension);
+            return make(merged, refinements, adaptations);
+        },
+        refine: (refiner)=>{
+            const compute = compute_0();
+            const refinement = normalizeDefinition(refiner({
+                base: schema,
+                compute
+            }));
+            return make(shallowMerge(definition, refinement), [
+                ...refinements,
+                refinement
+            ], adaptations);
+        },
+        adapt: (adapter, produce)=>make(definition, refinements, mergeAdaptations(adaptations, adapter, produce)),
+        override: (override)=>{
+            const overridden = {
+                ...definition
+            };
+            for (const key of Object.keys(override)){
+                const fieldSchema = definition[key];
+                if (!fieldSchema) throw new FabricatorError.UnknownOverrideFieldError(key, Object.keys(definition));
+                const value = override[key];
+                if (isObjectSchema(fieldSchema)) {
+                    if (!isPlainObject(value)) throw new FabricatorError.InvalidOverrideValueError(key, "object", value);
+                    overridden[key] = toSchema(rehydrate(fieldSchema).override(value));
+                    continue;
+                }
+                if (isObjectOmittableSchema(fieldSchema)) {
+                    if (value === Omitted) {
+                        overridden[key] = {
+                            ...toSchema(fieldSchema),
+                            [Fixed]: Omitted
+                        };
+                        continue;
+                    }
+                    const innerKind = fieldSchema[Meta].definition[Kind];
+                    if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
+                    overridden[key] = {
+                        ...toSchema(fieldSchema),
+                        [Fixed]: value
+                    };
+                    continue;
+                }
+                if (isObjectOptionalSchema(fieldSchema)) {
+                    if (value === Omitted || void 0 === value) {
+                        overridden[key] = {
+                            ...toSchema(fieldSchema),
+                            [Fixed]: value
+                        };
+                        continue;
+                    }
+                    const innerKind = fieldSchema[Meta].definition[Kind];
+                    if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
+                    overridden[key] = {
+                        ...toSchema(fieldSchema),
+                        [Fixed]: value
+                    };
+                    continue;
+                }
+                if (isUndefinableSchema(fieldSchema)) {
+                    if (void 0 !== value) {
+                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
+                    }
+                    overridden[key] = {
+                        ...toSchema(fieldSchema),
+                        [Fixed]: value
+                    };
+                    continue;
+                }
+                if (isNullableSchema(fieldSchema)) {
+                    if (null !== value) {
+                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
+                    }
+                    overridden[key] = {
+                        ...toSchema(fieldSchema),
+                        [Fixed]: value
+                    };
+                    continue;
+                }
+                if (isNullishSchema(fieldSchema)) {
+                    if (null != value) {
+                        const innerKind = fieldSchema[Meta].definition[Kind];
+                        if (violatesKind(innerKind, value)) throw new FabricatorError.InvalidOverrideValueError(key, innerKind, value);
+                    }
+                    overridden[key] = {
+                        ...toSchema(fieldSchema),
+                        [Fixed]: value
+                    };
+                    continue;
+                }
+                if (value === Omitted) throw new FabricatorError.IllegalOmittedOverrideError(key, fieldSchema[Kind]);
+                const kind = isObjectComputeSchema(fieldSchema) ? fieldSchema[Meta].source[Kind] : fieldSchema[Kind];
+                if (violatesKind(kind, value)) throw new FabricatorError.InvalidOverrideValueError(key, kind, value);
+                overridden[key] = {
+                    ...toSchema(fieldSchema),
+                    [Fixed]: value
+                };
+            }
+            return make(overridden, refinements, adaptations);
+        }
+    });
+    return schema;
+}
+function rehydrate(schema) {
+    const rehydrated = make(schema[Meta].definition, schema[Meta].refinements, schema[Adaptation]);
+    return schema[Meta].produce ? rehydrated.as(schema[Meta].produce) : rehydrated;
+}
+const Registry = (definition)=>make(normalizeDefinition(definition), []);
+export default Registry;
+export { rehydrate };