@ghostry/fabricator 0.0.1

package/dist/esm/Primitive/tuple/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/undefinable/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]: "undefinable",
+            [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.undefined) ? _ref : 1,
+            "undefined"
+        ],
+        [
+            null != (_ref1 = null == (_meta_weights1 = meta.weights) ? void 0 : _meta_weights1.value) ? _ref1 : 1,
+            "value"
+        ]
+    ], stream, "T.undefinable");
+    const fabricate = ()=>{
+        const picked = pick();
+        switch(picked){
+            case "value":
+                return source.fabricate();
+            case "undefined":
+                return;
+            default:
+                return never(picked);
+        }
+    };
+    return {
+        [Kind]: "undefinable",
+        [Meta]: meta,
+        trace,
+        [Children]: source,
+        fabricate,
+        schema: rehydrated
+    };
+}
+export { Fabricator };

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { Kind, Meta, Produces } from "../../Types.js";
+import { Schema } from "./Schema.js";
+const Registry = Schema({
+    [Kind]: "undefined",
+    [Meta]: {},
+    [Produces]: void 0
+});
+export default Registry;

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

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

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

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

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

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

package/dist/esm/Random/CallSite.js

@@ -0,0 +1,56 @@
+const OWN_ROOT = normalizeLocation(new URL("..", import.meta.url).href);
+function stripPosition(text) {
+    return text.replace(/:\d+:\d+/g, "");
+}
+function extractLocation(frameLine) {
+    const trimmed = frameLine.trim().replace(/^at\s+/, "");
+    const parenthesized = trimmed.match(/\(([^()]*)\)$/);
+    return parenthesized ? parenthesized[1] : trimmed;
+}
+function decode(text) {
+    try {
+        return decodeURIComponent(text);
+    } catch  {
+        return text;
+    }
+}
+function normalizeLocation(location) {
+    const isUrl = location.startsWith("file://");
+    const path = isUrl ? decode(location.slice(7)) : location;
+    return path.replace(/\\/g, "/").replace(/^\/?([A-Za-z]):\//, (_, letter)=>`/${letter.toUpperCase()}:/`);
+}
+function directoryOf(location) {
+    const cut = location.lastIndexOf("/");
+    return -1 === cut ? location : location.slice(0, cut + 1);
+}
+function relativize(root, file) {
+    if (!file.startsWith("/")) return file;
+    const from = root.split("/").filter(Boolean);
+    const to = file.split("/").filter(Boolean);
+    let shared = 0;
+    while(shared < from.length && shared < to.length && from[shared] === to[shared])shared++;
+    const traversals = Array(from.length - shared).fill("..");
+    return [
+        ...traversals,
+        ...to.slice(shared)
+    ].join("/");
+}
+function isOwnFrame(location) {
+    return location.startsWith(OWN_ROOT);
+}
+function firstExternalFrame(stack) {
+    var _ref, _locations_find;
+    const locations = stack.split("\n").filter((line)=>line.trim().startsWith("at ")).map(extractLocation).map(normalizeLocation);
+    return null != (_ref = null != (_locations_find = locations.find((location)=>!isOwnFrame(location))) ? _locations_find : locations[locations.length - 1]) ? _ref : stack;
+}
+function resolveCallerFile() {
+    var _stack;
+    if ("function" == typeof Error.captureStackTrace) {
+        var _captured_stack;
+        const captured = {};
+        Error.captureStackTrace(captured);
+        return stripPosition(firstExternalFrame(null != (_captured_stack = captured.stack) ? _captured_stack : ""));
+    }
+    return stripPosition(null != (_stack = new Error().stack) ? _stack : "");
+}
+export { directoryOf, normalizeLocation, relativize, resolveCallerFile };

package/dist/esm/Random/Generator/sfc32.js

@@ -0,0 +1,16 @@
+function sfc32(a, b, c, d) {
+    return ()=>{
+        a |= 0;
+        b |= 0;
+        c |= 0;
+        d |= 0;
+        const t = (a + b | 0) + d | 0;
+        d = d + 1 | 0;
+        a = b ^ b >>> 9;
+        b = c + (c << 3) | 0;
+        c = c << 21 | c >>> 11;
+        c = c + t | 0;
+        return (t >>> 0) / 4294967296;
+    };
+}
+export { sfc32 };

package/dist/esm/Random/Types.js

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

package/dist/esm/Random/index.js

@@ -0,0 +1,151 @@
+import { FabricatorError } from "../Error/index.js";
+import { Layer, MAX_TIME } from "../Types.js";
+import { inline } from "../Utility/Core.js";
+import { cyrb128 } from "../Utility/Digest.js";
+import { directoryOf, normalizeLocation, relativize, resolveCallerFile } from "./CallSite.js";
+import { sfc32 } from "./Generator/sfc32.js";
+function defaultAlgorithm(seed) {
+    return sfc32(...cyrb128(seed));
+}
+function randomSeed() {
+    return (0x100000000 * Math.random() >>> 0).toString(10);
+}
+function deriveClock(algorithm, seed) {
+    const stream = toStream(algorithm, JSON.stringify([
+        seed,
+        "clock"
+    ]));
+    return Math.trunc((2 * stream.next() - 1) * MAX_TIME);
+}
+function envSeed() {
+    var _ref, _ref1;
+    const env = "object" == typeof process ? process.env : void 0;
+    return null != (_ref = null != (_ref1 = null == env ? void 0 : env["FABRICATOR_SEED"]) ? _ref1 : null == env ? void 0 : env["SEED"]) ? _ref : null == env ? void 0 : env["RANDOM_SEED"];
+}
+function encode(trace) {
+    return JSON.stringify([
+        trace.seed,
+        trace.clock,
+        trace.root,
+        trace.file,
+        trace.path,
+        trace.kind,
+        trace.ordinal
+    ]);
+}
+function normalizeSeed(seed) {
+    if (void 0 === seed) {
+        const fromEnv = envSeed();
+        return void 0 === fromEnv ? [] : [
+            fromEnv
+        ];
+    }
+    return "string" == typeof seed ? [
+        seed
+    ] : [
+        ...seed
+    ];
+}
+function Random_layer(seed) {
+    return {
+        [Layer]: seed
+    };
+}
+function isLayered(value) {
+    return "object" == typeof value && null !== value && Layer in value;
+}
+function resolveAttribution(attribution) {
+    const policy = null != attribution ? attribution : {
+        kind: "call site"
+    };
+    switch(policy.kind){
+        case "none":
+            return policy;
+        case "rooted":
+            {
+                const root = normalizeLocation(policy.root);
+                if (!root.startsWith("/")) throw new FabricatorError.InvalidAttributionRootError(policy.root);
+                return toRooted(root);
+            }
+        case "call site":
+            {
+                const root = directoryOf(resolveCallerFile());
+                return toRooted(root);
+            }
+    }
+}
+function toRooted(root) {
+    return {
+        kind: "rooted",
+        root: root.endsWith("/") ? root : `${root}/`
+    };
+}
+function toStream(algorithm, seed) {
+    const generator = algorithm(seed);
+    let iterations = 0;
+    return {
+        seed,
+        get iterations () {
+            return iterations;
+        },
+        next: ()=>{
+            iterations++;
+            return generator();
+        }
+    };
+}
+function toStreamFromTrace(algorithm, trace) {
+    return toStream(algorithm, encode(trace));
+}
+function toRandomSource(options) {
+    var _options_algorithm;
+    let seed = normalizeSeed(options.seed);
+    let algorithm = null != (_options_algorithm = options.algorithm) ? _options_algorithm : defaultAlgorithm;
+    let attribution = resolveAttribution(options.attribution);
+    const clock = options.clock;
+    let constructionOrdinals = new Map();
+    function nextConstructionOrdinal(file) {
+        var _constructionOrdinals_get;
+        const ordinal = null != (_constructionOrdinals_get = constructionOrdinals.get(file)) ? _constructionOrdinals_get : 0;
+        constructionOrdinals.set(file, ordinal + 1);
+        return ordinal;
+    }
+    function toRoot(kind, pins = {}) {
+        var _pins_root, _pins_clock;
+        const replaying = void 0 !== pins.root;
+        const root = null != (_pins_root = pins.root) ? _pins_root : kind;
+        const file = replaying || void 0 !== pins.file ? pins.file : resolveRootFile(kind);
+        const ordinal = inline(()=>{
+            if (replaying || void 0 !== pins.ordinal) return pins.ordinal;
+            if ("unattributed" === root) return;
+            return nextConstructionOrdinal(file);
+        });
+        return {
+            seed,
+            clock: null != (_pins_clock = pins.clock) ? _pins_clock : clock,
+            root,
+            file,
+            ordinal
+        };
+    }
+    function resolveRootFile(kind) {
+        if ("attributed" !== kind) return;
+        if ("none" === attribution.kind) return;
+        return relativize(attribution.root, resolveCallerFile());
+    }
+    function fork(childSeed) {
+        return toRandomSource({
+            seed: childSeed,
+            algorithm,
+            attribution,
+            clock
+        });
+    }
+    return {
+        toRoot,
+        algorithm,
+        seed,
+        fork
+    };
+}
+export { Random_layer as layer, defaultAlgorithm, deriveClock, encode, isLayered, normalizeSeed, randomSeed, resolveAttribution, toRandomSource, toStream, toStreamFromTrace };

package/dist/esm/Schema/Core.js

@@ -0,0 +1,68 @@
+import { Adaptation, Kind, Meta } from "../Types.js";
+import { isPlainObject, never } from "../Utility/Core.js";
+function toSchema(value) {
+    const adaptations = value[Adaptation];
+    return adaptations ? {
+        [Kind]: value[Kind],
+        [Meta]: value[Meta],
+        [Adaptation]: adaptations
+    } : {
+        [Kind]: value[Kind],
+        [Meta]: value[Meta]
+    };
+}
+function violatesKind(kind, value) {
+    switch(kind){
+        case "object":
+            return !isPlainObject(value);
+        case "array":
+            return !Array.isArray(value);
+        case "record":
+            return !isPlainObject(value);
+        case "tuple":
+            return !Array.isArray(value);
+        case "string":
+            return "string" != typeof value;
+        case "number":
+            return "number" != typeof value;
+        case "boolean":
+            return "boolean" != typeof value;
+        case "bigint":
+            return "bigint" != typeof value;
+        case "symbol":
+            return "symbol" != typeof value;
+        case "date":
+            return !(value instanceof Date);
+        case "undefined":
+            return void 0 !== value;
+        case "null":
+            return null !== value;
+        case "nullable":
+            return false;
+        case "nullish":
+            return false;
+        case "always":
+            return false;
+        case "opaque":
+            return false;
+        case "recursive":
+            return false;
+        case "recursive.self":
+            return false;
+        case "enum":
+            return false;
+        case "choice":
+            return false;
+        case "object.compute":
+            return false;
+        case "object.omittable":
+            return false;
+        case "object.optional":
+            return false;
+        case "undefinable":
+            return false;
+        default:
+            return never(kind);
+    }
+}
+export { toSchema, violatesKind };

package/dist/esm/Schema/Registry.js

@@ -0,0 +1,17 @@
+import * as __rspack_external__Primitive_index_js_8ad84a20 from "../Primitive/index.js";
+import { deepMerge } from "../Utility/DeepMerge.js";
+const Registry = (registrations)=>{
+    const extend = (types)=>Registry(deepMerge(registrations, types({
+            T: registrations,
+            augment: deepMerge
+        })));
+    return {
+        ...registrations,
+        extend
+    };
+};
+const registry = Registry({}).extend(()=>{
+    const { Primitive: _, ...builders } = __rspack_external__Primitive_index_js_8ad84a20;
+    return builders;
+});
+export { registry };

package/dist/esm/Schema/Types.js

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

package/dist/esm/Types.js

@@ -0,0 +1,11 @@
+const Kind = Symbol.for("fabricator:kind");
+const Meta = Symbol.for("fabricator:meta");
+const Produces = Symbol.for("fabricator:produces");
+const Replace = Symbol.for("fabricator:replace");
+const Fixed = Symbol.for("fabricator:fixed");
+const Layer = Symbol.for("fabricator:layer");
+const Children = Symbol.for("fabricator:children");
+const Adaptation = Symbol.for("fabricator:adaptation");
+const Omitted = Symbol.for("fabricator:omitted");
+const MAX_TIME = 8640000000000000;
+export { Adaptation, Children, Fixed, Kind, Layer, MAX_TIME, Meta, Omitted, Produces, Replace };

package/dist/esm/Utility/Core.js

@@ -0,0 +1,36 @@
+import { Replace } from "../Types.js";
+function inline(fn) {
+    return fn();
+}
+function never(_) {}
+function isArray(candidate) {
+    return Array.isArray(candidate);
+}
+const POLLUTION_KEYS = Object.freeze(new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+]));
+function isPollutionKey(key) {
+    return POLLUTION_KEYS.has(key);
+}
+function isPlainObject(value) {
+    if ("object" != typeof value) return false;
+    if (null === value) return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || null === proto;
+}
+function mergeableKeys(source) {
+    return Reflect.ownKeys(source).filter((key)=>{
+        if (key === Replace) return false;
+        if ("symbol" == typeof key) return true;
+        return !isPollutionKey(key);
+    });
+}
+function replace(value) {
+    return {
+        ...value,
+        [Replace]: true
+    };
+}
+export { inline, isArray, isPlainObject, isPollutionKey, mergeableKeys, never, replace };

package/dist/esm/Utility/DeepMerge.js

@@ -0,0 +1,18 @@
+import { Replace } from "../Types.js";
+import { isPlainObject, mergeableKeys } from "./Core.js";
+function deepMerge(a, b) {
+    const result = {};
+    if (Replace in b && true === b[Replace]) {
+        for (const key of mergeableKeys(b))result[key] = b[key];
+        return result;
+    }
+    for (const key of mergeableKeys(a))result[key] = a[key];
+    for (const key of mergeableKeys(b)){
+        const bValue = b[key];
+        const aValue = result[key];
+        if (isPlainObject(aValue) && isPlainObject(bValue)) result[key] = deepMerge(aValue, bValue);
+        else result[key] = bValue;
+    }
+    return result;
+}
+export { deepMerge };

package/dist/esm/Utility/Digest.js

@@ -0,0 +1,28 @@
+function cyrb128(str) {
+    let h1 = 1779033703;
+    let h2 = 3144134277;
+    let h3 = 1013904242;
+    let h4 = 2773480762;
+    for(let i = 0; i < str.length; i++){
+        const k = str.charCodeAt(i);
+        h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+        h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+        h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+        h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
+    }
+    h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
+    h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
+    h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
+    h4 = Math.imul(h2 ^ h4 >>> 19, 2716044179);
+    h1 ^= h2 ^ h3 ^ h4;
+    h2 ^= h1;
+    h3 ^= h1;
+    h4 ^= h1;
+    return [
+        h1 >>> 0,
+        h2 >>> 0,
+        h3 >>> 0,
+        h4 >>> 0
+    ];
+}
+export { cyrb128 };

package/dist/esm/Utility/ShallowMerge.js

@@ -0,0 +1,13 @@
+import { Replace } from "../Types.js";
+import { mergeableKeys } from "./Core.js";
+function shallowMerge(a, b) {
+    const result = {};
+    if (Replace in b && true === b[Replace]) {
+        for (const key of mergeableKeys(b))result[key] = b[key];
+        return result;
+    }
+    for (const key of mergeableKeys(a))result[key] = a[key];
+    for (const key of mergeableKeys(b))result[key] = b[key];
+    return result;
+}
+export { shallowMerge };

package/dist/esm/Utility/Types.js

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

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import { instantiate, overlay, toStack } from "./Instance/Core.js";
+function initialize(config) {
+    return instantiate(overlay({}, null != config ? config : {}), toStack()).instance;
+}
+export { Adaptation, Omitted } from "./Types.js";
+export { layer } from "./Random/index.js";
+export { FabricatorError } from "./Error/index.js";
+export { drive } from "./Adapter/Core.js";
+export { registry } from "./Schema/Registry.js";
+export { effectiveDiscrete, toBound } from "./Bound.js";
+export { initialize };

package/dist/esm/internal.js

@@ -0,0 +1,5 @@
+export { Children, Kind, Meta, Produces } from "./Types.js";
+export { isPlainObject } from "./Utility/Core.js";
+export { plan, resolve } from "./Enumeration/Plan.js";
+export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace } from "./Random/index.js";
+export { directoryOf, normalizeLocation, relativize } from "./Random/CallSite.js";