@powerlines/schema 0.11.81 → 0.11.83

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/bundle.cjs

@@ -0,0 +1,49 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _powerlines_core_lib_unplugin = require("@powerlines/core/lib/unplugin");
+let _powerlines_unplugin_esbuild = require("@powerlines/unplugin/esbuild");
+let _stryke_helpers_omit = require("@stryke/helpers/omit");
+let _stryke_path_file_path_fns = require("@stryke/path/file-path-fns");
+let defu = require("defu");
+defu = require_runtime.__toESM(defu, 1);
+let esbuild = require("esbuild");
+let unplugin = require("unplugin");
+
+//#region src/bundle.ts
+/**
+* Bundle a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param file - The file path to bundle.
+* @param options - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the bundled module.
+*/
+async function bundle(context, file, options = {}) {
+	const path = await context.fs.resolve(file);
+	if (!path || !context.fs.existsSync(path)) throw new Error(`Module not found: "${file}". Please check the path and try again.`);
+	const result = await (0, esbuild.build)((0, defu.default)({
+		platform: "node",
+		...(0, _stryke_helpers_omit.omit)(options, ["name", "resolve"]),
+		logLevel: "silent",
+		entryPoints: [path],
+		write: false,
+		sourcemap: false,
+		splitting: false,
+		treeShaking: false,
+		bundle: true,
+		packages: "bundle",
+		keepNames: true,
+		metafile: false
+	}, (0, _powerlines_unplugin_esbuild.resolveOptions)(context), { plugins: [(0, unplugin.createEsbuildPlugin)((0, _powerlines_core_lib_unplugin.createUnpluginResolver)(context, {
+		name: options.name ?? `${(0, _stryke_path_file_path_fns.findFileName)(file)} Bundler`,
+		prefix: false,
+		overrides: (0, defu.default)(options.resolve ?? {}, { skipNodeModulesBundle: false }),
+		silenceHookLogging: true
+	}))()] }));
+	if (result.errors.length > 0) throw new Error(`Failed to bundle ${file}: ${result.errors.map((error) => error.text).join(", ")}`);
+	if (result.warnings.length > 0) context.warn(`Warnings while bundling ${file}: ${result.warnings.map((warning) => warning.text).join(", ")}`);
+	if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	return result.outputFiles.filter(Boolean)[0];
+}
+
+//#endregion
+exports.bundle = bundle;

package/dist/bundle.d.cts

@@ -0,0 +1,21 @@
+import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
+import { DeepPartial } from "@stryke/types/base";
+import { BuildOptions, OutputFile } from "esbuild";
+
+//#region src/bundle.d.ts
+type BundleOptions = DeepPartial<BuildOptions> & {
+  name?: string;
+  resolve?: DeepPartial<ResolveOptions>;
+};
+/**
+ * Bundle a type definition to a module.
+ *
+ * @param context - The context object containing the environment paths.
+ * @param file - The file path to bundle.
+ * @param options - Optional overrides for the ESBuild configuration.
+ * @returns A promise that resolves to the bundled module.
+ */
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
+//#endregion
+export { BundleOptions, bundle };
+//# sourceMappingURL=bundle.d.cts.map

package/dist/bundle.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.cts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KA6BY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,iBAAA,EAC5C,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}

package/dist/bundle.d.mts

@@ -0,0 +1,21 @@
+import { BuildOptions, OutputFile } from "esbuild";
+import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
+import { DeepPartial } from "@stryke/types/base";
+
+//#region src/bundle.d.ts
+type BundleOptions = DeepPartial<BuildOptions> & {
+  name?: string;
+  resolve?: DeepPartial<ResolveOptions>;
+};
+/**
+ * Bundle a type definition to a module.
+ *
+ * @param context - The context object containing the environment paths.
+ * @param file - The file path to bundle.
+ * @param options - Optional overrides for the ESBuild configuration.
+ * @returns A promise that resolves to the bundled module.
+ */
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputFile>;
+//#endregion
+export { BundleOptions, bundle };
+//# sourceMappingURL=bundle.d.mts.map

package/dist/bundle.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.mts","names":[],"sources":["../src/bundle.ts"],"mappings":";;;;;KA6BY,aAAA,GAAgB,WAAA,CAAY,YAAA;EACtC,IAAA;EACA,OAAA,GAAU,WAAA,CAAY,cAAA;AAAA;;;;;;;;;iBAWF,MAAA,kBAAwB,iBAAA,EAC5C,OAAA,EAAS,QAAA,EACT,IAAA,UACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,UAAA"}

package/dist/bundle.mjs

@@ -0,0 +1,48 @@
+import { createUnpluginResolver } from "@powerlines/core/lib/unplugin";
+import { resolveOptions } from "@powerlines/unplugin/esbuild";
+import { omit } from "@stryke/helpers/omit";
+import { findFileName } from "@stryke/path/file-path-fns";
+import defu from "defu";
+import { build } from "esbuild";
+import { createEsbuildPlugin } from "unplugin";
+
+//#region src/bundle.ts
+/**
+* Bundle a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param file - The file path to bundle.
+* @param options - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the bundled module.
+*/
+async function bundle(context, file, options = {}) {
+	const path = await context.fs.resolve(file);
+	if (!path || !context.fs.existsSync(path)) throw new Error(`Module not found: "${file}". Please check the path and try again.`);
+	const result = await build(defu({
+		platform: "node",
+		...omit(options, ["name", "resolve"]),
+		logLevel: "silent",
+		entryPoints: [path],
+		write: false,
+		sourcemap: false,
+		splitting: false,
+		treeShaking: false,
+		bundle: true,
+		packages: "bundle",
+		keepNames: true,
+		metafile: false
+	}, resolveOptions(context), { plugins: [createEsbuildPlugin(createUnpluginResolver(context, {
+		name: options.name ?? `${findFileName(file)} Bundler`,
+		prefix: false,
+		overrides: defu(options.resolve ?? {}, { skipNodeModulesBundle: false }),
+		silenceHookLogging: true
+	}))()] }));
+	if (result.errors.length > 0) throw new Error(`Failed to bundle ${file}: ${result.errors.map((error) => error.text).join(", ")}`);
+	if (result.warnings.length > 0) context.warn(`Warnings while bundling ${file}: ${result.warnings.map((warning) => warning.text).join(", ")}`);
+	if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	return result.outputFiles.filter(Boolean)[0];
+}
+
+//#endregion
+export { bundle };
+//# sourceMappingURL=bundle.mjs.map

package/dist/bundle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.mjs","names":[],"sources":["../src/bundle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { ResolveOptions, UnresolvedContext } from \"@powerlines/core\";\nimport { createUnpluginResolver } from \"@powerlines/core/lib/unplugin\";\nimport { resolveOptions } from \"@powerlines/unplugin/esbuild\";\nimport { omit } from \"@stryke/helpers/omit\";\nimport { findFileName } from \"@stryke/path/file-path-fns\";\nimport { DeepPartial } from \"@stryke/types/base\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport { build, OutputFile } from \"esbuild\";\nimport { createEsbuildPlugin } from \"unplugin\";\n\nexport type BundleOptions = DeepPartial<BuildOptions> & {\n  name?: string;\n  resolve?: DeepPartial<ResolveOptions>;\n};\n\n/**\n * Bundle a type definition to a module.\n *\n * @param context - The context object containing the environment paths.\n * @param file - The file path to bundle.\n * @param options - Optional overrides for the ESBuild configuration.\n * @returns A promise that resolves to the bundled module.\n */\nexport async function bundle<TContext extends UnresolvedContext>(\n  context: TContext,\n  file: string,\n  options: BundleOptions = {}\n): Promise<OutputFile> {\n  const path = await context.fs.resolve(file);\n  if (!path || !context.fs.existsSync(path)) {\n    throw new Error(\n      `Module not found: \"${file}\". Please check the path and try again.`\n    );\n  }\n\n  const result = await build(\n    defu(\n      {\n        platform: \"node\",\n        ...omit(options, [\"name\", \"resolve\"]),\n        logLevel: \"silent\",\n        entryPoints: [path],\n        write: false,\n        sourcemap: false,\n        splitting: false,\n        treeShaking: false,\n        bundle: true,\n        packages: \"bundle\",\n        keepNames: true,\n        metafile: false\n      },\n      resolveOptions(context),\n      {\n        plugins: [\n          createEsbuildPlugin(\n            createUnpluginResolver(context, {\n              name: options.name ?? `${findFileName(file)} Bundler`,\n              prefix: false,\n              overrides: defu(options.resolve ?? {}, {\n                skipNodeModulesBundle: false\n              }),\n              silenceHookLogging: true\n            })\n          )()\n        ]\n      }\n    )\n  );\n  if (result.errors.length > 0) {\n    throw new Error(\n      `Failed to bundle ${file}: ${result.errors\n        .map(error => error.text)\n        .join(\", \")}`\n    );\n  }\n  if (result.warnings.length > 0) {\n    context.warn(\n      `Warnings while bundling ${file}: ${result.warnings\n        .map(warning => warning.text)\n        .join(\", \")}`\n    );\n  }\n  if (!result.outputFiles || result.outputFiles.filter(Boolean).length === 0) {\n    throw new Error(\n      `No output files generated for ${\n        file\n      }. Please check the configuration and try again.`\n    );\n  }\n\n  return result.outputFiles.filter(Boolean)[0]!;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0CA,eAAsB,OACpB,SACA,MACA,UAAyB,CAAC,GACL;CACrB,MAAM,OAAO,MAAM,QAAQ,GAAG,QAAQ,IAAI;CAC1C,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,WAAW,IAAI,GACtC,MAAM,IAAI,MACR,sBAAsB,KAAK,wCAC7B;CAGF,MAAM,SAAS,MAAM,MACnB,KACE;EACE,UAAU;EACV,GAAG,KAAK,SAAS,CAAC,QAAQ,SAAS,CAAC;EACpC,UAAU;EACV,aAAa,CAAC,IAAI;EAClB,OAAO;EACP,WAAW;EACX,WAAW;EACX,aAAa;EACb,QAAQ;EACR,UAAU;EACV,WAAW;EACX,UAAU;CACZ,GACA,eAAe,OAAO,GACtB,EACE,SAAS,CACP,oBACE,uBAAuB,SAAS;EAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,IAAI,EAAE;EAC5C,QAAQ;EACR,WAAW,KAAK,QAAQ,WAAW,CAAC,GAAG,EACrC,uBAAuB,MACzB,CAAC;EACD,oBAAoB;CACtB,CAAC,CACH,EAAE,CACJ,EACF,CACF,CACF;CACA,IAAI,OAAO,OAAO,SAAS,GACzB,MAAM,IAAI,MACR,oBAAoB,KAAK,IAAI,OAAO,OACjC,KAAI,UAAS,MAAM,IAAI,EACvB,KAAK,IAAI,GACd;CAEF,IAAI,OAAO,SAAS,SAAS,GAC3B,QAAQ,KACN,2BAA2B,KAAK,IAAI,OAAO,SACxC,KAAI,YAAW,QAAQ,IAAI,EAC3B,KAAK,IAAI,GACd;CAEF,IAAI,CAAC,OAAO,eAAe,OAAO,YAAY,OAAO,OAAO,EAAE,WAAW,GACvE,MAAM,IAAI,MACR,iCACE,KACD,gDACH;CAGF,OAAO,OAAO,YAAY,OAAO,OAAO,EAAE;AAC5C"}

package/dist/codegen.cjs

@@ -0,0 +1,378 @@
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_metadata = require('./metadata.cjs');
+const require_type_checks = require('./type-checks.cjs');
+const require_helpers = require('./helpers.cjs');
+const require_validate = require('./validate.cjs');
+let _stryke_convert_to_bool = require("@stryke/convert/to-bool");
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_type_checks_is_boolean = require("@stryke/type-checks/is-boolean");
+let _stryke_type_checks_is_null = require("@stryke/type-checks/is-null");
+let _stryke_type_checks_is_number = require("@stryke/type-checks/is-number");
+let _stryke_type_checks_is_set_string = require("@stryke/type-checks/is-set-string");
+let _stryke_type_checks_is_undefined = require("@stryke/type-checks/is-undefined");
+let ajv_dist_standalone_index_js = require("ajv/dist/standalone/index.js");
+ajv_dist_standalone_index_js = require_runtime.__toESM(ajv_dist_standalone_index_js, 1);
+
+//#region src/codegen.ts
+/**
+* Stringifies a value for generated TypeScript code.
+*/
+function stringifyValue(value, type) {
+	return (0, _stryke_type_checks_is_undefined.isUndefined)(value) ? "undefined" : (0, _stryke_type_checks_is_null.isNull)(value) ? "null" : type === "boolean" || (0, _stryke_type_checks_is_boolean.isBoolean)(value) ? String((0, _stryke_convert_to_bool.toBool)(value)) : type === "number" || (0, _stryke_type_checks_is_number.isNumber)(value) ? Number.parseFloat(String(value)).toLocaleString(void 0, { maximumFractionDigits: 20 }) : type === "integer" ? Number.parseInt(String(value)).toLocaleString() : type === "string" || type === "object" || type === "array" ? JSON.stringify(value) : String(value);
+}
+/**
+* Stringifies a JSON Schema fragment into a TypeScript-like type string.
+*/
+function stringifyType(schema) {
+	if (!schema) return "unknown";
+	if (typeof schema === "boolean") return schema ? "unknown" : "never";
+	if (require_type_checks.isJsonSchemaObject(schema) && (0, _stryke_type_checks_is_set_string.isSetString)(schema.name)) return schema.name;
+	const objectSchema = schema;
+	if ((0, _stryke_type_checks_is_set_string.isSetString)(objectSchema.$ref)) return /^#\/(?:definitions|\$defs)\/(.+)$/.exec(objectSchema.$ref)?.[1] ?? objectSchema.$ref;
+	const primaryType = require_metadata.getPrimarySchemaType(schema);
+	if (primaryType) {
+		if (primaryType === "integer" || primaryType === "number") return "number";
+		return primaryType;
+	}
+	if (objectSchema.type === "array" && Array.isArray(objectSchema.enum)) return objectSchema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if (objectSchema.const !== void 0) return JSON.stringify(objectSchema.const);
+	if (objectSchema.type === "array" || objectSchema.items) return `${stringifyType(Array.isArray(objectSchema.items) ? objectSchema.items[0] : objectSchema.items)}[]`;
+	if (objectSchema.type === "object" || objectSchema.properties || objectSchema.additionalProperties) {
+		if (require_type_checks.isJsonSchema(objectSchema.additionalProperties)) return `{ [key: string]: ${stringifyType(objectSchema.additionalProperties)} }`;
+		if (require_type_checks.isJsonSchemaObject(objectSchema)) {
+			const required = objectSchema.required ?? [];
+			return `{ ${require_helpers.getPropertiesList(objectSchema).map((property) => {
+				const suffix = !required.includes(property.name) || require_helpers.isSchemaNullable(property) ? `${!required.includes(property.name) ? "?" : ""}${require_helpers.isSchemaNullable(property) ? " | null" : ""}` : "";
+				return `${property.name}${suffix}: ${stringifyType(property)}`;
+			}).join(";\n")} }`;
+		}
+	}
+	if (objectSchema.oneOf || objectSchema.anyOf) return (objectSchema.oneOf ?? objectSchema.anyOf ?? []).map((branch) => stringifyType(branch)).join(" | ");
+	if (objectSchema.allOf) return "object";
+	return "unknown";
+}
+/**
+* Returns a string type representation of a value based on its type and an optional JSON Schema primitive type hint.
+*
+* @param value - The value whose type is to be represented as a string.
+* @returns A string representation of the value's type, which may be influenced by the provided JSON Schema primitive type hint. The function handles various JavaScript types and formats them accordingly, including special handling for `undefined`, `null`, booleans, numbers (with formatting), strings, objects, and arrays. If a specific type hint is provided, it will take precedence in determining the string representation of the value.
+*/
+function getJsonSchemaType(value) {
+	return (0, _stryke_type_checks_is_null.isNull)(value) ? "null" : (0, _stryke_type_checks_is_boolean.isBoolean)(value) ? "boolean" : (0, _stryke_type_checks.isInteger)(value) ? "integer" : (0, _stryke_type_checks_is_number.isNumber)(value) ? "number" : (0, _stryke_type_checks.isString)(value) ? "string" : (0, _stryke_type_checks.isObject)(value) ? "object" : Array.isArray(value) ? "array" : void 0;
+}
+/**
+* Resolves a local JSON Schema `$ref` (e.g. `#/$defs/Name`) to the referenced definition name.
+*/
+function resolveLocalRefName(ref) {
+	return /^#\/(?:definitions|\$defs)\/(.+)$/.exec(ref)?.[1];
+}
+/**
+* Converts an arbitrary definition name into a safe JavaScript identifier suffix.
+*/
+function toParserIdentifier(name) {
+	const cleaned = name.replace(/[^\w$]/gu, "_");
+	return `parse_${/^\d/u.test(cleaned) ? `_${cleaned}` : cleaned}`;
+}
+/**
+* Returns the list of JSON Schema `type` keyword values declared on a fragment,
+* preserving `object` and `array` (which {@link readSchemaTypes} intentionally drops).
+*/
+function readDeclaredTypes(schema) {
+	const type = schema.type;
+	if (Array.isArray(type)) return [...type];
+	return type ? [type] : [];
+}
+/**
+* Generates a JavaScript expression that builds a path string for a child element.
+*/
+function childPath(pathExpr, segment) {
+	return `${pathExpr} + ${JSON.stringify(segment)}`;
+}
+/**
+* Generates standalone parser code for a JSON Schema.
+*
+* @remarks
+* The generated `parse` function reads an arbitrary input value and converts it
+* into the shape described by the schema. It walks the schema recursively to:
+*
+* - resolve local `$ref` pointers (`#/$defs/*` and `#/definitions/*`) into
+*   dedicated parser functions so recursive schemas are supported,
+* - apply `default` values for object properties (and root/array values) that
+*   are missing from the input,
+* - coerce primitive values to the declared type (for example `"42"` to `42`
+*   for an `integer` schema, or `1` to `true` for a `boolean` schema),
+* - validate `const`, `enum`, `oneOf`/`anyOf` and `allOf` constraints, and
+* - collect detailed, path-aware errors and throw a `ParserError` when the
+*   input cannot be converted into a valid value.
+*
+* @param schema - The JSON Schema to generate parser code for.
+* @returns The generated standalone parser code as a string.
+*/
+function generateParserCode(schema) {
+	const rootSchema = typeof schema === "boolean" ? schema : schema;
+	const definitions = typeof rootSchema === "boolean" ? {} : {
+		...rootSchema.definitions,
+		...rootSchema.$defs
+	};
+	let tempCounter = 0;
+	function nextTemp(prefix) {
+		const id = tempCounter;
+		tempCounter += 1;
+		return `__${prefix}_${id}`;
+	}
+	function indent(lines, size = 2) {
+		const padding = " ".repeat(size);
+		return lines.map((line) => `${padding}${line}`);
+	}
+	/**
+	* Generates inline parsing statements for a schema fragment.
+	*/
+	function generateStatements(fragment, valueExpr, pathExpr, targetVar, errorsVar = "errors") {
+		if (typeof fragment === "boolean") return fragment ? [`${targetVar} = ${valueExpr};`] : [`${errorsVar}.push({ path: ${pathExpr}, message: "No value is allowed at this location" });`, `${targetVar} = ${valueExpr};`];
+		const view = fragment;
+		if ((0, _stryke_type_checks_is_set_string.isSetString)(view.$ref)) {
+			const refName = resolveLocalRefName(view.$ref);
+			if (refName && refName in definitions) return [`${targetVar} = ${toParserIdentifier(refName)}(${valueExpr}, ${pathExpr}, ${errorsVar});`];
+			return [`${targetVar} = ${valueExpr};`];
+		}
+		const valueVar = nextTemp("value");
+		const pathVar = nextTemp("path");
+		const lines = [`const ${valueVar} = ${valueExpr};`, `const ${pathVar} = ${pathExpr};`];
+		if (view.default !== void 0) {
+			lines.push(`if (${valueVar} === undefined) {`, `  ${targetVar} = ${JSON.stringify(view.default)};`, `} else {`);
+			if (require_helpers.isSchemaNullable(view)) {
+				lines.push(`  if (${valueVar} === null) {`, `    ${targetVar} = null;`, `  } else {`);
+				lines.push(...indent(generateCoreStatements(view, valueVar, pathVar, targetVar, errorsVar), 4));
+				lines.push(`  }`);
+			} else lines.push(...indent(generateCoreStatements(view, valueVar, pathVar, targetVar, errorsVar), 2));
+			lines.push(`}`);
+			return lines;
+		}
+		lines.push(`if (${valueVar} === undefined) {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "A value is required" });`, `  ${targetVar} = ${valueVar};`, `} else {`);
+		if (require_helpers.isSchemaNullable(view)) {
+			lines.push(`  if (${valueVar} === null) {`, `    ${targetVar} = null;`, `  } else {`);
+			lines.push(...indent(generateCoreStatements(view, valueVar, pathVar, targetVar, errorsVar), 4));
+			lines.push(`  }`);
+		} else lines.push(...indent(generateCoreStatements(view, valueVar, pathVar, targetVar, errorsVar), 2));
+		lines.push(`}`);
+		return lines;
+	}
+	/**
+	* Generates inline parsing statements assuming `value` is already defined.
+	*/
+	function generateCoreStatements(view, valueVar, pathVar, targetVar, errorsVar) {
+		const lines = [];
+		if (view.const !== void 0) {
+			const constValue = JSON.stringify(view.const);
+			lines.push(`if (JSON.stringify(${valueVar}) !== ${constValue}) { ${errorsVar}.push({ path: ${pathVar}, message: "Expected the constant value " + ${constValue} }); }`, `${targetVar} = ${constValue};`);
+			return lines;
+		}
+		if (Array.isArray(view.enum)) {
+			const enumValues = JSON.stringify(view.enum);
+			lines.push(`if (!${enumValues}.some(allowed => JSON.stringify(allowed) === JSON.stringify(${valueVar}))) { ${errorsVar}.push({ path: ${pathVar}, message: "Expected one of " + ${enumValues} }); }`, `${targetVar} = ${valueVar};`);
+			return lines;
+		}
+		if (Array.isArray(view.oneOf) || Array.isArray(view.anyOf)) {
+			const branches = view.oneOf ?? view.anyOf ?? [];
+			const matchedVar = nextTemp("matched");
+			lines.push(`let ${matchedVar} = false;`);
+			for (const branch of branches) {
+				const branchErrorsVar = nextTemp("branchErrors");
+				const branchResultVar = nextTemp("branchResult");
+				lines.push(`if (!${matchedVar}) {`);
+				lines.push(`  const ${branchErrorsVar}: { path: string; message: string }[] = [];`, `  let ${branchResultVar};`);
+				lines.push(...indent(generateStatements(branch, valueVar, pathVar, branchResultVar, branchErrorsVar), 2));
+				lines.push(`  if (${branchErrorsVar}.length === 0) {`, `    ${targetVar} = ${branchResultVar};`, `    ${matchedVar} = true;`, `  }`, `}`);
+			}
+			lines.push(`if (!${matchedVar}) {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Value does not match any of the allowed schemas" });`, `  ${targetVar} = ${valueVar};`, `}`);
+			return lines;
+		}
+		if (Array.isArray(view.allOf)) {
+			const { allOf, ...rest } = view;
+			const merged = require_helpers.merge(rest, ...allOf);
+			lines.push(...generateStatements(merged, valueVar, pathVar, targetVar, errorsVar));
+			return lines;
+		}
+		const declaredTypes = readDeclaredTypes(view);
+		switch (require_metadata.getPrimarySchemaType(view) ?? declaredTypes.find((type) => type !== "null") ?? (view.properties ? "object" : view.items ? "array" : void 0)) {
+			case "object":
+				lines.push(...generateObjectStatements(view, valueVar, pathVar, targetVar, errorsVar));
+				break;
+			case "array":
+				lines.push(...generateArrayStatements(view, valueVar, pathVar, targetVar, errorsVar));
+				break;
+			case "string":
+				lines.push(`if (typeof ${valueVar} === "string") {`, `  ${targetVar} = ${valueVar};`, `} else if (typeof ${valueVar} === "number" || typeof ${valueVar} === "boolean") {`, `  ${targetVar} = String(${valueVar});`, `} else {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Expected a string value" });`, `  ${targetVar} = ${valueVar};`, `}`);
+				break;
+			case "integer":
+				lines.push(`if (typeof ${valueVar} === "number" && Number.isInteger(${valueVar})) {`, `  ${targetVar} = ${valueVar};`, `} else if (typeof ${valueVar} === "string" && ${valueVar}.trim() !== "" && Number.isInteger(Number(${valueVar}))) {`, `  ${targetVar} = Number(${valueVar});`, `} else if (typeof ${valueVar} === "boolean") {`, `  ${targetVar} = ${valueVar} ? 1 : 0;`, `} else {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Expected an integer value" });`, `  ${targetVar} = ${valueVar};`, `}`);
+				break;
+			case "number":
+				lines.push(`if (typeof ${valueVar} === "number") {`, `  ${targetVar} = ${valueVar};`, `} else if (typeof ${valueVar} === "string" && ${valueVar}.trim() !== "" && !Number.isNaN(Number(${valueVar}))) {`, `  ${targetVar} = Number(${valueVar});`, `} else if (typeof ${valueVar} === "boolean") {`, `  ${targetVar} = ${valueVar} ? 1 : 0;`, `} else {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Expected a number value" });`, `  ${targetVar} = ${valueVar};`, `}`);
+				break;
+			case "boolean":
+				lines.push(`if (typeof ${valueVar} === "boolean") {`, `  ${targetVar} = ${valueVar};`, `} else if (${valueVar} === "true" || ${valueVar} === 1) {`, `  ${targetVar} = true;`, `} else if (${valueVar} === "false" || ${valueVar} === 0) {`, `  ${targetVar} = false;`, `} else {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Expected a boolean value" });`, `  ${targetVar} = ${valueVar};`, `}`);
+				break;
+			case "null":
+				lines.push(`if (${valueVar} === null) {`, `  ${targetVar} = null;`, `} else {`, `  ${errorsVar}.push({ path: ${pathVar}, message: "Expected a null value" });`, `  ${targetVar} = ${valueVar};`, `}`);
+				break;
+			case void 0:
+			default:
+				lines.push(`${targetVar} = ${valueVar};`);
+				break;
+		}
+		return lines;
+	}
+	/**
+	* Generates the parsing statements for an `object` schema, applying property
+	* defaults and recursing into each declared property.
+	*/
+	function generateObjectStatements(view, valueVar, pathVar, targetVar, errorsVar) {
+		const type = stringifyType(view);
+		const lines = [
+			`if (typeof ${valueVar} !== "object" || ${valueVar} === null || Array.isArray(${valueVar})) {`,
+			`  ${errorsVar}.push({ path: ${pathVar}, message: "Expected an object value" });`,
+			`  ${targetVar} = ${valueVar};`,
+			`} else {`
+		];
+		const resultVar = nextTemp("object");
+		lines.push(`  const ${resultVar} = {}${type ? ` as ${type}` : ""};`);
+		const properties = require_type_checks.isJsonSchemaObject(view) ? require_helpers.getPropertiesList(view) : [];
+		const propertyNames = /* @__PURE__ */ new Set();
+		for (const property of properties) {
+			const name = property.name;
+			propertyNames.add(name);
+			const accessor = `${valueVar}[${JSON.stringify(name)}]`;
+			const propertyPath = childPath(pathVar, `.${name}`);
+			const propertyVar = nextTemp("property");
+			const missingBranch = property.default !== void 0 ? `${resultVar}[${JSON.stringify(name)}] = ${JSON.stringify(property.default)};` : property.required ? `errors.push({ path: ${propertyPath}, message: "Required property is missing" });` : ``;
+			lines.push(`  if (${accessor} !== undefined) {`, `    let ${propertyVar};`);
+			lines.push(...indent(generateStatements(property, accessor, propertyPath, propertyVar, errorsVar), 4));
+			lines.push(`    ${resultVar}[${JSON.stringify(name)}] = ${propertyVar};`);
+			if (missingBranch) lines.push(`  } else { ${missingBranch} }`);
+			else lines.push(`  }`);
+		}
+		const additional = view.additionalProperties;
+		if (require_type_checks.isJsonSchema(additional)) {
+			const additionalVar = nextTemp("additional");
+			lines.push(`  for (const key of Object.keys(${valueVar})) {`, `    if (${JSON.stringify([...propertyNames])}.includes(key)) { continue; }`, `    let ${additionalVar};`);
+			lines.push(...indent(generateStatements(additional, `${valueVar}[key]`, `${pathVar} + "." + key`, additionalVar, errorsVar), 4));
+			lines.push(`    ${resultVar}[key] = ${additionalVar};`, `}`);
+		} else if (additional !== false) lines.push(`  for (const key of Object.keys(${valueVar})) {`, `    if (${JSON.stringify([...propertyNames])}.includes(key)) { continue; }`, `    ${resultVar}[key] = ${valueVar}[key];`, `}`);
+		lines.push(`  ${targetVar} = ${resultVar};`, `}`);
+		return lines;
+	}
+	/**
+	* Generates the parsing statements for an `array` schema, recursing into each
+	* item (supporting both list and tuple `items`/`prefixItems` forms).
+	*/
+	function generateArrayStatements(view, valueVar, pathVar, targetVar, errorsVar) {
+		const lines = [
+			`if (!Array.isArray(${valueVar})) {`,
+			`  ${errorsVar}.push({ path: ${pathVar}, message: "Expected an array value" });`,
+			`  ${targetVar} = ${valueVar};`,
+			`} else {`
+		];
+		const resultVar = nextTemp("array");
+		lines.push(`  const ${resultVar}: unknown[] = [];`);
+		const tupleItems = view.prefixItems ?? (Array.isArray(view.items) ? view.items : void 0);
+		if (tupleItems) {
+			const listItems = !Array.isArray(view.items) ? view.items : void 0;
+			lines.push(`  for (let index = 0; index < ${valueVar}.length; index += 1) {`, `    const item = ${valueVar}[index];`, `    let itemResult;`);
+			tupleItems.forEach((item, index) => {
+				lines.push(`${index === 0 ? "    if" : "    else if"} (index === ${index}) {`);
+				lines.push(...indent(generateStatements(item, "item", childPath(pathVar, `[${index}]`), "itemResult", errorsVar), 6));
+				lines.push(`    }`);
+			});
+			if (listItems) {
+				lines.push(`    else {`);
+				lines.push(...indent(generateStatements(listItems, "item", `${pathVar} + "[" + index + "]"`, "itemResult", errorsVar), 6));
+				lines.push(`    }`);
+			} else lines.push(`    else { itemResult = item; }`);
+			lines.push(`    ${resultVar}.push(itemResult);`, `  }`, `  ${targetVar} = ${resultVar};`, `}`);
+			return lines;
+		}
+		const itemSchema = view.items ?? true;
+		lines.push(`  for (let index = 0; index < ${valueVar}.length; index += 1) {`, `    const item = ${valueVar}[index];`, `    let itemResult;`);
+		lines.push(...indent(generateStatements(itemSchema, "item", `${pathVar} + "[" + index + "]"`, "itemResult", errorsVar), 4));
+		lines.push(`    ${resultVar}.push(itemResult);`, `  }`, `  ${targetVar} = ${resultVar};`, `}`);
+		return lines;
+	}
+	return `/**
+ * Error thrown when an input value cannot be parsed into the type described by the JSON Schema.
+ */
+export class ParserError extends Error {
+  public override name = "ParserError";
+
+  public errors: { path: string; message: string }[];
+
+  public constructor(errors: { path: string; message: string }[]) {
+    super(
+      "Failed to parse the provided value against the JSON Schema:\\n" +
+        errors.map(error => "  - " + error.path + ": " + error.message).join("\\n")
+    );
+
+    this.errors = errors;
+  }
+}
+
+${Object.entries(definitions).map(([name, definition]) => `function ${toParserIdentifier(name)}(value, path, errors) {\n  let result;\n${indent(generateStatements(definition, "value", "path", "result", "errors")).join("\n")}\n\n  return result;\n}`).join("\n\n")}
+
+/**
+ * Parses an input value into the type described by the JSON Schema.
+ *
+ * @remarks
+ * The parser applies default values for missing properties, coerces primitive values to the declared type, and throws a {@link ParserError} (containing a detailed list of validation errors) when the value cannot be converted into a valid result.
+ *
+ * @param value - The input value to parse.
+ * @returns The parsed value conforming to the schema.
+ */
+export function parse(value: unknown)${schema.name ? `: ${stringifyType(schema)}` : ""} {
+  const errors: { path: string; message: string }[] = [];
+
+  let result;
+${indent(generateStatements(schema, "value", "\"$\"", "result", "errors")).join("\n")}
+
+  if (errors.length > 0) {
+    throw new ParserError(errors);
+  }
+
+  return result;
+}`;
+}
+/**
+* Generates standalone JSON Schema validation code using Ajv.
+*
+* @remarks
+* The generated code includes a validation function that can be used to validate data against the provided JSON Schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
+*
+* @param schema - The JSON Schema to generate validation code for.
+* @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
+* @returns The generated standalone validation code as a string.
+*/
+function generateValidationCode(schema, refsOrFuncts) {
+	return (0, ajv_dist_standalone_index_js.default)(require_validate.getValidator(schema), refsOrFuncts);
+}
+/**
+* Generates standalone JavaScript code for validating and parsing data according to a JSON Schema.
+*
+* @remarks
+* The generated code includes:
+* - Validation code generated by Ajv for the provided JSON Schema, which can be used to validate data against the schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
+* - Parsing code generated for the provided JSON Schema, which can be used to parse and validate data against the schema at runtime. The parsing function will apply default values specified in the schema if they are not present in the input data, throw an error if the input data does not conform to the schema (providing detailed information about the validation errors), and return the parsed data if it is valid according to the schema.
+*
+* @param schema - The JSON Schema to generate code for.
+* @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
+* @returns The generated standalone validation and parsing code as a string.
+*/
+function generateCode(schema, refsOrFuncts) {
+	return `${generateValidationCode(schema, refsOrFuncts)}\n\n${generateParserCode(schema)}`;
+}
+
+//#endregion
+exports.generateCode = generateCode;
+exports.generateParserCode = generateParserCode;
+exports.generateValidationCode = generateValidationCode;
+exports.getJsonSchemaType = getJsonSchemaType;
+exports.stringifyType = stringifyType;
+exports.stringifyValue = stringifyValue;

package/dist/codegen.d.cts

@@ -0,0 +1,67 @@
+import { JsonSchema, JsonSchemaType } from "./types.cjs";
+import standaloneCode from "ajv/dist/standalone/index.js";
+
+//#region src/codegen.d.ts
+/**
+ * Stringifies a value for generated TypeScript code.
+ */
+declare function stringifyValue(value?: unknown, type?: JsonSchemaType | string): string;
+/**
+ * Stringifies a JSON Schema fragment into a TypeScript-like type string.
+ */
+declare function stringifyType(schema?: JsonSchema): string;
+/**
+ * Returns a string type representation of a value based on its type and an optional JSON Schema primitive type hint.
+ *
+ * @param value - The value whose type is to be represented as a string.
+ * @returns A string representation of the value's type, which may be influenced by the provided JSON Schema primitive type hint. The function handles various JavaScript types and formats them accordingly, including special handling for `undefined`, `null`, booleans, numbers (with formatting), strings, objects, and arrays. If a specific type hint is provided, it will take precedence in determining the string representation of the value.
+ */
+declare function getJsonSchemaType(value?: unknown): JsonSchemaType | undefined;
+/**
+ * Generates standalone parser code for a JSON Schema.
+ *
+ * @remarks
+ * The generated `parse` function reads an arbitrary input value and converts it
+ * into the shape described by the schema. It walks the schema recursively to:
+ *
+ * - resolve local `$ref` pointers (`#/$defs/*` and `#/definitions/*`) into
+ *   dedicated parser functions so recursive schemas are supported,
+ * - apply `default` values for object properties (and root/array values) that
+ *   are missing from the input,
+ * - coerce primitive values to the declared type (for example `"42"` to `42`
+ *   for an `integer` schema, or `1` to `true` for a `boolean` schema),
+ * - validate `const`, `enum`, `oneOf`/`anyOf` and `allOf` constraints, and
+ * - collect detailed, path-aware errors and throw a `ParserError` when the
+ *   input cannot be converted into a valid value.
+ *
+ * @param schema - The JSON Schema to generate parser code for.
+ * @returns The generated standalone parser code as a string.
+ */
+declare function generateParserCode(schema: JsonSchema): string;
+/**
+ * Generates standalone JSON Schema validation code using Ajv.
+ *
+ * @remarks
+ * The generated code includes a validation function that can be used to validate data against the provided JSON Schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
+ *
+ * @param schema - The JSON Schema to generate validation code for.
+ * @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
+ * @returns The generated standalone validation code as a string.
+ */
+declare function generateValidationCode(schema: JsonSchema, refsOrFuncts?: Parameters<typeof standaloneCode>[1]): string;
+/**
+ * Generates standalone JavaScript code for validating and parsing data according to a JSON Schema.
+ *
+ * @remarks
+ * The generated code includes:
+ * - Validation code generated by Ajv for the provided JSON Schema, which can be used to validate data against the schema at runtime. The validation function will throw an error if the data does not conform to the schema, providing detailed information about the validation errors.
+ * - Parsing code generated for the provided JSON Schema, which can be used to parse and validate data against the schema at runtime. The parsing function will apply default values specified in the schema if they are not present in the input data, throw an error if the input data does not conform to the schema (providing detailed information about the validation errors), and return the parsed data if it is valid according to the schema.
+ *
+ * @param schema - The JSON Schema to generate code for.
+ * @param refsOrFuncts - Optional additional references or functions for Ajv's standalone code generation.
+ * @returns The generated standalone validation and parsing code as a string.
+ */
+declare function generateCode(schema: JsonSchema, refsOrFuncts?: Parameters<typeof standaloneCode>[1]): string;
+//#endregion
+export { generateCode, generateParserCode, generateValidationCode, getJsonSchemaType, stringifyType, stringifyValue };
+//# sourceMappingURL=codegen.d.cts.map

package/dist/codegen.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.cts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;AAqDA;iBAAgB,cAAA,CACd,KAAA,YACA,IAAA,GAAO,cAAc;;;;iBAsBP,aAAA,CAAc,MAAmB,GAAV,UAAU;;;AAtBjB;AAsBhC;;;iBA8FgB,iBAAA,CAAkB,KAAA,aAAkB,cAAc;AA9FjB;AA8FjD;;;;AAAkE;AA0ElE;;;;AAAqD;AAqmBrD;;;;;;;;;AA7wBiD,iBAwKjC,kBAAA,CAAmB,MAAkB,EAAV,UAAU;;;;;AAumBA;AAiBrD;;;;;iBAnBgB,sBAAA,CACd,MAAA,EAAQ,UAAA,EACR,YAAA,GAAe,UAAA,QAAkB,cAAA;;;;;;;;;AAmBkB;;;;iBAFrC,YAAA,CACd,MAAA,EAAQ,UAAA,EACR,YAAA,GAAe,UAAA,QAAkB,cAAA"}