@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/type-emitter.js

@@ -1,729 +0,0 @@
-const SAFE_KEY_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const LAZY_ALIAS_CAP = 64;
-/** A property key in a type literal: bare when it is an identifier, a string literal otherwise. */
-export function quoteKey(key) {
-    return SAFE_KEY_RE.test(key) ? key : JSON.stringify(key);
-}
-/** A TypeScript literal type for a runtime value; anything without one widens to its type. */
-export function literalType(value) {
-    if (value === null)
-        return "null";
-    if (value === undefined)
-        return "undefined";
-    if (typeof value === "string")
-        return JSON.stringify(value);
-    if (typeof value === "boolean")
-        return String(value);
-    if (typeof value === "bigint")
-        return `${value}n`;
-    if (typeof value === "number")
-        return Number.isFinite(value) ? String(value) : "number";
-    if (typeof value === "symbol")
-        return "symbol";
-    return "unknown";
-}
-/**
- * Does `type` contain `token` outside every bracket and string? `A | B` does; `{ a: A | B }`
- * and `Array<A | B>` do not. Used to parenthesize only where precedence needs it.
- */
-function hasTopLevel(type, token) {
-    let depth = 0;
-    let quote = null;
-    for (let i = 0; i < type.length; i++) {
-        const c = type[i];
-        if (quote !== null) {
-            if (c === "\\")
-                i++;
-            else if (c === quote)
-                quote = null;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === "`")
-            quote = c;
-        else if (c === "(" || c === "{" || c === "[" || c === "<")
-            depth++;
-        else if (c === ")" || c === "}" || c === "]" || (c === ">" && type[i - 1] !== "="))
-            depth--;
-        else if (depth === 0 && type.startsWith(token, i))
-            return true;
-    }
-    return false;
-}
-/** Wrap element type in parens when union, intersection or function binds looser than `[]` */
-export function arrayOf(el) {
-    return hasTopLevel(el, "|") || hasTopLevel(el, "&") || hasTopLevel(el, "=>") ? `(${el})[]` : `${el}[]`;
-}
-export function unionOf(parts) {
-    const unique = [...new Set(parts)];
-    if (unique.length === 0)
-        return "never";
-    return unique.map((p) => (hasTopLevel(p, "=>") ? `(${p})` : p)).join(" | ");
-}
-/** `(A | B) & C`, never `A | B & C` — `&` binds tighter than `|`. */
-export function intersectionOf(parts) {
-    return parts.map((p) => (hasTopLevel(p, "|") || hasTopLevel(p, "=>") ? `(${p})` : p)).join(" & ");
-}
-export function createTypeEmitState() {
-    return {
-        aliases: new Map(),
-        inProgress: new Map(),
-        lazyNames: new WeakMap(),
-        nextId: 0,
-        reserved: new Set(),
-    };
-}
-/**
- * Emit a TypeScript type string from a Standard Schema compatible schema.
- * Supports Zod (+ mini), Valibot, ArkType, Yup, and Effect.
- * Unknown vendors return "unknown".
- *
- * Pass a shared `TypeEmitState` from `generateTypes` so recursive lazy
- * aliases are hoisted once and reused across routes.
- */
-export function emitSchemaType(schema, state) {
-    const vendor = schema["~standard"].vendor;
-    if (vendor === "zod")
-        return emitZod(schema, state ?? createTypeEmitState());
-    if (vendor === "valibot")
-        return emitValibot(schema, 0);
-    if (vendor === "arktype")
-        return emitArkType(schema);
-    if (vendor === "yup")
-        return emitYup(schema);
-    if (vendor === "effect")
-        return emitEffect(schema);
-    return "unknown";
-}
-/* ---- Zod emitter (handles both full zod and zod/mini) ---- */
-/** Unwrap nullable/default/catch wrappers to detect if optional is nested inside */
-function zodIsOptional(def) {
-    const t = def.typeName ?? def.type;
-    if (t === "ZodOptional" || t === "optional")
-        return true;
-    if (t === "ZodNullable" ||
-        t === "nullable" ||
-        t === "ZodDefault" ||
-        t === "default" ||
-        t === "ZodCatch" ||
-        t === "catch" ||
-        t === "ZodReadonly" ||
-        t === "readonly") {
-        const inner = def.innerType;
-        if (inner)
-            return zodIsOptional(zodDef(inner));
-    }
-    return false;
-}
-function zodDef(schema) {
-    const s = schema;
-    return (s._def ?? s.def);
-}
-/** `.meta({ tsType })` is a vendor-agnostic override; emit it verbatim. */
-function zodTsTypeMeta(schema) {
-    const s = schema;
-    if (typeof s.meta !== "function")
-        return undefined;
-    let bag;
-    try {
-        bag = s.meta();
-    }
-    catch {
-        return undefined;
-    }
-    if (!bag || typeof bag !== "object")
-        return undefined;
-    const tsType = bag.tsType;
-    return typeof tsType === "string" && tsType.length > 0 ? tsType : undefined;
-}
-function resolveLazyInner(def, schema) {
-    if (typeof def.getter === "function") {
-        try {
-            return def.getter();
-        }
-        catch {
-            return undefined;
-        }
-    }
-    const s = schema;
-    if (typeof s.unwrap === "function") {
-        try {
-            return s.unwrap();
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (s._zod && "innerType" in s._zod)
-        return s._zod.innerType;
-    return undefined;
-}
-function typeRefersTo(body, name) {
-    return new RegExp(`(?:^|[^A-Za-z0-9_$])${name}(?:[^A-Za-z0-9_$]|$)`).test(body);
-}
-function emitZodRecord(keyType, valueType, state) {
-    /* Partial<Record> adds `| undefined` and is not assignable to a recursive `Record<string, T>`. */
-    if (typeRefersToReserved(valueType, state)) {
-        return `Record<${keyType}, ${valueType}>`;
-    }
-    return `Partial<Record<${keyType}, ${valueType}>>`;
-}
-function typeRefersToReserved(typeStr, state) {
-    for (const name of state.reserved) {
-        if (typeRefersTo(typeStr, name))
-            return true;
-    }
-    return false;
-}
-/** Values of a TS enum object, without the reverse mappings numeric enums carry (`{ A: 0, "0": "A" }`). */
-function enumValues(entries) {
-    return Object.keys(entries)
-        .filter((k) => typeof entries[entries[k]] !== "number")
-        .map((k) => entries[k]);
-}
-/**
- * Recursion guard for schemas that refer to themselves without `z.lazy` (Zod 4 getters). The
- * first visit emits the body; a visit while the body is still being emitted names the schema,
- * and the finished body becomes that alias.
- */
-function emitZod(schema, state) {
-    if (schema === null || typeof schema !== "object")
-        return emitZodNode(schema, state);
-    /* a z.lazy names itself before emitting its body */
-    const known = state.lazyNames.get(schema);
-    if (known !== undefined)
-        return known;
-    const active = state.inProgress.get(schema);
-    if (active !== undefined) {
-        if (active.name === null) {
-            if (state.nextId >= LAZY_ALIAS_CAP)
-                return "unknown";
-            active.name = `_Lazy${state.nextId++}`;
-            state.reserved.add(active.name);
-        }
-        return active.name;
-    }
-    const entry = { name: null };
-    state.inProgress.set(schema, entry);
-    try {
-        const body = emitZodNode(schema, state);
-        if (entry.name === null)
-            return body;
-        state.aliases.set(entry.name, body);
-        state.lazyNames.set(schema, entry.name);
-        return entry.name;
-    }
-    finally {
-        state.inProgress.delete(schema);
-    }
-}
-function emitZodNode(schema, state) {
-    const stamped = zodTsTypeMeta(schema);
-    if (stamped)
-        return stamped;
-    const def = zodDef(schema);
-    if (!def)
-        return "unknown";
-    const typeName = (def.typeName ?? def.type);
-    switch (typeName) {
-        case "ZodString":
-        case "string":
-        case "template_literal":
-            return "string";
-        case "ZodNumber":
-        case "number":
-        case "nan":
-            return "number";
-        case "ZodBoolean":
-        case "boolean":
-        case "success":
-            return "boolean";
-        case "ZodBigInt":
-        case "bigint":
-            return "bigint";
-        case "ZodSymbol":
-        case "symbol":
-            return "symbol";
-        case "ZodDate":
-        case "date":
-            return "Date";
-        case "file":
-            return "File";
-        case "ZodUndefined":
-        case "undefined":
-            return "undefined";
-        case "ZodNull":
-        case "null":
-            return "null";
-        case "ZodVoid":
-        case "void":
-            return "void";
-        case "ZodAny":
-        case "ZodUnknown":
-        case "any":
-        case "unknown":
-        case "custom":
-            return "unknown";
-        case "ZodNever":
-        case "never":
-            return "never";
-        case "ZodLiteral":
-        case "literal": {
-            /* v4: values array, v3: single value */
-            const values = Array.isArray(def.values) ? def.values : [def.value];
-            return unionOf(values.map(literalType));
-        }
-        case "ZodEnum":
-        case "enum": {
-            /* v4: entries record, v3: values array */
-            const vals = (def.values ?? def.entries);
-            const list = Array.isArray(vals) ? vals : enumValues(vals);
-            return unionOf(list.map(literalType));
-        }
-        case "ZodObject":
-        case "object": {
-            const rawShape = def.shape;
-            const shape = typeof rawShape === "function" ? rawShape() : rawShape;
-            const keys = Object.keys(shape);
-            if (keys.length === 0)
-                return "{}";
-            return `{ ${keys
-                .map((k) => {
-                const propDef = zodDef(shape[k]);
-                const isOpt = propDef && zodIsOptional(propDef);
-                return `${quoteKey(k)}${isOpt ? "?" : ""}: ${emitZod(shape[k], state)}`;
-            })
-                .join("; ")} }`;
-        }
-        case "ZodArray":
-            /* v4: _def.type is the element schema */
-            return arrayOf(emitZod((def.type ?? def.element), state));
-        case "array":
-            return arrayOf(emitZod(def.element, state));
-        case "ZodSet":
-        case "set":
-            return `Set<${emitZod(def.valueType, state)}>`;
-        case "ZodMap":
-        case "map":
-            return `Map<${emitZod(def.keyType, state)}, ${emitZod(def.valueType, state)}>`;
-        case "ZodPromise":
-        case "promise":
-            return `Promise<${emitZod(def.innerType, state)}>`;
-        case "ZodFunction":
-        case "function":
-            return "(...args: never[]) => unknown";
-        case "ZodOptional":
-        case "optional":
-            return unionOf([emitZod(def.innerType, state), "undefined"]);
-        case "nonoptional":
-            return `Exclude<${emitZod(def.innerType, state)}, undefined>`;
-        case "ZodNullable":
-        case "nullable":
-            return unionOf([emitZod(def.innerType, state), "null"]);
-        case "ZodUnion":
-        case "ZodDiscriminatedUnion":
-        case "union":
-            return unionOf(def.options.map((o) => emitZod(o, state)));
-        case "ZodIntersection":
-        case "intersection":
-            return intersectionOf([emitZod(def.left, state), emitZod(def.right, state)]);
-        case "ZodRecord":
-        case "record":
-            return emitZodRecord(emitZod(def.keyType, state), emitZod(def.valueType, state), state);
-        case "ZodTuple":
-        case "tuple": {
-            const items = def.items.map((i) => emitZod(i, state));
-            if (def.rest)
-                items.push(`...${arrayOf(emitZod(def.rest, state))}`);
-            return `[${items.join(", ")}]`;
-        }
-        case "ZodDefault":
-        case "ZodCatch":
-        case "default":
-        case "prefault":
-        case "catch":
-            return emitZod(def.innerType, state);
-        case "ZodReadonly":
-        case "readonly":
-            return `Readonly<${emitZod(def.innerType, state)}>`;
-        case "ZodPipeline":
-        case "pipe":
-            return emitZod(def.out, state);
-        case "ZodBranded":
-            return emitZod(def.type, state);
-        case "ZodLazy":
-        case "lazy":
-            return emitZodLazy(schema, def, state);
-        default:
-            /* a transform's output is whatever the function returns — the schema cannot say */
-            return "unknown";
-    }
-}
-function emitZodLazy(schema, def, state) {
-    if (schema && typeof schema === "object") {
-        const existing = state.lazyNames.get(schema);
-        if (existing)
-            return existing;
-    }
-    const inner = resolveLazyInner(def, schema);
-    if (inner === undefined || inner === schema)
-        return "unknown";
-    if (!schema || typeof schema !== "object") {
-        return emitZod(inner, state);
-    }
-    if (state.nextId >= LAZY_ALIAS_CAP)
-        return "unknown";
-    const name = `_Lazy${state.nextId++}`;
-    state.lazyNames.set(schema, name);
-    state.reserved.add(name);
-    const body = emitZod(inner, state);
-    if (!typeRefersTo(body, name)) {
-        state.lazyNames.delete(schema);
-        state.reserved.delete(name);
-        return body;
-    }
-    state.aliases.set(name, body);
-    return name;
-}
-/* ---- Valibot emitter ---- */
-const VALIBOT_OPTIONAL = new Set(["exact_optional", "nullish", "optional", "undefinedable"]);
-/** Lazy schemas can recurse without end; past this depth a node is `unknown`. */
-const VALIBOT_MAX_DEPTH = 32;
-function emitValibot(schema, depth) {
-    if (depth > VALIBOT_MAX_DEPTH)
-        return "unknown";
-    const s = schema;
-    const type = s.type;
-    if (!type)
-        return "unknown";
-    const walk = (child) => emitValibot(child, depth + 1);
-    switch (type) {
-        case "string":
-            return "string";
-        case "number":
-        case "nan":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "bigint":
-            return "bigint";
-        case "symbol":
-            return "symbol";
-        case "date":
-            return "Date";
-        case "file":
-            return "File";
-        case "blob":
-            return "Blob";
-        case "undefined":
-            return "undefined";
-        case "null":
-            return "null";
-        case "void":
-            return "void";
-        case "any":
-        case "unknown":
-            return "unknown";
-        case "never":
-            return "never";
-        case "literal":
-            return literalType(s.literal);
-        case "enum":
-            return unionOf(enumValues(s.enum).map(literalType));
-        case "picklist":
-            return unionOf(s.options.map(literalType));
-        case "object":
-        case "strict_object":
-        case "loose_object":
-        case "object_with_rest": {
-            const entries = s.entries;
-            const keys = Object.keys(entries);
-            const fields = keys.map((k) => {
-                const propType = entries[k].type;
-                const isOpt = propType !== undefined && VALIBOT_OPTIONAL.has(propType);
-                return `${quoteKey(k)}${isOpt ? "?" : ""}: ${walk(entries[k])}`;
-            });
-            if (type === "loose_object")
-                fields.push("[key: string]: unknown");
-            if (type === "object_with_rest")
-                fields.push(`[key: string]: ${unionOf([walk(s.rest), "unknown"])}`);
-            if (fields.length === 0)
-                return "{}";
-            return `{ ${fields.join("; ")} }`;
-        }
-        case "array":
-            return arrayOf(walk(s.item));
-        case "set":
-            return `Set<${walk(s.value)}>`;
-        case "map":
-            return `Map<${walk(s.key)}, ${walk(s.value)}>`;
-        case "optional":
-        case "exact_optional":
-        case "undefinedable":
-            return unionOf([walk(s.wrapped), "undefined"]);
-        case "nullable":
-            return unionOf([walk(s.wrapped), "null"]);
-        case "nullish":
-            return unionOf([walk(s.wrapped), "null", "undefined"]);
-        case "non_optional":
-            return `Exclude<${walk(s.wrapped)}, undefined>`;
-        case "non_nullable":
-            return `Exclude<${walk(s.wrapped)}, null>`;
-        case "non_nullish":
-            return `NonNullable<${walk(s.wrapped)}>`;
-        case "union":
-        case "variant":
-            return unionOf(s.options.map(walk));
-        case "intersect":
-            return intersectionOf(s.options.map(walk));
-        case "record":
-            return `Record<${walk(s.key)}, ${walk(s.value)}>`;
-        case "tuple":
-        case "strict_tuple":
-        case "loose_tuple":
-        case "tuple_with_rest": {
-            const items = s.items.map(walk);
-            if (type === "tuple_with_rest")
-                items.push(`...${arrayOf(walk(s.rest))}`);
-            if (type === "loose_tuple")
-                items.push("...unknown[]");
-            return `[${items.join(", ")}]`;
-        }
-        case "lazy": {
-            const getter = s.getter;
-            return typeof getter === "function" ? walk(getter(undefined)) : "unknown";
-        }
-        default:
-            return "unknown";
-    }
-}
-/* ---- ArkType emitter ---- */
-function emitArkType(schema) {
-    const s = schema;
-    const json = s.json;
-    if (json === undefined || json === null)
-        return "unknown";
-    return emitArkJson(json);
-}
-function isBooleanUnion(node) {
-    if (node.length !== 2)
-        return false;
-    const units = node.map((n) => {
-        if (typeof n === "object" && n !== null && "unit" in n) {
-            return n.unit;
-        }
-        return undefined;
-    });
-    return (units[0] === false && units[1] === true) || (units[0] === true && units[1] === false);
-}
-function emitArkJson(node) {
-    if (typeof node === "string")
-        return mapArkDomain(node);
-    if (Array.isArray(node)) {
-        if (node.length === 0)
-            return "never";
-        if (isBooleanUnion(node))
-            return "boolean";
-        return unionOf(node.map((n) => emitArkJson(n)));
-    }
-    const obj = node;
-    if ("unit" in obj) {
-        const val = obj.unit;
-        /* arktype serializes undefined as the string "undefined" in JSON */
-        if (val === "undefined")
-            return "undefined";
-        return literalType(val);
-    }
-    if ("sequence" in obj) {
-        return arrayOf(emitArkJson(obj.sequence));
-    }
-    if ("proto" in obj) {
-        return mapArkProto(obj.proto);
-    }
-    if ("domain" in obj) {
-        const domain = obj.domain;
-        if (domain === "object") {
-            const required = obj.required ?? [];
-            const optional = obj.optional ?? [];
-            if (required.length === 0 && optional.length === 0)
-                return "{}";
-            const parts = [];
-            for (const entry of required) {
-                parts.push(`${quoteKey(String(entry.key))}: ${emitArkJson(entry.value)}`);
-            }
-            for (const entry of optional) {
-                parts.push(`${quoteKey(String(entry.key))}?: ${emitArkJson(entry.value)}`);
-            }
-            return `{ ${parts.join("; ")} }`;
-        }
-        return mapArkDomain(domain);
-    }
-    return "unknown";
-}
-function mapArkDomain(domain) {
-    switch (domain) {
-        case "string":
-            return "string";
-        case "number":
-        case "integer":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "bigint":
-            return "bigint";
-        case "symbol":
-            return "symbol";
-        case "undefined":
-            return "undefined";
-        case "null":
-            return "null";
-        case "object":
-            return "object";
-        default:
-            return "unknown";
-    }
-}
-function mapArkProto(proto) {
-    switch (proto) {
-        case "Date":
-            return "Date";
-        case "Array":
-            return "unknown[]";
-        case "RegExp":
-            return "RegExp";
-        case "Map":
-            return "Map<unknown, unknown>";
-        case "Set":
-            return "Set<unknown>";
-        default:
-            return "unknown";
-    }
-}
-function emitYup(schema) {
-    const s = schema;
-    if (typeof s.describe !== "function")
-        return "unknown";
-    const desc = s.describe();
-    return emitYupDesc(desc);
-}
-function emitYupDesc(desc) {
-    const base = emitYupBase(desc);
-    return desc.nullable ? unionOf([base, "null"]) : base;
-}
-function emitYupBase(desc) {
-    switch (desc.type) {
-        case "string":
-            return "string";
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "date":
-            return "Date";
-        case "object": {
-            if (!desc.fields)
-                return "{}";
-            const keys = Object.keys(desc.fields);
-            if (keys.length === 0)
-                return "{}";
-            const parts = keys.map((k) => {
-                const field = desc.fields?.[k];
-                if (!field)
-                    return `${quoteKey(k)}: unknown`;
-                const opt = field.optional ? "?" : "";
-                return `${quoteKey(k)}${opt}: ${emitYupDesc(field)}`;
-            });
-            return `{ ${parts.join("; ")} }`;
-        }
-        case "array": {
-            if (!desc.innerType || Array.isArray(desc.innerType))
-                return "unknown[]";
-            return arrayOf(emitYupDesc(desc.innerType));
-        }
-        case "tuple": {
-            if (!Array.isArray(desc.innerType))
-                return "unknown";
-            return `[${desc.innerType.map((i) => emitYupDesc(i)).join(", ")}]`;
-        }
-        case "mixed": {
-            if (desc.oneOf && desc.oneOf.length > 0)
-                return unionOf(desc.oneOf.map(literalType));
-            return "unknown";
-        }
-        case "lazy":
-            return "unknown";
-        default:
-            return "unknown";
-    }
-}
-function emitEffect(schema) {
-    const s = schema;
-    const ast = s.ast;
-    if (!ast)
-        return "unknown";
-    return emitEffectAst(ast);
-}
-function emitEffectAst(ast) {
-    switch (ast._tag) {
-        case "StringKeyword":
-            return "string";
-        case "NumberKeyword":
-            return "number";
-        case "BooleanKeyword":
-            return "boolean";
-        case "BigIntKeyword":
-            return "bigint";
-        case "SymbolKeyword":
-            return "symbol";
-        case "UndefinedKeyword":
-            return "undefined";
-        case "VoidKeyword":
-            return "void";
-        case "UnknownKeyword":
-        case "AnyKeyword":
-            return "unknown";
-        case "NeverKeyword":
-            return "never";
-        case "ObjectKeyword":
-            return "object";
-        case "Literal":
-            return literalType(ast.literal);
-        case "Union":
-            return unionOf((ast.types ?? []).map((t) => emitEffectAst(t)));
-        case "TypeLiteral": {
-            const props = ast.propertySignatures ?? [];
-            const idxSigs = ast.indexSignatures ?? [];
-            if (props.length === 0 && idxSigs.length === 0)
-                return "{}";
-            if (props.length === 0 && idxSigs.length === 1) {
-                return `Record<${emitEffectAst(idxSigs[0].parameter)}, ${emitEffectAst(idxSigs[0].type)}>`;
-            }
-            const parts = props
-                .filter((p) => typeof p.name === "string")
-                .map((p) => {
-                const opt = p.isOptional ? "?" : "";
-                return `${quoteKey(p.name)}${opt}: ${emitEffectAst(p.type)}`;
-            });
-            return `{ ${parts.join("; ")} }`;
-        }
-        case "TupleType": {
-            const elems = ast.elements ?? [];
-            const rest = ast.rest ?? [];
-            const items = elems.map((e) => `${emitEffectAst(e.type)}${e.isOptional ? "?" : ""}`);
-            if (rest.length > 0) {
-                if (items.length === 0 && rest.length === 1)
-                    return arrayOf(emitEffectAst(rest[0].type));
-                items.push(`...${arrayOf(emitEffectAst(rest[0].type))}`);
-                for (const tail of rest.slice(1))
-                    items.push(emitEffectAst(tail.type));
-            }
-            return `[${items.join(", ")}]`;
-        }
-        case "Declaration":
-            return "unknown";
-        case "Suspend":
-            return "unknown";
-        default:
-            return "unknown";
-    }
-}
-//# sourceMappingURL=type-emitter.js.map