@lovrozagar/honey 0.6.8 → 0.7.1

package/dist/type-emitter.js

@@ -0,0 +1,729 @@
+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