@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,236 @@
+import { FabricatorError } from "../../Error/index.js";
+import { Adaptation, Kind, Meta, Omitted } from "../../Types.js";
+import { never } from "../../Utility/Core.js";
+function terminate(body) {
+    return terminateAt(body, []);
+}
+function terminateAt(schema, path) {
+    const kind = schema[Kind];
+    switch(kind){
+        case "recursive.self":
+            throw new FabricatorError.UnterminableRecursiveError(path);
+        case "array":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? emptyArray() : schema;
+            }
+        case "record":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].key) || containsSelf(s[Meta].value) ? emptyRecord() : schema;
+            }
+        case "choice":
+            {
+                const s = schema;
+                const items = s[Meta].items;
+                const kept = items.filter(([, option])=>!containsSelf(option));
+                if (0 === kept.length) throw new FabricatorError.UnterminableRecursiveError(path);
+                return withMeta(s, {
+                    ...s[Meta],
+                    items: kept
+                });
+            }
+        case "nullable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? alwaysNull() : schema;
+            }
+        case "nullish":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? alwaysNull() : schema;
+            }
+        case "undefinable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? alwaysUndefined() : schema;
+            }
+        case "object.omittable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? alwaysOmitted(kind) : schema;
+            }
+        case "object.optional":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition) ? alwaysOmitted(kind) : schema;
+            }
+        case "object":
+            {
+                const s = schema;
+                const definition = s[Meta].definition;
+                const next = {};
+                for (const key of Object.keys(definition))next[key] = terminateAt(definition[key], [
+                    ...path,
+                    key
+                ]);
+                return withMeta(s, {
+                    ...s[Meta],
+                    definition: next
+                });
+            }
+        case "tuple":
+            {
+                const s = schema;
+                return withMeta(s, {
+                    ...s[Meta],
+                    items: s[Meta].items.map((item, i)=>terminateAt(item, [
+                            ...path,
+                            String(i)
+                        ]))
+                });
+            }
+        case "object.compute":
+            {
+                const s = schema;
+                if (containsSelf(s[Meta].source)) throw new FabricatorError.UnterminableRecursiveError([
+                    ...path,
+                    "source"
+                ]);
+                return schema;
+            }
+        case "recursive":
+        case "always":
+        case "bigint":
+        case "boolean":
+        case "date":
+        case "enum":
+        case "null":
+        case "number":
+        case "opaque":
+        case "string":
+        case "symbol":
+        case "undefined":
+            return schema;
+        default:
+            return never(kind);
+    }
+}
+function containsSelf(schema) {
+    const kind = schema[Kind];
+    switch(kind){
+        case "recursive.self":
+            return true;
+        case "recursive":
+            return false;
+        case "array":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "nullable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "nullish":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "undefinable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "object.omittable":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "object.optional":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].definition);
+            }
+        case "record":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].key) || containsSelf(s[Meta].value);
+            }
+        case "choice":
+            {
+                const s = schema;
+                return s[Meta].items.some(([, option])=>containsSelf(option));
+            }
+        case "object":
+            {
+                const s = schema;
+                const definition = s[Meta].definition;
+                return Object.keys(definition).some((key)=>containsSelf(definition[key]));
+            }
+        case "tuple":
+            {
+                const s = schema;
+                return s[Meta].items.some((item)=>containsSelf(item));
+            }
+        case "object.compute":
+            {
+                const s = schema;
+                return containsSelf(s[Meta].source);
+            }
+        case "always":
+        case "bigint":
+        case "boolean":
+        case "date":
+        case "enum":
+        case "null":
+        case "number":
+        case "opaque":
+        case "string":
+        case "symbol":
+        case "undefined":
+            return false;
+        default:
+            return never(kind);
+    }
+}
+function withMeta(schema, meta) {
+    const adaptations = schema[Adaptation];
+    return adaptations ? {
+        [Kind]: schema[Kind],
+        [Meta]: meta,
+        [Adaptation]: adaptations
+    } : {
+        [Kind]: schema[Kind],
+        [Meta]: meta
+    };
+}
+function emptyArray() {
+    return {
+        [Kind]: "opaque",
+        [Meta]: {
+            produce: ()=>[]
+        }
+    };
+}
+function emptyRecord() {
+    return {
+        [Kind]: "opaque",
+        [Meta]: {
+            produce: ()=>({})
+        }
+    };
+}
+function alwaysNull() {
+    return {
+        [Kind]: "null",
+        [Meta]: {}
+    };
+}
+function alwaysUndefined() {
+    return {
+        [Kind]: "undefined",
+        [Meta]: {}
+    };
+}
+function alwaysOmitted(kind) {
+    return {
+        [Kind]: kind,
+        [Meta]: {
+            definition: alwaysNull(),
+            produce: ()=>Omitted
+        }
+    };
+}
+export { terminate };

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

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

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

@@ -0,0 +1,7 @@
+import * as __rspack_external__self_index_js_7cfd8858 from "./self/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__self_index_js_7cfd8858 as self };

package/dist/esm/Primitive/recursive/self/Fabricator.js

@@ -0,0 +1,15 @@
+import { FabricatorError } from "../../../Error/index.js";
+import { Kind, Meta } from "../../../Types.js";
+function Fabricator(context, resolve) {
+    const { schema, trace } = context;
+    return {
+        [Kind]: "recursive.self",
+        [Meta]: schema[Meta],
+        trace,
+        fabricate: ()=>{
+            if (!resolve) throw new FabricatorError.DetachedSelfError("construction");
+            return resolve();
+        }
+    };
+}
+export { Fabricator };

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

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

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

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

package/dist/esm/Primitive/recursive/self/Types.js

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

package/dist/esm/Primitive/recursive/self/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/string/Constants.js

@@ -0,0 +1,73 @@
+const unicode = {
+    scalars: [
+        {
+            from: 0x0,
+            to: 0xd7ff
+        },
+        {
+            from: 0xe000,
+            to: 0x10ffff
+        }
+    ],
+    codespace: {
+        from: 0x0,
+        to: 0x10ffff
+    },
+    bmp: {
+        from: 0x0,
+        to: 0xffff
+    },
+    ascii: {
+        from: 0x20,
+        to: 0x7e
+    },
+    range: (from, to)=>({
+            from,
+            to
+        })
+};
+const classes = {
+    lowercase: [
+        {
+            from: 0x61,
+            to: 0x7a
+        }
+    ],
+    uppercase: [
+        {
+            from: 0x41,
+            to: 0x5a
+        }
+    ],
+    digit: [
+        {
+            from: 0x30,
+            to: 0x39
+        }
+    ],
+    symbol: [
+        {
+            from: 0x21,
+            to: 0x2f
+        },
+        {
+            from: 0x3a,
+            to: 0x40
+        },
+        {
+            from: 0x5b,
+            to: 0x60
+        },
+        {
+            from: 0x7b,
+            to: 0x7e
+        }
+    ],
+    space: [
+        {
+            from: 0x20,
+            to: 0x20
+        }
+    ]
+};
+export { classes, unicode };

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

@@ -0,0 +1,109 @@
+import { effectiveDiscrete } from "../../Bound.js";
+import { weighted } from "../../Distribution/index.js";
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Kind, Meta } from "../../Types.js";
+import { inline } from "../../Utility/Core.js";
+import { classes, unicode } from "./Constants.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]: "string",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const stream = toStreamFromTrace(algorithm, trace);
+    const whereby = meta.whereby;
+    const { min, max } = effectiveDiscrete(whereby.length.min, whereby.length.max);
+    const sources = inline(()=>{
+        const composition = whereby.composition;
+        if (void 0 === composition) return [
+            [
+                1,
+                unicode.scalars
+            ]
+        ];
+        if (Array.isArray(composition)) return composition;
+        return Object.entries(composition).map(([name, weight])=>[
+                weight,
+                classes[name]
+            ]);
+    });
+    const pick = weighted(sources.map(([weight, source])=>[
+            weight,
+            compiler(source, stream)
+        ]), stream, "T.string.whereby.composition");
+    const fill = compiler(bmpScalars, stream);
+    const fabricate = ()=>{
+        const length = min + Math.floor(stream.next() * (max - min + 1));
+        const pieces = [];
+        let remaining = length;
+        while(remaining > 0){
+            const unit = pick()();
+            if (unit.length <= remaining) {
+                pieces.push(unit);
+                remaining -= unit.length;
+            } else {
+                const at = Math.floor(stream.next() * (pieces.length + 1));
+                pieces.splice(at, 0, fill());
+                remaining -= 1;
+            }
+        }
+        return pieces.join("");
+    };
+    return {
+        [Kind]: "string",
+        [Meta]: meta,
+        trace,
+        fabricate,
+        schema: rehydrated
+    };
+}
+const toRanges = (source)=>{
+    if ("string" == typeof source) return [
+        ...source
+    ].map((char)=>{
+        const codepoint = char.codePointAt(0);
+        return {
+            from: codepoint,
+            to: codepoint
+        };
+    });
+    if (Array.isArray(source)) return source;
+    return [
+        source
+    ];
+};
+const bmpScalars = [
+    {
+        from: 0x0,
+        to: 0xd7ff
+    },
+    {
+        from: 0xe000,
+        to: 0xffff
+    }
+];
+const compiler = (source, stream)=>{
+    const pick = weighted(toRanges(source).map((range)=>[
+            range.to - range.from + 1,
+            range
+        ]), stream, "T.string.whereby");
+    return ()=>{
+        const range = pick();
+        const span = range.to - range.from + 1;
+        return String.fromCodePoint(range.from + Math.floor(stream.next() * span));
+    };
+};
+export { Fabricator };

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

@@ -0,0 +1,25 @@
+import { toLengthRange } from "../../Bound.js";
+import { Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+const Registry = {
+    [Kind]: "string",
+    as: (produce, hints)=>Schema({
+            [Kind]: "string",
+            [Meta]: {
+                produce,
+                hints
+            }
+        }),
+    whereby: (whereby)=>Schema({
+            [Kind]: "string",
+            [Meta]: {
+                whereby: {
+                    length: toLengthRange(whereby.length, "T.string.whereby"),
+                    ...void 0 === whereby.composition ? {} : {
+                        composition: whereby.composition
+                    }
+                }
+            }
+        })
+};
+export default Registry;

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

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

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

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

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

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

package/dist/esm/Primitive/symbol/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) {
+    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]: "symbol",
+            [Meta]: meta,
+            trace,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    return {
+        [Kind]: "symbol",
+        [Meta]: meta,
+        trace,
+        fabricate: ()=>Symbol(meta.key),
+        schema: rehydrated
+    };
+}
+export { Fabricator };

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

@@ -0,0 +1,17 @@
+import { Adaptation, Kind, Meta, Produces } from "../../Types.js";
+import { Schema } from "./Schema.js";
+const Registry = {
+    ...Schema({
+        [Kind]: "symbol",
+        [Meta]: {},
+        [Produces]: void 0,
+        [Adaptation]: void 0
+    }),
+    keyed: (key)=>Schema({
+            [Kind]: "symbol",
+            [Meta]: {
+                key
+            }
+        })
+};
+export default Registry;

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { toStreamFromTrace } from "../../Random/index.js";
+import { Children, Kind, Meta } from "../../Types.js";
+import { Schema } from "./Schema.js";
+function Fabricator(context, elements) {
+    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]: "tuple",
+            [Meta]: meta,
+            trace,
+            [Children]: elements,
+            fabricate: ()=>produce({
+                    random: stream,
+                    clock: trace.clock
+                }),
+            schema: rehydrated
+        };
+    }
+    const fabricate = ()=>elements.map((element)=>element.fabricate());
+    return {
+        [Kind]: "tuple",
+        [Meta]: meta,
+        trace,
+        [Children]: elements,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

package/dist/esm/Primitive/tuple/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(items) {
+    const normalized = items.map((item)=>toSchema(item));
+    return Schema({
+        [Kind]: "tuple",
+        [Meta]: {
+            items: normalized
+        }
+    });
+}
+export default Registry;

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

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

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

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