@ghostry/fabricator 0.0.1

package/dist/esm/Enumeration/Plan.js

@@ -0,0 +1,286 @@
+import { drawableOutcomes, isDrawable } from "../Distribution/index.js";
+import { FabricatorError } from "../Error/index.js";
+import { outcomes } from "../Primitive/boolean/Outcomes.js";
+import { outcomes as Outcomes_js_outcomes } from "../Primitive/nullable/Outcomes.js";
+import { outcomes as nullish_Outcomes_js_outcomes } from "../Primitive/nullish/Outcomes.js";
+import { outcomes as omittable_Outcomes_js_outcomes } from "../Primitive/object/omittable/Outcomes.js";
+import { outcomes as optional_Outcomes_js_outcomes } from "../Primitive/object/optional/Outcomes.js";
+import { outcomes as undefinable_Outcomes_js_outcomes } from "../Primitive/undefinable/Outcomes.js";
+import { Children, Fixed, Kind, Meta, Omitted } from "../Types.js";
+import { never } from "../Utility/Core.js";
+function leaf() {
+    return {
+        width: BigInt(1),
+        at: ()=>void 0
+    };
+}
+function literal(value) {
+    return {
+        kind: "literal",
+        value
+    };
+}
+function delegate(axis, index) {
+    return {
+        kind: "delegate",
+        axis,
+        index
+    };
+}
+function sumAxis(branches) {
+    const width = branches.reduce((total, branch)=>total + ("literal" === branch.kind ? BigInt(1) : branch.axis.width), BigInt(0));
+    function at(index) {
+        let remaining = index;
+        for(let i = 0; i < branches.length; i++){
+            const branch = branches[i];
+            const branchWidth = "literal" === branch.kind ? BigInt(1) : branch.axis.width;
+            if (remaining < branchWidth) return "literal" === branch.kind ? {
+                value: branch.value
+            } : {
+                branch: branch.index,
+                inner: branch.axis.at(remaining)
+            };
+            remaining -= branchWidth;
+        }
+        throw new FabricatorError.EnumerationIndexError(index, width);
+    }
+    return {
+        width,
+        at
+    };
+}
+function productAxis(strategy, axes, assemble) {
+    switch(strategy){
+        case "cycle":
+            {
+                const width = axes.reduce((widest, axis)=>axis.width > widest ? axis.width : widest, BigInt(1));
+                return {
+                    width,
+                    at: (index)=>assemble(axes.map((axis)=>axis.at(index)))
+                };
+            }
+        case "product":
+            {
+                const width = axes.reduce((total, axis)=>total * axis.width, BigInt(1));
+                function at(index) {
+                    const pins = new Array(axes.length);
+                    let remaining = index;
+                    for(let i = axes.length - 1; i >= 0; i--){
+                        const axis = axes[i];
+                        pins[i] = axis.at(remaining % axis.width);
+                        remaining /= axis.width;
+                    }
+                    return assemble(pins);
+                }
+                return {
+                    width,
+                    at
+                };
+            }
+    }
+}
+function plan(node, planning) {
+    const axis = axisFor(node, planning);
+    switch(planning.strategy){
+        case "product":
+            return axis;
+        case "cycle":
+            {
+                if (axis.width <= BigInt(1)) return axis;
+                const order = planning.orderer(axis.width);
+                return {
+                    width: axis.width,
+                    at: (index)=>axis.at(order[Number(index % axis.width)])
+                };
+            }
+    }
+}
+function axisFor(node, planning) {
+    var _node_Meta;
+    if (null == (_node_Meta = node[Meta]) ? void 0 : _node_Meta.produce) return leaf();
+    const kind = node[Kind];
+    switch(kind){
+        case "enum":
+            {
+                const items = node[Meta].items;
+                const drawable = items.filter(([weight])=>isDrawable(weight));
+                return {
+                    width: BigInt(drawable.length),
+                    at: (index)=>({
+                            value: drawable[Number(index)][1]
+                        })
+                };
+            }
+        case "boolean":
+            {
+                const names = drawableOutcomes(outcomes, node[Meta].weights);
+                return {
+                    width: BigInt(names.length),
+                    at: (index)=>({
+                            value: "true" === names[Number(index)]
+                        })
+                };
+            }
+        case "choice":
+            {
+                const items = node[Meta].items;
+                const options = node[Children];
+                const branches = [];
+                for(let i = 0; i < items.length; i++)if (isDrawable(items[i][0])) branches.push(delegate(plan(options[i], planning), i));
+                return sumAxis(branches);
+            }
+        case "nullable":
+            return sumAxis(drawableOutcomes(Outcomes_js_outcomes, node[Meta].weights).map((name, i)=>{
+                switch(name){
+                    case "null":
+                        return literal(null);
+                    case "value":
+                        return delegate(plan(node[Children], planning), i);
+                }
+            }));
+        case "nullish":
+            return sumAxis(drawableOutcomes(nullish_Outcomes_js_outcomes, node[Meta].weights).map((name, i)=>{
+                switch(name){
+                    case "null":
+                        return literal(null);
+                    case "undefined":
+                        return literal(void 0);
+                    case "value":
+                        return delegate(plan(node[Children], planning), i);
+                }
+            }));
+        case "undefinable":
+            return sumAxis(drawableOutcomes(undefinable_Outcomes_js_outcomes, node[Meta].weights).map((name, i)=>{
+                switch(name){
+                    case "undefined":
+                        return literal(void 0);
+                    case "value":
+                        return delegate(plan(node[Children], planning), i);
+                }
+            }));
+        case "object.omittable":
+            return sumAxis(drawableOutcomes(omittable_Outcomes_js_outcomes, node[Meta].weights).map((name, i)=>{
+                switch(name){
+                    case "omitted":
+                        return literal(Omitted);
+                    case "value":
+                        return delegate(plan(node[Children], planning), i);
+                }
+            }));
+        case "object.optional":
+            return sumAxis(drawableOutcomes(optional_Outcomes_js_outcomes, node[Meta].weights).map((name, i)=>{
+                switch(name){
+                    case "omitted":
+                        return literal(Omitted);
+                    case "undefined":
+                        return literal(void 0);
+                    case "value":
+                        return delegate(plan(node[Children], planning), i);
+                }
+            }));
+        case "tuple":
+            {
+                const elements = node[Children];
+                const axes = elements.map((element)=>plan(element, planning));
+                return productAxis(planning.strategy, axes, (slots)=>({
+                        slots
+                    }));
+            }
+        case "object":
+            {
+                const definition = node[Meta].definition;
+                const fields = node[Children];
+                const keys = [];
+                const axes = [];
+                for (const key of Object.keys(fields)){
+                    const fieldSchema = definition[key];
+                    const fieldFabricator = fields[key];
+                    if (fieldSchema && Fixed in fieldSchema) {
+                        keys.push(key);
+                        axes.push(leaf());
+                        continue;
+                    }
+                    if ("object.compute" !== fieldFabricator[Kind]) {
+                        keys.push(key);
+                        axes.push(plan(fieldFabricator, planning));
+                    }
+                }
+                return productAxis(planning.strategy, axes, (pins)=>{
+                    const fieldsPin = {};
+                    for(let i = 0; i < keys.length; i++)fieldsPin[keys[i]] = pins[i];
+                    return {
+                        fields: fieldsPin
+                    };
+                });
+            }
+        case "always":
+        case "null":
+        case "undefined":
+        case "string":
+        case "number":
+        case "bigint":
+        case "date":
+        case "symbol":
+        case "opaque":
+        case "array":
+        case "record":
+        case "recursive":
+        case "recursive.self":
+        case "object.compute":
+            return leaf();
+        default:
+            return never(kind);
+    }
+}
+function toOverride(fieldsPin, fields) {
+    const overrides = {};
+    for (const key of Object.keys(fieldsPin)){
+        const pin = fieldsPin[key];
+        if (void 0 === pin) continue;
+        const fieldFabricator = fields[key];
+        overrides[key] = "object" === fieldFabricator[Kind] ? toOverride(pin.fields, fieldFabricator[Children]) : resolve(fieldFabricator, pin);
+    }
+    return overrides;
+}
+function resolve(node, pin) {
+    if (void 0 === pin) return node.fabricate();
+    const kind = node[Kind];
+    switch(kind){
+        case "enum":
+        case "boolean":
+            return pin.value;
+        case "choice":
+            {
+                const p = pin;
+                const options = node[Children];
+                return resolve(options[p.branch], p.inner);
+            }
+        case "nullable":
+        case "nullish":
+        case "undefinable":
+        case "object.omittable":
+        case "object.optional":
+            {
+                if ("value" in pin) return pin.value;
+                const p = pin;
+                return resolve(node[Children], p.inner);
+            }
+        case "tuple":
+            {
+                const p = pin;
+                const elements = node[Children];
+                return elements.map((element, i)=>resolve(element, p.slots[i]));
+            }
+        case "object":
+            {
+                const p = pin;
+                const overrides = toOverride(p.fields, node[Children]);
+                return node.fabricate(overrides, {
+                    validate: false
+                });
+            }
+        default:
+            throw new FabricatorError.UnpinnableKindError(kind);
+    }
+}
+export { plan, resolve };

package/dist/esm/Enumeration/Types.js

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

package/dist/esm/Error/index.js

@@ -0,0 +1,201 @@
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class Error_FabricatorError extends Error {
+    constructor(){
+        super();
+        this.name = "FabricatorError";
+    }
+}
+(function(FabricatorError) {
+    function phrase(during) {
+        switch(during){
+            case "construction":
+                return "building a Fabricator";
+            case "adaptation":
+                return "converting to an external schema";
+        }
+    }
+    class InvalidCombinatorialLimitError extends FabricatorError {
+        constructor(limit){
+            super(), _define_property(this, "limit", void 0), this.limit = limit;
+            this.name = "InvalidCombinatorialLimitError";
+            this.message = `initialize({ limits: { combinatorial } }) requires a positive safe integer; received ${String(limit)}.`;
+        }
+    }
+    FabricatorError.InvalidCombinatorialLimitError = InvalidCombinatorialLimitError;
+    class InvalidAttributionRootError extends FabricatorError {
+        constructor(root){
+            super(), _define_property(this, "root", void 0), this.root = root;
+            this.name = "InvalidAttributionRootError";
+            this.message = `initialize({ attribution: { kind: "rooted", root } }) requires an absolute path or a "file://" URL; received "${root}".`;
+        }
+    }
+    FabricatorError.InvalidAttributionRootError = InvalidAttributionRootError;
+    class DetachedSelfError extends FabricatorError {
+        constructor(during){
+            super(), _define_property(this, "during", void 0), this.during = during;
+            this.name = "DetachedSelfError";
+            this.message = `\`self\` was used outside any active \`T.recursive\` while ${phrase(during)} — it can only appear inside the body (or terminal) passed to \`T.recursive(...)\`, and a \`self\` captured out of that callback cannot be reused elsewhere.`;
+        }
+    }
+    FabricatorError.DetachedSelfError = DetachedSelfError;
+    class UnterminableRecursiveError extends FabricatorError {
+        constructor(path){
+            super(), _define_property(this, "path", void 0), this.path = path;
+            this.name = "UnterminableRecursiveError";
+            const where = 0 === path.length ? "the recursive body itself" : `"${path.join(".")}"`;
+            this.message = `T.recursive cannot derive a terminal: self at ${where} is not behind a kind that can stop recursing. Wrap it in an array, record, choice, omittable, optional, nullable, nullish, or undefinable, or pass an explicit terminal.`;
+        }
+    }
+    FabricatorError.UnterminableRecursiveError = UnterminableRecursiveError;
+    class UnknownKindError extends FabricatorError {
+        constructor(kind, during){
+            super(), _define_property(this, "kind", void 0), _define_property(this, "during", void 0), this.kind = kind, this.during = during;
+            this.name = "UnknownKindError";
+            this.message = `Cannot dispatch a Schema of unknown kind "${kind}" while ${phrase(during)}.`;
+        }
+    }
+    FabricatorError.UnknownKindError = UnknownKindError;
+    class EmptyItemsError extends FabricatorError {
+        constructor(label, noun){
+            super(), _define_property(this, "label", void 0), _define_property(this, "noun", void 0), this.label = label, this.noun = noun;
+            this.name = "EmptyItemsError";
+            this.message = `${label} requires at least one ${noun}.`;
+        }
+    }
+    FabricatorError.EmptyItemsError = EmptyItemsError;
+    class PrototypePollutionError extends FabricatorError {
+        constructor(key){
+            super(), _define_property(this, "key", void 0), this.key = key;
+            this.name = "PrototypePollutionError";
+            this.message = `Potential prototype pollution blocked for key: ${key}. An object schema cannot define a field named \`__proto__\`, \`constructor\`, or \`prototype\`.`;
+        }
+    }
+    FabricatorError.PrototypePollutionError = PrototypePollutionError;
+    class DetachedComputeError extends FabricatorError {
+        constructor(){
+            super();
+            this.name = "DetachedComputeError";
+            this.message = "A `.refine()`-computed field can only be fabricated as part of its parent object, which supplies the already-fabricated fields its resolver reads.";
+        }
+    }
+    FabricatorError.DetachedComputeError = DetachedComputeError;
+    class ComputeResultMismatchError extends FabricatorError {
+        constructor(kind, value){
+            super(), _define_property(this, "kind", void 0), _define_property(this, "value", void 0), this.kind = kind, this.value = value;
+            this.name = "ComputeResultMismatchError";
+            this.message = `A \`.refine()\`-computed field's resolver returned a value of type ${typeof value} that does not match its "${kind}" source schema.`;
+        }
+    }
+    FabricatorError.ComputeResultMismatchError = ComputeResultMismatchError;
+    class UnknownOverrideFieldError extends FabricatorError {
+        constructor(field, available){
+            super(), _define_property(this, "field", void 0), _define_property(this, "available", void 0), this.field = field, this.available = available;
+            this.name = "UnknownOverrideFieldError";
+            this.message = `Cannot override unknown field: "${field}". This object schema defines ` + (0 === available.length ? "no fields." : `${available.map((k)=>`"${k}"`).join(", ")}.`);
+        }
+    }
+    FabricatorError.UnknownOverrideFieldError = UnknownOverrideFieldError;
+    class InvalidOverrideValueError extends FabricatorError {
+        constructor(field, kind, value){
+            super(), _define_property(this, "field", void 0), _define_property(this, "kind", void 0), _define_property(this, "value", void 0), this.field = field, this.kind = kind, this.value = value;
+            this.name = "InvalidOverrideValueError";
+            this.message = `Cannot override field "${field}": a value of type ${typeof value} does not match its "${kind}" schema.`;
+        }
+    }
+    FabricatorError.InvalidOverrideValueError = InvalidOverrideValueError;
+    class IllegalOmittedOverrideError extends FabricatorError {
+        constructor(field, kind){
+            super(), _define_property(this, "field", void 0), _define_property(this, "kind", void 0), this.field = field, this.kind = kind;
+            this.name = "IllegalOmittedOverrideError";
+            this.message = `Cannot override field "${field}" with Omitted: a "${kind}" field is neither omittable nor optional, so it has no absent outcome to select.`;
+        }
+    }
+    FabricatorError.IllegalOmittedOverrideError = IllegalOmittedOverrideError;
+    class EnumerationIndexError extends FabricatorError {
+        constructor(index, width){
+            super(), _define_property(this, "index", void 0), _define_property(this, "width", void 0), this.index = index, this.width = width;
+            this.name = "EnumerationIndexError";
+            this.message = `Enumeration index ${index} is out of range for an axis of width ${width}.`;
+        }
+    }
+    FabricatorError.EnumerationIndexError = EnumerationIndexError;
+    class UnpinnableKindError extends FabricatorError {
+        constructor(kind){
+            super(), _define_property(this, "kind", void 0), this.kind = kind;
+            this.name = "UnpinnableKindError";
+            this.message = `resolve() received a pin for kind "${kind}", which plan() never gives one to.`;
+        }
+    }
+    FabricatorError.UnpinnableKindError = UnpinnableKindError;
+    class CombinatorialLimitExceededError extends FabricatorError {
+        constructor(width, limit){
+            super(), _define_property(this, "width", void 0), _define_property(this, "limit", void 0), this.width = width, this.limit = limit;
+            this.name = "CombinatorialLimitExceededError";
+            this.message = `combinatorial(...) would enumerate ${width} instances which is over the configured limit of ${limit}. Raise it with initialize({ limits: { combinatorial } }), or use coverage(...), which needs only as many instances as the widest single axis.`;
+        }
+    }
+    FabricatorError.CombinatorialLimitExceededError = CombinatorialLimitExceededError;
+    class UnrepresentableRecordKeyError extends FabricatorError {
+        constructor(kind){
+            super(), _define_property(this, "kind", void 0), this.kind = kind;
+            this.name = "UnrepresentableRecordKeyError";
+            this.message = `Cannot map a "record" schema keyed by "${kind}" to an external schema: the target has no record with keys of that type. Use .adapt(adapter, ...) to supply one.`;
+        }
+    }
+    FabricatorError.UnrepresentableRecordKeyError = UnrepresentableRecordKeyError;
+    class EmptyRangeError extends FabricatorError {
+        constructor(label, min, max){
+            super(), _define_property(this, "label", void 0), _define_property(this, "min", void 0), _define_property(this, "max", void 0), this.label = label, this.min = min, this.max = max;
+            this.name = "EmptyRangeError";
+            this.message = `${label} produces an empty range (min=${describeBound(min)}, max=${describeBound(max)}).`;
+        }
+    }
+    FabricatorError.EmptyRangeError = EmptyRangeError;
+    function describeBound(bound) {
+        const value = String(bound.value);
+        return bound.exclusive ? `{ value: ${value}, exclusive: true }` : value;
+    }
+    class InvalidDistributionBoundError extends FabricatorError {
+        constructor(distribution, min, max){
+            super(), _define_property(this, "distribution", void 0), _define_property(this, "min", void 0), _define_property(this, "max", void 0), this.distribution = distribution, this.min = min, this.max = max;
+            this.name = "InvalidDistributionBoundError";
+            this.message = `The ${distribution} distribution requires min > 0 (received min=${min}, max=${max}); its density is proportional to 1/x and undefined at or below zero.`;
+        }
+    }
+    FabricatorError.InvalidDistributionBoundError = InvalidDistributionBoundError;
+    class InvalidWeightError extends FabricatorError {
+        constructor(label, weight, entry){
+            super(), _define_property(this, "label", void 0), _define_property(this, "weight", void 0), _define_property(this, "entry", void 0), this.label = label, this.weight = weight, this.entry = entry;
+            this.name = "InvalidWeightError";
+            const where = "index" === entry.kind ? `${entry.noun} at index ${entry.index}` : `"${entry.name}"`;
+            this.message = `${label} requires every weight to be a finite number ≥ 0; ${where} has weight ${weight}. Zero disables an outcome; a negative weight, NaN, or Infinity is invalid.`;
+        }
+    }
+    FabricatorError.InvalidWeightError = InvalidWeightError;
+    class NoDrawableOutcomesError extends FabricatorError {
+        constructor(label, noun){
+            super(), _define_property(this, "label", void 0), _define_property(this, "noun", void 0), this.label = label, this.noun = noun;
+            this.name = "NoDrawableOutcomesError";
+            this.message = `${label} leaves no drawable ${noun}. Zeroing an outcome disables it, so at least one must keep a positive weight.`;
+        }
+    }
+    FabricatorError.NoDrawableOutcomesError = NoDrawableOutcomesError;
+    class TraceKindMismatchError extends FabricatorError {
+        constructor(expected, given){
+            super(), _define_property(this, "expected", void 0), _define_property(this, "given", void 0), this.expected = expected, this.given = given;
+            this.name = "TraceKindMismatchError";
+            this.message = `Cannot build from a trace for kind "${given}": this schema's kind is "${expected}". A trace reproduces the node it was taken from, so its kind must match the schema it is replayed against.`;
+        }
+    }
+    FabricatorError.TraceKindMismatchError = TraceKindMismatchError;
+})(Error_FabricatorError || (Error_FabricatorError = {}));
+export { Error_FabricatorError as FabricatorError };