@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,18 @@
+import { Kind, Meta } from "../../Types.js";
+function Schema(schema) {
+    return {
+        ...schema,
+        [Kind]: "object",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            })
+    };
+}
+function isObjectSchema(candidate) {
+    return "object" === candidate[Kind];
+}
+export { Schema, isObjectSchema };

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

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

package/dist/esm/Primitive/object/compute/Fabricator.js

@@ -0,0 +1,24 @@
+import { FabricatorError } from "../../../Error/index.js";
+import { violatesKind } from "../../../Schema/Core.js";
+import { Kind, Meta } from "../../../Types.js";
+function isObjectComputeFabricator(candidate) {
+    return "object.compute" === candidate[Kind];
+}
+function Fabricator(context) {
+    const { schema, trace } = context;
+    return {
+        [Kind]: "object.compute",
+        [Meta]: schema[Meta],
+        trace,
+        fabricate: (params)=>{
+            if (!params) throw new FabricatorError.DetachedComputeError();
+            const resolved = schema[Meta].resolve({
+                fabricated: params.fabricated
+            });
+            const sourceKind = schema[Meta].source[Kind];
+            if (violatesKind(sourceKind, resolved)) throw new FabricatorError.ComputeResultMismatchError(sourceKind, resolved);
+            return resolved;
+        }
+    };
+}
+export { Fabricator, isObjectComputeFabricator };

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

@@ -0,0 +1,15 @@
+import { Kind, Meta } from "../../../Types.js";
+import { Schema } from "./Schema.js";
+function make() {
+    return (source)=>({
+            as: (resolve)=>Schema({
+                    [Kind]: "object.compute",
+                    [Meta]: {
+                        source,
+                        resolve
+                    }
+                })
+        });
+}
+const Registry = make;
+export default Registry;

package/dist/esm/Primitive/object/compute/Schema.js

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

package/dist/esm/Primitive/object/compute/Types.js

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

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

@@ -0,0 +1,9 @@
+import * as __rspack_external__optional_index_js_f05de486 from "./optional/index.js";
+import * as __rspack_external__compute_index_js_a8316ce7 from "./compute/index.js";
+import * as __rspack_external__omittable_index_js_42741170 from "./omittable/index.js";
+export * from "./Types.js";
+export * from "./Schema.js";
+export * from "./Fabricator.js";
+export * from "./Registry.js";
+export { default } from "./Registry.js";
+export { __rspack_external__compute_index_js_a8316ce7 as compute, __rspack_external__omittable_index_js_42741170 as omittable, __rspack_external__optional_index_js_f05de486 as optional };

package/dist/esm/Primitive/object/omittable/Fabricator.js

@@ -0,0 +1,57 @@
+import { weighted } from "../../../Distribution/index.js";
+import { toStreamFromTrace } from "../../../Random/index.js";
+import { Children, Kind, Meta, Omitted } from "../../../Types.js";
+import { never } from "../../../Utility/Core.js";
+function isObjectOmittableFabricator(candidate) {
+    return "object.omittable" === candidate[Kind];
+}
+function Fabricator(context, source) {
+    var _ref, _ref1;
+    var _meta_weights, _meta_weights1;
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        return {
+            [Kind]: "object.omittable",
+            [Meta]: meta,
+            trace,
+            [Children]: source,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                })
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const pick = weighted([
+        [
+            null != (_ref = null == (_meta_weights = meta.weights) ? void 0 : _meta_weights.omitted) ? _ref : 1,
+            "omitted"
+        ],
+        [
+            null != (_ref1 = null == (_meta_weights1 = meta.weights) ? void 0 : _meta_weights1.value) ? _ref1 : 1,
+            "value"
+        ]
+    ], stream, "T.omittable");
+    const fabricate = ()=>{
+        const picked = pick();
+        switch(picked){
+            case "value":
+                return source.fabricate();
+            case "omitted":
+                return Omitted;
+            default:
+                never(picked);
+        }
+    };
+    return {
+        [Kind]: "object.omittable",
+        [Meta]: meta,
+        trace,
+        [Children]: source,
+        fabricate
+    };
+}
+export { Fabricator, isObjectOmittableFabricator };

package/dist/esm/Primitive/object/omittable/Outcomes.js

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

package/dist/esm/Primitive/object/omittable/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]: "object.omittable",
+        [Meta]: {
+            definition: normalized
+        }
+    });
+}
+export default Registry;

package/dist/esm/Primitive/object/omittable/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]: "object.omittable",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            }),
+        weighted: (weights)=>{
+            const merged = {
+                ...schema[Meta].weights,
+                ...weights
+            };
+            assertDrawableKeyedWeights("T.omittable.weighted", outcomes, merged);
+            return Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    weights: merged
+                }
+            });
+        },
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+function isObjectOmittableSchema(candidate) {
+    return "object.omittable" === candidate[Kind];
+}
+export { Schema, isObjectOmittableSchema };

package/dist/esm/Primitive/object/omittable/Types.js

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

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

@@ -0,0 +1,55 @@
+import { weighted } from "../../../Distribution/index.js";
+import { toStreamFromTrace } from "../../../Random/index.js";
+import { Children, Kind, Meta, Omitted } from "../../../Types.js";
+function isObjectOptionalFabricator(candidate) {
+    return "object.optional" === candidate[Kind];
+}
+function Fabricator(context, source) {
+    var _ref, _ref1, _ref2;
+    var _meta_weights, _meta_weights1, _meta_weights2;
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    if (meta.produce) {
+        const stream = toStreamFromTrace(algorithm, trace);
+        const produce = meta.produce;
+        return {
+            [Kind]: "object.optional",
+            [Meta]: meta,
+            trace,
+            [Children]: source,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                })
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const pick = weighted([
+        [
+            null != (_ref = null == (_meta_weights = meta.weights) ? void 0 : _meta_weights.omitted) ? _ref : 1,
+            "omitted"
+        ],
+        [
+            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.optional");
+    const fabricate = ()=>{
+        const outcome = pick();
+        if ("omitted" === outcome) return Omitted;
+        if ("undefined" === outcome) return;
+        return source.fabricate();
+    };
+    return {
+        [Kind]: "object.optional",
+        [Meta]: meta,
+        trace,
+        [Children]: source,
+        fabricate
+    };
+}
+export { Fabricator, isObjectOptionalFabricator };

package/dist/esm/Primitive/object/optional/Outcomes.js

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

package/dist/esm/Primitive/object/optional/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]: "object.optional",
+        [Meta]: {
+            definition: normalized
+        }
+    });
+}
+export default Registry;

package/dist/esm/Primitive/object/optional/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]: "object.optional",
+        as: (produce)=>Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    produce
+                }
+            }),
+        weighted: (weights)=>{
+            const merged = {
+                ...schema[Meta].weights,
+                ...weights
+            };
+            assertDrawableKeyedWeights("T.optional.weighted", outcomes, merged);
+            return Schema({
+                ...schema,
+                [Meta]: {
+                    ...schema[Meta],
+                    weights: merged
+                }
+            });
+        },
+        adapt: (adapter, produce)=>Schema(withAdaptations(schema, adapter, produce))
+    };
+}
+function isObjectOptionalSchema(candidate) {
+    return "object.optional" === candidate[Kind];
+}
+export { Schema, isObjectOptionalSchema };

package/dist/esm/Primitive/object/optional/Types.js

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

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

@@ -0,0 +1,19 @@
+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 stream = toStreamFromTrace(algorithm, trace);
+    return {
+        [Kind]: "opaque",
+        [Meta]: meta,
+        trace,
+        fabricate: ()=>meta.produce({
+                random: stream,
+                clock: trace.clock
+            }),
+        schema: Schema(schema)
+    };
+}
+export { Fabricator };

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

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

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

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

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

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

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

@@ -0,0 +1,55 @@
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, key, value) {
+    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]: "record",
+            [Meta]: meta,
+            trace,
+            [Children]: {
+                key,
+                value
+            },
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const { max, minTried = 0 } = meta.whereby.size;
+    const fabricate = ()=>{
+        const size = minTried + Math.floor(stream.next() * (max - minTried + 1));
+        const fabricated = {};
+        for(let i = 0; i < size; i++){
+            const k = key.fabricate();
+            const v = value.fabricate();
+            Object.defineProperty(fabricated, k, {
+                value: v,
+                enumerable: true,
+                writable: true,
+                configurable: true
+            });
+        }
+        return fabricated;
+    };
+    return {
+        [Kind]: "record",
+        [Meta]: meta,
+        trace,
+        [Children]: {
+            key,
+            value
+        },
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

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

@@ -0,0 +1,26 @@
+import { toSchema } from "../../Schema/Core.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Registry(key, value) {
+    const normalizedKey = toSchema(key);
+    const normalizedValue = toSchema(value);
+    return {
+        whereby: (whereby)=>Schema({
+                [Kind]: "record",
+                [Meta]: {
+                    whereby,
+                    key: normalizedKey,
+                    value: normalizedValue
+                }
+            }),
+        as: (produce)=>Schema({
+                [Kind]: "record",
+                [Meta]: {
+                    produce,
+                    key: normalizedKey,
+                    value: normalizedValue
+                }
+            })
+    };
+}
+export default Registry;

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, forkSource, make) {
+    const { schema, algorithm, trace } = context;
+    const meta = schema[Meta];
+    const rehydrated = Schema(schema);
+    const stream = toStreamFromTrace(algorithm, trace);
+    const privateSource = forkSource(stream.seed);
+    function fabricateAt(depth) {
+        const atMax = depth >= meta.depth.max;
+        const target = atMax ? meta.terminal : meta.body;
+        const construction = privateSource.toRoot("counted");
+        const context = {
+            toTrace: (path, kind)=>({
+                    ...construction,
+                    path,
+                    kind
+                }),
+            algorithm,
+            self: atMax ? void 0 : ()=>fabricateAt(depth + 1)
+        };
+        return make(target, [], context).fabricate();
+    }
+    return {
+        [Kind]: "recursive",
+        [Meta]: meta,
+        trace,
+        fabricate: ()=>fabricateAt(0),
+        schema: rehydrated
+    };
+}
+export { Fabricator };

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

@@ -0,0 +1,20 @@
+import { toSchema } from "../../Schema/Core.js";
+import { Kind, Meta } from "../../Types.js";
+import self_0 from "./self/index.js";
+import { Schema } from "./Schema.js";
+import { terminate } from "./Terminate.js";
+function Registry(body) {
+    const placeholder = self_0();
+    const resolvedBody = toSchema(body(placeholder));
+    return {
+        whereby: (config)=>Schema({
+                [Kind]: "recursive",
+                [Meta]: {
+                    body: resolvedBody,
+                    depth: config.depth,
+                    terminal: config.terminal ? toSchema(config.terminal) : terminate(resolvedBody)
+                }
+            })
+    };
+}
+export default Registry;

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

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