llmz 0.9.0 → 1.0.1

package/dist/{typings-CrBa7Tyy.js → typings-D9_aC8aq.js}

@@ -1,11 +1,10 @@
-import { n as __exportAll } from "./rolldown-runtime-EAsCxrDo.js";
-import { a as getMultilineComment, f as toPropertyKey, n as escapeString } from "./utils-UBeAFeEI.js";
-import { r as CodeFormattingError } from "./errors-Cg1G0Awu.js";
-import { z } from "@bpinternal/zui";
+import { Y as __exportAll, d as toPropertyKey, i as getMultilineComment, n as fromJSONSchemaCompat } from "./utils-BOFzb8Ok.js";
+import { b as InvalidConfigurationError, c as CodeFormattingError } from "./errors-H4JJFH3S.js";
+import { transforms, z } from "@bpinternal/zui";
 //#region src/typings-formatter.ts
 /**
 * A minimal, dependency-free formatter for the TypeScript typings generated by
-* llmz (typings.ts, objects.ts, hoist.ts). It supports only the small grammar
+* llmz (typings.ts, objects.ts). It supports only the small grammar
 * those generators emit — type expressions, `declare const` / `declare function`
 * declarations, `type` aliases and `export namespace` blocks — and produces
 * prettier-like output: 80 columns, 2-space indent, no semicolons in broken
@@ -427,7 +426,7 @@ function breakGroup(p, g, level, tailWidth = 0) {
 		});
 		return;
 	}
-	const separator = g.open === "(" || g.open === "[" ? "," : usedComma ? "," : null;
+	const separator = g.open === "(" || g.open === "[" || usedComma ? "," : null;
 	const trailingSeparator = g.open === "(" || g.open === "[";
 	p.atom({
 		kind: "open",
@@ -566,178 +565,42 @@ async function formatTypings(typings, options) {
 }
 //#endregion
 //#region src/typings.ts
-var typings_exports = /* @__PURE__ */ __exportAll({ getTypings: () => getTypings });
-const Primitives = [
-	"string",
-	"number",
-	"boolean",
-	"unknown",
-	"void",
-	"any",
-	"null",
-	"undefined",
-	"never",
-	"bigint",
-	"symbol",
-	"object"
-];
-const LARGE_DECLARATION_LINES = 5;
-const isPrimitive = (type) => Primitives.includes(type);
-const isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
-const stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
-var KeyValue = class {
-	key;
-	value;
-	constructor(key, value) {
-		this.key = key;
-		this.value = value;
-	}
-};
-var FnParameters = class {
-	schema;
-	constructor(schema) {
-		this.schema = schema;
-	}
-};
-var FnReturn = class {
-	schema;
-	constructor(schema) {
-		this.schema = schema;
-	}
-};
-var Declaration = class {
-	schema;
-	identifier;
-	constructor(schema, identifier) {
-		this.schema = schema;
-		this.identifier = identifier;
-	}
-};
-async function getTypings(schema, options) {
-	options ??= {};
-	options.declaration ??= false;
-	let wrappedSchema = schema;
-	if ((options === null || options === void 0 ? void 0 : options.declaration) && z.is.zuiType(schema)) {
-		const title = "title" in schema.ui ? schema.ui.title : null;
-		if (!title) throw new Error("Only schemas with \"title\" Zui property can be declared.");
-		wrappedSchema = new Declaration(schema, title);
+var typings_exports = /* @__PURE__ */ __exportAll({
+	getTypings: () => getTypings,
+	schemaToTypeScript: () => schemaToTypeScript
+});
+/** One schema renderer for API inputs, results, and memory properties. */
+function schemaToTypeScript(schema) {
+	if (z.is.zuiDefault(schema)) return schemaToTypeScript(schema._def.innerType);
+	const options = { treatDefaultAsOptional: true };
+	try {
+		return transforms.toTypescriptType(schema, options);
+	} catch {
+		const normalized = fromJSONSchemaCompat(transforms.toJSONSchemaLegacy(schema));
+		return transforms.toTypescriptType(normalized, options);
 	}
-	let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
-	dts = await formatTypings(dts, { throwOnError: false });
-	return dts;
 }
-async function sUnwrapZodRecursive(schema, options) {
-	return sUnwrapZod(schema, options);
+function describeParameter(parameter, index) {
+	var _parameter$ui;
+	const name = toPropertyKey(((_parameter$ui = parameter.ui) === null || _parameter$ui === void 0 ? void 0 : _parameter$ui.title) ?? `arg${index}`);
+	const optional = z.is.zuiOptional(parameter) || z.is.zuiDefault(parameter);
+	let value = parameter;
+	while (z.is.zuiOptional(value) || z.is.zuiDefault(value)) value = value._def.innerType;
+	return `${getMultilineComment(parameter.description)}${name}${optional ? "?" : ""}: ${schemaToTypeScript(value.describe(""))}`;
 }
-async function sUnwrapZod(schema, options) {
-	const newOptions = {
-		...options,
-		declaration: false,
-		parent: schema
-	};
-	if (schema instanceof Declaration) {
-		const description = getMultilineComment(schema.schema.description);
-		const typings = await sUnwrapZodRecursive(schema.schema.describe(""), {
-			...newOptions,
-			declaration: true
-		});
-		const closingTag = typings.split("\n").length >= LARGE_DECLARATION_LINES ? `// end of ${schema.identifier}` : "";
-		if (z.is.zuiFunction(schema.schema)) return stripSpaces(`${description}
-declare function ${schema.identifier}${typings};${closingTag}`);
-		return stripSpaces(`${description}
-declare const ${schema.identifier}: ${typings};${closingTag}`);
-	}
-	if (schema instanceof KeyValue) {
-		if (z.is.zuiOptional(schema.value) || z.is.zuiDefault(schema.value)) {
-			let innerType = schema.value._def.innerType;
-			if (z.is.zuiType(innerType) && !innerType.description && schema.value.description) innerType = innerType === null || innerType === void 0 ? void 0 : innerType.describe(schema.value.description);
-			const optionalToken = schema.key.endsWith("?") ? "" : "?";
-			return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
-		}
-		const description = getMultilineComment(schema.value._def.description || schema.value.description);
-		const delimiter = (description === null || description === void 0 ? void 0 : description.trim().length) > 0 ? "\n" : "";
-		const withoutDesc = schema.value.describe("");
-		return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
-	}
-	if (schema instanceof FnParameters) {
-		if (z.is.zuiTuple(schema.schema)) {
-			let args = "";
-			for (let i = 0; i < schema.schema.items.length; i++) {
-				var _schema$schema$items$;
-				const argName = ((_schema$schema$items$ = schema.schema.items[i]) === null || _schema$schema$items$ === void 0 || (_schema$schema$items$ = _schema$schema$items$.ui) === null || _schema$schema$items$ === void 0 ? void 0 : _schema$schema$items$.title) ?? `arg${i}`;
-				const item = schema.schema.items[i];
-				args += `${await sUnwrapZodRecursive(new KeyValue(toPropertyKey(argName), item), newOptions)}, `;
-			}
-			return args;
-		}
-		const isLiteral = z.is.zuiLiteral(schema.schema.naked());
-		const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
-		if (typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings) || isLiteral) return `args: ${typings}`;
-		else return typings;
-	}
-	if (schema instanceof FnReturn) {
-		if (z.is.zuiOptional(schema.schema)) return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
-		return sUnwrapZodRecursive(schema.schema, newOptions);
-	}
-	if (schema === null) return "unknown";
-	if (z.is.zuiDefault(schema)) return sUnwrapZodRecursive(schema._def.innerType, options);
-	if (z.is.zuiVoid(schema)) return "void";
-	if (z.is.zuiUnknown(schema)) return "unknown";
-	if (z.is.zuiAny(schema)) return "any";
-	if (z.is.zuiPromise(schema)) return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+/** Preserve declaration names and parameter labels; Zui renders every value type. */
+async function getTypings(schema, options = {}) {
+	var _schema$ui;
+	if (!options.declaration) return formatTypings(schemaToTypeScript(schema), { throwOnError: false });
+	const title = (_schema$ui = schema.ui) === null || _schema$ui === void 0 ? void 0 : _schema$ui.title;
+	if (typeof title !== "string" || !title) throw new InvalidConfigurationError("Only schemas with \"title\" Zui property can be declared.");
+	const description = getMultilineComment(schema.description);
+	let declaration;
 	if (z.is.zuiFunction(schema)) {
-		const description = getMultilineComment(schema._def.description);
-		const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
-		const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
-		if (options === null || options === void 0 ? void 0 : options.declaration) return `${description}
-(${input}): ${output}`;
-		return `${description}
-(${input}) => ${output}`;
-	}
-	if (z.is.zuiArray(schema)) {
-		const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
-		if (isPrimitive(item)) return `${item}[]`;
-		return `Array<${item}>`;
-	}
-	if (z.is.zuiEnum(schema)) return schema._def.values.map(escapeString).join(" | ");
-	if (z.is.zuiTuple(schema)) {
-		if (schema.items.length === 0) return "[]";
-		return `[${(await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)))).join(", ")}]`;
-	}
-	if (z.is.zuiNullable(schema)) return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
-	if (z.is.zuiOptional(schema)) {
-		if ((options === null || options === void 0 ? void 0 : options.declaration) || z.is.zuiType(options === null || options === void 0 ? void 0 : options.parent) && options.parent.typeName === "ZodRecord") return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
-		const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
-		return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
-	}
-	if (z.is.zuiObject(schema)) return `{ ${(await Promise.all(Object.entries(schema.shape).map(async ([key, value]) => {
-		if (z.is.zuiType(value)) return sUnwrapZodRecursive(new KeyValue(toPropertyKey(key), value), newOptions);
-		return `${key}: unknown`;
-	}))).join("; ")} }`;
-	if (z.is.zuiString(schema)) return `${getMultilineComment(schema._def.description)} string`.trim();
-	if (z.is.zuiUnion(schema)) return `${getMultilineComment(schema._def.description)}
-${(await Promise.all(schema.options.map(async (option) => {
-		return sUnwrapZodRecursive(option, newOptions);
-	}))).join(" | ")}`;
-	if (z.is.zuiLiteral(schema)) return `${getMultilineComment(schema._def.description)}
-${typeof schema.value === "string" ? escapeString(schema.value) : String(schema.value)}`.trim();
-	if (z.is.zuiNumber(schema)) return `${getMultilineComment(schema._def.description)} number`.trim();
-	if (z.is.zuiBoolean(schema)) return `${getMultilineComment(schema._def.description)} boolean`.trim();
-	if (z.is.zuiCatch(schema)) return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
-	if (z.is.zuiLazy(schema)) return sUnwrapZodRecursive(schema._def.getter(), newOptions);
-	if (z.is.zuiRecord(schema)) return `${getMultilineComment(schema._def.description)} { [key: (${await sUnwrapZodRecursive(schema._def.keyType, newOptions)})]: (${await sUnwrapZodRecursive(schema._def.valueType, newOptions)}) }`;
-	try {
-		let typings = schema === null || schema === void 0 ? void 0 : schema.toTypescriptType({ treatDefaultAsOptional: true });
-		typings ??= "unknown";
-		return stripSpaces(typings);
-	} catch (error) {
-		console.error("Error in sUnwrapZod", {
-			error,
-			schema,
-			parent: options === null || options === void 0 ? void 0 : options.parent
-		});
-		return "unknown";
-	}
+		const input = schema.parameters();
+		declaration = `declare function ${title}(${z.is.zuiTuple(input) ? input.items.map(describeParameter).join(", ") : `args: ${schemaToTypeScript(input)}`}): ${schemaToTypeScript(schema.returnType())};`;
+	} else declaration = `declare const ${title}: ${schemaToTypeScript(schema.describe(""))};`;
+	return formatTypings(`${description}\n${declaration}`, { throwOnError: false });
 }
 //#endregion
-export { isPunct as a, isGroup as i, typings_exports as n, parse as o, formatTypings as r, tokenize as s, getTypings as t };
+export { formatTypings as i, schemaToTypeScript as n, typings_exports as r, getTypings as t };

package/dist/typings-formatter.d.ts

@@ -1,6 +1,6 @@
 /**
  * A minimal, dependency-free formatter for the TypeScript typings generated by
- * llmz (typings.ts, objects.ts, hoist.ts). It supports only the small grammar
+ * llmz (typings.ts, objects.ts). It supports only the small grammar
  * those generators emit — type expressions, `declare const` / `declare function`
  * declarations, `type` aliases and `export namespace` blocks — and produces
  * prettier-like output: 80 columns, 2-space indent, no semicolons in broken

package/dist/typings.d.ts

@@ -2,4 +2,7 @@ import { z } from '@bpinternal/zui';
 export type Options = {
     declaration?: boolean;
 };
+/** One schema renderer for API inputs, results, and memory properties. */
+export declare function schemaToTypeScript(schema: z.Schema): string;
+/** Preserve declaration names and parameter labels; Zui renders every value type. */
 export declare function getTypings(schema: z.Schema, options?: Options): Promise<string>;

package/dist/{uniq-BYQ7GWwb.js → uniq-DfUeSNaX.js}

@@ -1,4 +1,4 @@
-import { a as cacheHas, l as Set, o as SetCache, r as setToArray } from "./_baseIteratee-P_firB7b.js";
+import { S as Set, _ as setToArray, v as cacheHas, y as SetCache } from "./utils-BOFzb8Ok.js";
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/noop.js
 /**
 * This method returns `undefined`.
@@ -180,4 +180,4 @@ function uniq(array) {
 	return array && array.length ? baseUniq(array) : [];
 }
 //#endregion
-export { baseUniq as n, noop as r, uniq as t };
+export { uniq as t };

package/dist/{uniq-G872RWmE.cjs → uniq-DiXgysNV.cjs}

@@ -1,4 +1,4 @@
-const require__baseIteratee = require("./_baseIteratee-CF4qP2a8.cjs");
+const require_utils = require("./utils-CTlsXvdj.cjs");
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/noop.js
 /**
 * This method returns `undefined`.
@@ -113,8 +113,8 @@ function arrayIncludesWith(array, value, comparator) {
 * @param {Array} values The values to add to the set.
 * @returns {Object} Returns the new set.
 */
-var createSet = !(require__baseIteratee.Set && 1 / require__baseIteratee.setToArray(new require__baseIteratee.Set([, -0]))[1] == 1 / 0) ? noop : function(values) {
-	return new require__baseIteratee.Set(values);
+var createSet = !(require_utils.Set && 1 / require_utils.setToArray(new require_utils.Set([, -0]))[1] == 1 / 0) ? noop : function(values) {
+	return new require_utils.Set(values);
 };
 //#endregion
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseUniq.js
@@ -136,10 +136,10 @@ function baseUniq(array, iteratee, comparator) {
 		includes = arrayIncludesWith;
 	} else if (length >= LARGE_ARRAY_SIZE) {
 		var set = iteratee ? null : createSet(array);
-		if (set) return require__baseIteratee.setToArray(set);
+		if (set) return require_utils.setToArray(set);
 		isCommon = false;
-		includes = require__baseIteratee.cacheHas;
-		seen = new require__baseIteratee.SetCache();
+		includes = require_utils.cacheHas;
+		seen = new require_utils.SetCache();
 	} else seen = iteratee ? [] : result;
 	outer: while (++index < length) {
 		var value = array[index], computed = iteratee ? iteratee(value) : value;
@@ -180,18 +180,6 @@ function uniq(array) {
 	return array && array.length ? baseUniq(array) : [];
 }
 //#endregion
-Object.defineProperty(exports, "baseUniq", {
-	enumerable: true,
-	get: function() {
-		return baseUniq;
-	}
-});
-Object.defineProperty(exports, "noop", {
-	enumerable: true,
-	get: function() {
-		return noop;
-	}
-});
 Object.defineProperty(exports, "uniq", {
 	enumerable: true,
 	get: function() {