@powerlines/schema 0.11.25 → 0.11.27

package/dist/bundle.mjs.map

@@ -1 +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 {\n  CreateUnpluginResolverOptions,\n  ResolveOptions,\n  UnresolvedContext\n} 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        entryPoints: [path],\n        write: false,\n        sourcemap: false,\n        splitting: false,\n        treeShaking: true,\n        bundle: true,\n        packages: \"bundle\",\n        platform: \"node\",\n        logLevel: \"silent\",\n        ...omit(options, [\"name\", \"resolve\"])\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(\n                options.resolve ?? {},\n                { skipNodeModulesBundle: false },\n                context.config.resolve\n              ) as CreateUnpluginResolverOptions[\"overrides\"],\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":";;;;;;;;;;;;;;;;;AA8CA,eAAsB,OACpB,SACA,MACA,UAAyB,EAAE,EACN;CACrB,MAAM,OAAO,MAAM,QAAQ,GAAG,QAAQ,KAAK;AAC3C,KAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,WAAW,KAAK,CACvC,OAAM,IAAI,MACR,sBAAsB,KAAK,yCAC5B;CAGH,MAAM,SAAS,MAAM,MACnB,KACE;EACE,aAAa,CAAC,KAAK;EACnB,OAAO;EACP,WAAW;EACX,WAAW;EACX,aAAa;EACb,QAAQ;EACR,UAAU;EACV,UAAU;EACV,UAAU;EACV,GAAG,KAAK,SAAS,CAAC,QAAQ,UAAU,CAAC;EACtC,EACD,eAAe,QAAQ,EACvB,EACE,SAAS,CACP,oBACE,uBAAuB,SAAS;EAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,KAAK,CAAC;EAC5C,QAAQ;EACR,WAAW,KACT,QAAQ,WAAW,EAAE,EACrB,EAAE,uBAAuB,OAAO,EAChC,QAAQ,OAAO,QAChB;EACD,oBAAoB;EACrB,CAAC,CACH,EAAE,CACJ,EACF,CACF,CACF;AACD,KAAI,OAAO,OAAO,SAAS,EACzB,OAAM,IAAI,MACR,oBAAoB,KAAK,IAAI,OAAO,OACjC,KAAI,UAAS,MAAM,KAAK,CACxB,KAAK,KAAK,GACd;AAEH,KAAI,OAAO,SAAS,SAAS,EAC3B,SAAQ,KACN,2BAA2B,KAAK,IAAI,OAAO,SACxC,KAAI,YAAW,QAAQ,KAAK,CAC5B,KAAK,KAAK,GACd;AAEH,KAAI,CAAC,OAAO,eAAe,OAAO,YAAY,OAAO,QAAQ,CAAC,WAAW,EACvE,OAAM,IAAI,MACR,iCACE,KACD,iDACF;AAGH,QAAO,OAAO,YAAY,OAAO,QAAQ,CAAC"}
+{"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 {\n  CreateUnpluginResolverOptions,\n  ResolveOptions,\n  UnresolvedContext\n} 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        entryPoints: [path],\n        write: false,\n        sourcemap: false,\n        splitting: false,\n        treeShaking: true,\n        bundle: true,\n        packages: \"bundle\",\n        platform: \"node\",\n        logLevel: \"silent\",\n        ...omit(options, [\"name\", \"resolve\"])\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(\n                options.resolve ?? {},\n                { skipNodeModulesBundle: false },\n                context.config.resolve\n              ) as CreateUnpluginResolverOptions[\"overrides\"],\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":";;;;;;;;;;;;;;;;;AA8CA,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,aAAa,CAAC,IAAI;EAClB,OAAO;EACP,WAAW;EACX,WAAW;EACX,aAAa;EACb,QAAQ;EACR,UAAU;EACV,UAAU;EACV,UAAU;EACV,GAAG,KAAK,SAAS,CAAC,QAAQ,SAAS,CAAC;CACtC,GACA,eAAe,OAAO,GACtB,EACE,SAAS,CACP,oBACE,uBAAuB,SAAS;EAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,IAAI,EAAE;EAC5C,QAAQ;EACR,WAAW,KACT,QAAQ,WAAW,CAAC,GACpB,EAAE,uBAAuB,MAAM,GAC/B,QAAQ,OAAO,OACjB;EACA,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

@@ -1,12 +1,53 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-let ajv = require("ajv");
-ajv = require_runtime.__toESM(ajv, 1);
-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);
+const require_helpers = require('./helpers.cjs');
+let _stryke_convert_to_bool = require("@stryke/convert/to-bool");
+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_undefined = require("@stryke/type-checks/is-undefined");
+let ajv_lib_jtd_ts = require("ajv/lib/jtd.ts");
+ajv_lib_jtd_ts = require_runtime.__toESM(ajv_lib_jtd_ts, 1);
+let ajv_lib_standalone_index_ts = require("ajv/lib/standalone/index.ts");
+ajv_lib_standalone_index_ts = require_runtime.__toESM(ajv_lib_standalone_index_ts, 1);
 
 //#region src/codegen.ts
 /**
+* Stringifies a value as a string.
+*
+* @remarks
+* This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to "true" or "false", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.
+*
+* @param value - The value to stringify.
+* @returns A string representation of the value.
+*/
+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 && type.startsWith("float") ? Number.parseFloat(String(value)).toLocaleString(void 0, { maximumFractionDigits: 20 }) : type && ["int", "uint"].some((prefix) => type.startsWith(prefix)) || (0, _stryke_type_checks_is_number.isNumber)(value) ? Number.parseInt(String(value)).toLocaleString() : type === "timestamp" ? `"${new Date(String(value)).toISOString()}"` : JSON.stringify(String(value).replaceAll("\"", "\\\""), void 0, 2);
+}
+/**
+* Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.
+*
+* @param schema - The JTD schema type to stringify.
+* @returns A string representation of the JTD schema type.
+*/
+function stringifyType(schema) {
+	if (!schema) return "unknown";
+	if ("ref" in schema) return schema.ref;
+	if ("type" in schema) return [
+		"float",
+		"uint",
+		"int"
+	].some((prefix) => schema.type.startsWith(prefix)) ? "number" : schema.type === "timestamp" ? "string" : schema.type;
+	if ("enum" in schema) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if ("elements" in schema) return `${stringifyType(schema.elements)}[]`;
+	if ("values" in schema) return `{ [key: string]: ${stringifyType(schema.values)} }`;
+	if ("properties" in schema || "optionalProperties" in schema) return `{ ${Object.entries(require_helpers.getProperties(schema)).map(([key, value]) => {
+		return `${key}${value.optional ? "?" : ""}: ${stringifyType(value)}`;
+	}).join(";\n")} }`;
+	if ("discriminator" in schema) return "object";
+	return "unknown";
+}
+/**
 * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
 *
 * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
@@ -14,7 +55,7 @@ ajv_dist_standalone_index_js = require_runtime.__toESM(ajv_dist_standalone_index
 * @returns A promise that resolves to a string containing the generated standalone validation code.
 */
 async function generateCode(schemas, refsOrFuncts) {
-	return (0, ajv_dist_standalone_index_js.default)(new ajv.default({
+	return (0, ajv_lib_standalone_index_ts.default)(new ajv_lib_jtd_ts.default({
 		schemas,
 		code: {
 			source: true,
@@ -24,4 +65,6 @@ async function generateCode(schemas, refsOrFuncts) {
 }
 
 //#endregion
-exports.generateCode = generateCode;
+exports.generateCode = generateCode;
+exports.stringifyType = stringifyType;
+exports.stringifyValue = stringifyValue;

package/dist/codegen.d.cts

@@ -1,7 +1,25 @@
-import { Options } from "ajv";
-import standaloneCode from "ajv/dist/standalone/index.js";
+import { JTDSchemaType, JTDType } from "./types.cjs";
+import { Options } from "ajv/lib/jtd.ts";
+import standaloneCode from "ajv/lib/standalone/index.ts";
 
 //#region src/codegen.d.ts
+/**
+ * Stringifies a value as a string.
+ *
+ * @remarks
+ * This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to "true" or "false", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.
+ *
+ * @param value - The value to stringify.
+ * @returns A string representation of the value.
+ */
+declare function stringifyValue(value?: unknown, type?: JTDType): string;
+/**
+ * Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.
+ *
+ * @param schema - The JTD schema type to stringify.
+ * @returns A string representation of the JTD schema type.
+ */
+declare function stringifyType(schema?: JTDSchemaType): string;
 /**
  * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
  *
@@ -11,5 +29,5 @@ import standaloneCode from "ajv/dist/standalone/index.js";
  */
 declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
 //#endregion
-export { generateCode };
+export { generateCode, stringifyType, stringifyValue };
 //# sourceMappingURL=codegen.d.cts.map

package/dist/codegen.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.cts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;AA6BA;;;;;iBAAsB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}
+{"version":3,"file":"codegen.d.cts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;;AAsCA;;;;;;;iBAAgB,cAAA,CAAe,KAAA,YAAiB,IAAA,GAAO,OAAO;AAAA;AA6B9D;;;;AAAoD;AA7BU,iBA6B9C,aAAA,CAAc,MAAsB,GAAb,aAAa;;;;;;;;iBAqD9B,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}

package/dist/codegen.d.mts

@@ -1,7 +1,25 @@
-import { Options } from "ajv";
-import standaloneCode from "ajv/dist/standalone/index.js";
+import { JTDSchemaType, JTDType } from "./types.mjs";
+import { Options } from "ajv/lib/jtd.ts";
+import standaloneCode from "ajv/lib/standalone/index.ts";
 
 //#region src/codegen.d.ts
+/**
+ * Stringifies a value as a string.
+ *
+ * @remarks
+ * This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to "true" or "false", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.
+ *
+ * @param value - The value to stringify.
+ * @returns A string representation of the value.
+ */
+declare function stringifyValue(value?: unknown, type?: JTDType): string;
+/**
+ * Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.
+ *
+ * @param schema - The JTD schema type to stringify.
+ * @returns A string representation of the JTD schema type.
+ */
+declare function stringifyType(schema?: JTDSchemaType): string;
 /**
  * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
  *
@@ -11,5 +29,5 @@ import standaloneCode from "ajv/dist/standalone/index.js";
  */
 declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
 //#endregion
-export { generateCode };
+export { generateCode, stringifyType, stringifyValue };
 //# sourceMappingURL=codegen.d.mts.map

package/dist/codegen.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.mts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;AA6BA;;;;;iBAAsB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}
+{"version":3,"file":"codegen.d.mts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;;AAsCA;;;;;;;iBAAgB,cAAA,CAAe,KAAA,YAAiB,IAAA,GAAO,OAAO;AAAA;AA6B9D;;;;AAAoD;AA7BU,iBA6B9C,aAAA,CAAc,MAAsB,GAAb,aAAa;;;;;;;;iBAqD9B,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA"}

package/dist/codegen.mjs

@@ -1,8 +1,49 @@
-import Ajv from "ajv";
-import standaloneCode from "ajv/dist/standalone/index.js";
+import { getProperties } from "./helpers.mjs";
+import { toBool } from "@stryke/convert/to-bool";
+import { isBoolean } from "@stryke/type-checks/is-boolean";
+import { isNull } from "@stryke/type-checks/is-null";
+import { isNumber } from "@stryke/type-checks/is-number";
+import { isUndefined } from "@stryke/type-checks/is-undefined";
+import Ajv from "ajv/lib/jtd.ts";
+import standaloneCode from "ajv/lib/standalone/index.ts";
 
 //#region src/codegen.ts
 /**
+* Stringifies a value as a string.
+*
+* @remarks
+* This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to "true" or "false", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.
+*
+* @param value - The value to stringify.
+* @returns A string representation of the value.
+*/
+function stringifyValue(value, type) {
+	return isUndefined(value) ? "undefined" : isNull(value) ? "null" : type === "boolean" || isBoolean(value) ? String(toBool(value)) : type && type.startsWith("float") ? Number.parseFloat(String(value)).toLocaleString(void 0, { maximumFractionDigits: 20 }) : type && ["int", "uint"].some((prefix) => type.startsWith(prefix)) || isNumber(value) ? Number.parseInt(String(value)).toLocaleString() : type === "timestamp" ? `"${new Date(String(value)).toISOString()}"` : JSON.stringify(String(value).replaceAll("\"", "\\\""), void 0, 2);
+}
+/**
+* Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.
+*
+* @param schema - The JTD schema type to stringify.
+* @returns A string representation of the JTD schema type.
+*/
+function stringifyType(schema) {
+	if (!schema) return "unknown";
+	if ("ref" in schema) return schema.ref;
+	if ("type" in schema) return [
+		"float",
+		"uint",
+		"int"
+	].some((prefix) => schema.type.startsWith(prefix)) ? "number" : schema.type === "timestamp" ? "string" : schema.type;
+	if ("enum" in schema) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if ("elements" in schema) return `${stringifyType(schema.elements)}[]`;
+	if ("values" in schema) return `{ [key: string]: ${stringifyType(schema.values)} }`;
+	if ("properties" in schema || "optionalProperties" in schema) return `{ ${Object.entries(getProperties(schema)).map(([key, value]) => {
+		return `${key}${value.optional ? "?" : ""}: ${stringifyType(value)}`;
+	}).join(";\n")} }`;
+	if ("discriminator" in schema) return "object";
+	return "unknown";
+}
+/**
 * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.
 *
 * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.
@@ -20,5 +61,5 @@ async function generateCode(schemas, refsOrFuncts) {
 }
 
 //#endregion
-export { generateCode };
+export { generateCode, stringifyType, stringifyValue };
 //# sourceMappingURL=codegen.mjs.map

package/dist/codegen.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.mjs","names":[],"sources":["../src/codegen.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 { Options } from \"ajv\";\nimport Ajv from \"ajv\";\nimport standaloneCode from \"ajv/dist/standalone\";\n\n/**\n * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.\n *\n * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.\n * @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.\n * @returns A promise that resolves to a string containing the generated standalone validation code.\n */\nexport async function generateCode(\n  schemas: Options[\"schemas\"],\n  refsOrFuncts?: Parameters<typeof standaloneCode>[1]\n) {\n  return standaloneCode(\n    new Ajv({\n      schemas,\n      code: { source: true, esm: true }\n    }),\n    refsOrFuncts\n  );\n}\n"],"mappings":";;;;;;;;;;;AA6BA,eAAsB,aACpB,SACA,cACA;AACA,QAAO,eACL,IAAI,IAAI;EACN;EACA,MAAM;GAAE,QAAQ;GAAM,KAAK;GAAM;EAClC,CAAC,EACF,aACD"}
+{"version":3,"file":"codegen.mjs","names":[],"sources":["../src/codegen.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 { toBool } from \"@stryke/convert/to-bool\";\nimport { isBoolean } from \"@stryke/type-checks/is-boolean\";\nimport { isNull } from \"@stryke/type-checks/is-null\";\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isUndefined } from \"@stryke/type-checks/is-undefined\";\nimport type { Options } from \"ajv/lib/jtd\";\nimport Ajv from \"ajv/lib/jtd\";\nimport standaloneCode from \"ajv/lib/standalone\";\nimport { getProperties } from \"./helpers\";\nimport { JTDSchemaType, JTDType } from \"./types\";\n\n/**\n * Stringifies a value as a string.\n *\n * @remarks\n * This function is used to convert a value into a string representation that can be used in generated code, such as default values in TypeScript declarations. It handles different types of values, including booleans, numbers, and strings, and formats them appropriately. For example, boolean values are converted to \"true\" or \"false\", numbers are formatted with locale-specific separators, and strings are JSON-stringified with escaped quotes. The function also takes into account the type of the value when stringifying, allowing for specific formatting based on the type (e.g., different handling for integers vs. floats). This ensures that the generated code is both accurate and readable.\n *\n * @param value - The value to stringify.\n * @returns A string representation of the value.\n */\nexport function stringifyValue(value?: unknown, type?: JTDType): string {\n  return isUndefined(value)\n    ? \"undefined\"\n    : isNull(value)\n      ? \"null\"\n      : type === \"boolean\" || isBoolean(value)\n        ? String(toBool(value))\n        : type && type.startsWith(\"float\")\n          ? Number.parseFloat(String(value)).toLocaleString(undefined, {\n              maximumFractionDigits: 20\n            })\n          : (type && [\"int\", \"uint\"].some(prefix => type.startsWith(prefix))) ||\n              isNumber(value)\n            ? Number.parseInt(String(value)).toLocaleString()\n            : type === \"timestamp\"\n              ? `\"${new Date(String(value)).toISOString()}\"`\n              : JSON.stringify(\n                  String(value).replaceAll('\"', '\\\\\"'),\n                  undefined,\n                  2\n                );\n}\n\n/**\n * Stringifies a JTD schema type into a string representation. This function takes a JTD schema type as input and returns a string that represents the type in a human-readable format. It handles various JTD schema constructs, such as references, primitive types, enums, arrays, objects, and discriminated unions. The resulting string can be used for documentation, error messages, or any context where a textual representation of the schema type is needed. The function recursively processes nested schemas to ensure that complex types are accurately represented in the output string.\n *\n * @param schema - The JTD schema type to stringify.\n * @returns A string representation of the JTD schema type.\n */\nexport function stringifyType(schema?: JTDSchemaType): string {\n  if (!schema) {\n    return \"unknown\";\n  }\n\n  if (\"ref\" in schema) {\n    return schema.ref;\n  }\n\n  if (\"type\" in schema) {\n    return [\"float\", \"uint\", \"int\"].some(prefix =>\n      schema.type.startsWith(prefix)\n    )\n      ? \"number\"\n      : schema.type === \"timestamp\"\n        ? \"string\"\n        : schema.type;\n  }\n\n  if (\"enum\" in schema) {\n    return schema.enum.map(value => JSON.stringify(value)).join(\" | \");\n  }\n\n  if (\"elements\" in schema) {\n    return `${stringifyType(schema.elements)}[]`;\n  }\n\n  if (\"values\" in schema) {\n    return `{ [key: string]: ${stringifyType(schema.values)} }`;\n  }\n\n  if (\"properties\" in schema || \"optionalProperties\" in schema) {\n    return `{ ${Object.entries(getProperties(schema))\n      .map(([key, value]) => {\n        return `${key}${value.optional ? \"?\" : \"\"}: ${stringifyType(value)}`;\n      })\n      .join(\";\\n\")} }`;\n  }\n\n  if (\"discriminator\" in schema) {\n    return \"object\";\n  }\n\n  return \"unknown\";\n}\n\n/**\n * Generates standalone validation code for the provided JSON schemas using the Ajv library. This function takes an array of JSON schemas and an optional set of references or functions, and returns a string containing the generated validation code. The generated code can be used to validate data against the provided schemas without requiring the Ajv library at runtime, making it suitable for use in environments where minimizing dependencies is important.\n *\n * @param schemas - An array of JSON schemas to generate validation code for. Each schema should be a valid JSON schema object that defines the structure and constraints of the data to be validated.\n * @param refsOrFuncts - An optional parameter that can be either an object containing schema references or a function that returns such an object. This parameter allows you to provide additional schemas that may be referenced by the main schemas, or to define custom functions that can be used in the generated validation code. If not provided, the function will generate code based solely on the provided schemas.\n * @returns A promise that resolves to a string containing the generated standalone validation code.\n */\nexport async function generateCode(\n  schemas: Options[\"schemas\"],\n  refsOrFuncts?: Parameters<typeof standaloneCode>[1]\n) {\n  return standaloneCode(\n    new Ajv({\n      schemas,\n      code: { source: true, esm: true }\n    }),\n    refsOrFuncts\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,eAAe,OAAiB,MAAwB;CACtE,OAAO,YAAY,KAAK,IACpB,cACA,OAAO,KAAK,IACV,SACA,SAAS,aAAa,UAAU,KAAK,IACnC,OAAO,OAAO,KAAK,CAAC,IACpB,QAAQ,KAAK,WAAW,OAAO,IAC7B,OAAO,WAAW,OAAO,KAAK,CAAC,EAAE,eAAe,QAAW,EACzD,uBAAuB,GACzB,CAAC,IACA,QAAQ,CAAC,OAAO,MAAM,EAAE,MAAK,WAAU,KAAK,WAAW,MAAM,CAAC,KAC7D,SAAS,KAAK,IACd,OAAO,SAAS,OAAO,KAAK,CAAC,EAAE,eAAe,IAC9C,SAAS,cACP,IAAI,IAAI,KAAK,OAAO,KAAK,CAAC,EAAE,YAAY,EAAE,KAC1C,KAAK,UACH,OAAO,KAAK,EAAE,WAAW,MAAK,MAAK,GACnC,QACA,CACF;AAChB;;;;;;;AAQA,SAAgB,cAAc,QAAgC;CAC5D,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,SAAS,QACX,OAAO,OAAO;CAGhB,IAAI,UAAU,QACZ,OAAO;EAAC;EAAS;EAAQ;CAAK,EAAE,MAAK,WACnC,OAAO,KAAK,WAAW,MAAM,CAC/B,IACI,WACA,OAAO,SAAS,cACd,WACA,OAAO;CAGf,IAAI,UAAU,QACZ,OAAO,OAAO,KAAK,KAAI,UAAS,KAAK,UAAU,KAAK,CAAC,EAAE,KAAK,KAAK;CAGnE,IAAI,cAAc,QAChB,OAAO,GAAG,cAAc,OAAO,QAAQ,EAAE;CAG3C,IAAI,YAAY,QACd,OAAO,oBAAoB,cAAc,OAAO,MAAM,EAAE;CAG1D,IAAI,gBAAgB,UAAU,wBAAwB,QACpD,OAAO,KAAK,OAAO,QAAQ,cAAc,MAAM,CAAC,EAC7C,KAAK,CAAC,KAAK,WAAW;EACrB,OAAO,GAAG,MAAM,MAAM,WAAW,MAAM,GAAG,IAAI,cAAc,KAAK;CACnE,CAAC,EACA,KAAK,KAAK,EAAE;CAGjB,IAAI,mBAAmB,QACrB,OAAO;CAGT,OAAO;AACT;;;;;;;;AASA,eAAsB,aACpB,SACA,cACA;CACA,OAAO,eACL,IAAI,IAAI;EACN;EACA,MAAM;GAAE,QAAQ;GAAM,KAAK;EAAK;CAClC,CAAC,GACD,YACF;AACF"}

package/dist/constants.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/constants.ts
+const JTDTypes = {
+	STRING: "string",
+	TIMESTAMP: "timestamp",
+	BOOLEAN: "boolean",
+	FLOAT32: "float32",
+	FLOAT64: "float64",
+	INT8: "int8",
+	UINT8: "uint8",
+	INT16: "int16",
+	UINT16: "uint16",
+	INT32: "int32",
+	UINT32: "uint32"
+};
+
+//#endregion
+exports.JTDTypes = JTDTypes;

package/dist/constants.d.cts

@@ -0,0 +1,17 @@
+//#region src/constants.d.ts
+declare const JTDTypes: {
+  readonly STRING: "string";
+  readonly TIMESTAMP: "timestamp";
+  readonly BOOLEAN: "boolean";
+  readonly FLOAT32: "float32";
+  readonly FLOAT64: "float64";
+  readonly INT8: "int8";
+  readonly UINT8: "uint8";
+  readonly INT16: "int16";
+  readonly UINT16: "uint16";
+  readonly INT32: "int32";
+  readonly UINT32: "uint32";
+};
+//#endregion
+export { JTDTypes };
+//# sourceMappingURL=constants.d.cts.map

package/dist/constants.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.cts","names":[],"sources":["../src/constants.ts"],"mappings":";cAkBa,QAAA;EAAA"}

package/dist/constants.d.mts

@@ -0,0 +1,17 @@
+//#region src/constants.d.ts
+declare const JTDTypes: {
+  readonly STRING: "string";
+  readonly TIMESTAMP: "timestamp";
+  readonly BOOLEAN: "boolean";
+  readonly FLOAT32: "float32";
+  readonly FLOAT64: "float64";
+  readonly INT8: "int8";
+  readonly UINT8: "uint8";
+  readonly INT16: "int16";
+  readonly UINT16: "uint16";
+  readonly INT32: "int32";
+  readonly UINT32: "uint32";
+};
+//#endregion
+export { JTDTypes };
+//# sourceMappingURL=constants.d.mts.map

package/dist/constants.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","names":[],"sources":["../src/constants.ts"],"mappings":";cAkBa,QAAA;EAAA"}

package/dist/constants.mjs

@@ -0,0 +1,18 @@
+//#region src/constants.ts
+const JTDTypes = {
+	STRING: "string",
+	TIMESTAMP: "timestamp",
+	BOOLEAN: "boolean",
+	FLOAT32: "float32",
+	FLOAT64: "float64",
+	INT8: "int8",
+	UINT8: "uint8",
+	INT16: "int16",
+	UINT16: "uint16",
+	INT32: "int32",
+	UINT32: "uint32"
+};
+
+//#endregion
+export { JTDTypes };
+//# sourceMappingURL=constants.mjs.map

package/dist/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../src/constants.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\nexport const JTDTypes = {\n  STRING: \"string\",\n  TIMESTAMP: \"timestamp\",\n  BOOLEAN: \"boolean\",\n  FLOAT32: \"float32\",\n  FLOAT64: \"float64\",\n  INT8: \"int8\",\n  UINT8: \"uint8\",\n  INT16: \"int16\",\n  UINT16: \"uint16\",\n  INT32: \"int32\",\n  UINT32: \"uint32\"\n} as const;\n"],"mappings":";AAkBA,MAAa,WAAW;CACtB,QAAQ;CACR,WAAW;CACX,SAAS;CACT,SAAS;CACT,SAAS;CACT,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CACR,OAAO;CACP,QAAQ;AACV"}

package/dist/extract.cjs

@@ -1,17 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_type_checks = require('./type-checks.cjs');
 const require_jtd = require('./jtd.cjs');
+const require_persistence = require('./persistence.cjs');
 const require_reflection = require('./reflection.cjs');
 const require_resolve = require('./resolve.cjs');
-const require_type_checks = require('./type-checks.cjs');
 let defu = require("defu");
 defu = require_runtime.__toESM(defu, 1);
+let _stryke_type_checks = require("@stryke/type-checks");
 let _powerlines_core = require("@powerlines/core");
 let _powerlines_deepkit_esbuild_plugin = require("@powerlines/deepkit/esbuild-plugin");
 let _powerlines_deepkit_vendor_type = require("@powerlines/deepkit/vendor/type");
 let _stryke_hash = require("@stryke/hash");
 let _stryke_json = require("@stryke/json");
-let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_path_join = require("@stryke/path/join");
 let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
 let _stryke_zod = require("@stryke/zod");
 
@@ -199,6 +201,7 @@ async function extractSchema(context, input, options = {}) {
 	};
 	let source;
 	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
 	if (variant === "type-definition") {
 		const resolved = await require_resolve.resolve(context, input, (0, defu.default)(options, { plugins: [(0, _powerlines_deepkit_esbuild_plugin.esbuildPlugin)(context, {
 			reflection: "default",
@@ -218,7 +221,7 @@ async function extractSchema(context, input, options = {}) {
 		variant,
 		source,
 		schema: await extractSchemaSchema(source.schema, source.variant),
-		hash: extractHash(variant, input)
+		hash
 	};
 }
 /**
@@ -250,7 +253,23 @@ async function extractSchema(context, input, options = {}) {
 * @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.
 */
 async function extract(context, input, options = {}) {
-	return await extractSchema(context, input, options);
+	if (require_type_checks.isExtractedSchema(input) || require_type_checks.isSchema(input)) return input;
+	let result;
+	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
+	const cacheFilePath = (0, _stryke_path_join.joinPaths)(require_persistence.getCacheDirectory(context), `${hash}.json`);
+	if (context.config.skipCache !== true && context.fs.existsSync(cacheFilePath)) {
+		const schema = await context.fs.read(cacheFilePath);
+		if (schema) result = {
+			variant,
+			hash,
+			schema: JSON.parse(schema)
+		};
+	}
+	result ??= await extractSchema(context, input, options);
+	if (!result?.schema) throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	if (context.config.skipCache !== true) await require_persistence.writeSchema(context, result);
+	return result;
 }
 
 //#endregion

package/dist/extract.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"extract.d.cts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAmEA;iBAAgB,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAA;;;;;;;;;AA8BT;iBAAgB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA;;;;;;;;;;iBAiBnB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,MAAA,YAAkB,aAAA,CAAc,SAAA;;;;;;;;iBAsClB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAA;;;;AA1CH;;;;iBAuEgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAA;;;;;;;;;iBAgB9B,mBAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,aAAA,CAAc,SAAA;;;;;;;;AApDzB;iBA6FgB,aAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,OAAA,EAAS,mBAAA,EAAqB,KAAA,EAAO,iBAAA,GAAoB,YAAA;;;;;;;;AAhE3D;;;;;;;;;AAgBA;;;;iBAgHsB,aAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;AAzE3B;;;;;iBAkKsB,OAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,SAAA"}
+{"version":3,"file":"extract.d.cts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAqEA;iBAAgB,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAW;;;;;;;;AAAA;AA8BpB;iBAAgB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA;;;;;;;;;;iBAiBnB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,MAAA,YAAkB,aAAA,CAAc,SAAA;;;;;;;;iBAsClB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAmB;;;AA3DsB;AAiB5C;;;;iBAuEgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAkB;;;;;;;;;iBAgBhD,mBAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,aAAA,CAAc,SAAA;;;;;;;AA1FkB;AAsC3C;iBA6FgB,aAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,OAAA,EAAS,mBAAA,EAAqB,KAAA,EAAO,iBAAA,GAAoB,YAAA;;;;;;;AA7FrC;AA6BtB;;;;;;;;AAAsE;AAgBtE;;;;iBAgHsB,aAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;AAlHO;AAyClC;;;;;iBAoKsB,OAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,SAAA"}

package/dist/extract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAmEA;iBAAgB,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAA;;;;;;;;;AA8BT;iBAAgB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA;;;;;;;;;;iBAiBnB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,MAAA,YAAkB,aAAA,CAAc,SAAA;;;;;;;;iBAsClB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAA;;;;AA1CH;;;;iBAuEgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAA;;;;;;;;;iBAgB9B,mBAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,aAAA,CAAc,SAAA;;;;;;;;AApDzB;iBA6FgB,aAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,OAAA,EAAS,mBAAA,EAAqB,KAAA,EAAO,iBAAA,GAAoB,YAAA;;;;;;;;AAhE3D;;;;;;;;;AAgBA;;;;iBAgHsB,aAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;;AAzE3B;;;;;iBAkKsB,OAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,SAAA"}
+{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;AAqEA;iBAAgB,WAAA,CACd,OAAA,EAAS,kBAAA,EACT,KAAA,EAAO,WAAW;;;;;;;;AAAA;AA8BpB;iBAAgB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,UAAA,EAAY,IAAA,GAAO,aAAA,CAAc,SAAA;;;;;;;;;;iBAiBnB,iBAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,MAAA,YAAkB,aAAA,CAAc,SAAA;;;;;;;;iBAsClB,sBAAA,CACd,KAAA,EAAO,iBAAA,GACN,mBAAmB;;;AA3DsB;AAiB5C;;;;iBAuEgB,cAAA,CAAe,KAAA,EAAO,WAAA,GAAc,kBAAkB;;;;;;;;;iBAgBhD,mBAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,KAAA,EAAO,iBAAA,EACP,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,aAAA,CAAc,SAAA;;;;;;;AA1FkB;AAsC3C;iBA6FgB,aAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CACpD,OAAA,EAAS,mBAAA,EAAqB,KAAA,EAAO,iBAAA,GAAoB,YAAA;;;;;;;AA7FrC;AA6BtB;;;;;;;;AAAsE;AAgBtE;;;;iBAgHsB,aAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,eAAA,CAAgB,SAAA;;;;;;;;;;;;;;;;;;;;;;;AAlHO;AAyClC;;;;;iBAoKsB,OAAA,mBACF,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,oBACnC,OAAA,GAAU,OAAA,CAAA,CAE3B,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,WAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,MAAA,CAAO,SAAA"}

package/dist/extract.mjs

@@ -1,14 +1,16 @@
+import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
 import { jsonSchemaToJtd } from "./jtd.mjs";
+import { getCacheDirectory, writeSchema } from "./persistence.mjs";
 import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve } from "./resolve.mjs";
-import { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
 import defu from "defu";
+import { isSetString } from "@stryke/type-checks";
 import { isTypeDefinition } from "@powerlines/core";
 import { esbuildPlugin } from "@powerlines/deepkit/esbuild-plugin";
 import { isType, stringifyType } from "@powerlines/deepkit/vendor/type";
 import { murmurhash } from "@stryke/hash";
 import { isJsonSchemaObjectType, isStandardJsonSchema } from "@stryke/json";
-import { isSetString } from "@stryke/type-checks";
+import { joinPaths } from "@stryke/path/join";
 import { isSetObject as isSetObject$1 } from "@stryke/type-checks/is-set-object";
 import { extractJsonSchema as extractJsonSchema$1, isZod3Type } from "@stryke/zod";
 
@@ -196,6 +198,7 @@ async function extractSchema(context, input, options = {}) {
 	};
 	let source;
 	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
 	if (variant === "type-definition") {
 		const resolved = await resolve(context, input, defu(options, { plugins: [esbuildPlugin(context, {
 			reflection: "default",
@@ -215,7 +218,7 @@ async function extractSchema(context, input, options = {}) {
 		variant,
 		source,
 		schema: await extractSchemaSchema(source.schema, source.variant),
-		hash: extractHash(variant, input)
+		hash
 	};
 }
 /**
@@ -247,7 +250,23 @@ async function extractSchema(context, input, options = {}) {
 * @returns A promise that resolves to a {@link Schema | schema} object parsed from the input.
 */
 async function extract(context, input, options = {}) {
-	return await extractSchema(context, input, options);
+	if (isExtractedSchema(input) || isSchema(input)) return input;
+	let result;
+	const variant = extractVariant(input);
+	const hash = extractHash(variant, input);
+	const cacheFilePath = joinPaths(getCacheDirectory(context), `${hash}.json`);
+	if (context.config.skipCache !== true && context.fs.existsSync(cacheFilePath)) {
+		const schema = await context.fs.read(cacheFilePath);
+		if (schema) result = {
+			variant,
+			hash,
+			schema: JSON.parse(schema)
+		};
+	}
+	result ??= await extractSchema(context, input, options);
+	if (!result?.schema) throw new Error(`Failed to extract a valid schema from the provided input. The input must be a Zod schema, a Standard JSON Schema, a JSON Schema object, a JTD schema, an untyped schema, or a reflected Deepkit Type object.`);
+	if (context.config.skipCache !== true) await writeSchema(context, result);
+	return result;
 }
 
 //#endregion