@powerlines/schema 0.11.27 → 0.11.37

package/dist/bundle.cjs

@@ -1,12 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 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 _powerlines_unplugin_rolldown = require("@powerlines/unplugin/rolldown");
+let _stryke_convert_to_array = require("@stryke/convert/to-array");
 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 rolldown = require("rolldown");
 let unplugin = require("unplugin");
 
 //#region src/bundle.ts
@@ -21,27 +22,40 @@ let unplugin = require("unplugin");
 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)({
-		entryPoints: [path],
-		write: false,
-		sourcemap: false,
-		splitting: false,
-		treeShaking: true,
+	const userOptions = (0, _stryke_helpers_omit.omit)(options, [
+		"name",
+		"resolve",
+		"plugins"
+	]);
+	const plugins = await Promise.resolve(options.plugins);
+	const result = await (0, rolldown.build)({
 		bundle: true,
-		packages: "bundle",
 		platform: "node",
+		...(0, _powerlines_unplugin_rolldown.resolveOptions)(context),
+		...userOptions,
 		logLevel: "silent",
-		...(0, _stryke_helpers_omit.omit)(options, ["name", "resolve"])
-	}, (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 }, context.config.resolve),
-		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];
+		output: {
+			dir: context.config.output.path,
+			format: "es",
+			sourcemap: false,
+			codeSplitting: false,
+			minify: false,
+			keepNames: true,
+			exports: "named",
+			...userOptions.output
+		},
+		input: [path],
+		write: false,
+		plugins: [...plugins ? (0, _stryke_convert_to_array.toArray)(plugins) : [], (0, unplugin.createRolldownPlugin)((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 }, context.config.resolve),
+			silenceHookLogging: true
+		}))()].filter(Boolean)
+	});
+	if (!result.output || result.output.length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	if (result.output.length > 1) context.warn(`Multiple output files generated for "${file}". Only the first file will be used. Please check the configuration to ensure only one output file is generated.`);
+	return result.output[0];
 }
 
 //#endregion

package/dist/bundle.d.cts

@@ -1,9 +1,9 @@
 import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
 import { DeepPartial } from "@stryke/types/base";
-import { BuildOptions, OutputFile } from "esbuild";
+import { BuildOptions, OutputChunk } from "rolldown";
 
 //#region src/bundle.d.ts
-type BundleOptions = DeepPartial<BuildOptions> & {
+type BundleOptions = DeepPartial<Omit<BuildOptions, "input" | "write">> & {
   name?: string;
   resolve?: DeepPartial<ResolveOptions>;
 };
@@ -15,7 +15,7 @@ type BundleOptions = DeepPartial<BuildOptions> & {
  * @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>;
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputChunk>;
 //#endregion
 export { BundleOptions, bundle };
 //# sourceMappingURL=bundle.d.cts.map

package/dist/bundle.d.cts.map

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

package/dist/bundle.d.mts

@@ -1,9 +1,9 @@
-import { BuildOptions, OutputFile } from "esbuild";
+import { BuildOptions, OutputChunk } from "rolldown";
 import { ResolveOptions, UnresolvedContext } from "@powerlines/core";
 import { DeepPartial } from "@stryke/types/base";
 
 //#region src/bundle.d.ts
-type BundleOptions = DeepPartial<BuildOptions> & {
+type BundleOptions = DeepPartial<Omit<BuildOptions, "input" | "write">> & {
   name?: string;
   resolve?: DeepPartial<ResolveOptions>;
 };
@@ -15,7 +15,7 @@ type BundleOptions = DeepPartial<BuildOptions> & {
  * @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>;
+declare function bundle<TContext extends UnresolvedContext>(context: TContext, file: string, options?: BundleOptions): Promise<OutputChunk>;
 //#endregion
 export { BundleOptions, bundle };
 //# sourceMappingURL=bundle.d.mts.map

package/dist/bundle.d.mts.map

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

package/dist/bundle.mjs

@@ -1,10 +1,11 @@
 import { createUnpluginResolver } from "@powerlines/core/lib/unplugin";
-import { resolveOptions } from "@powerlines/unplugin/esbuild";
+import { resolveOptions } from "@powerlines/unplugin/rolldown";
+import { toArray } from "@stryke/convert/to-array";
 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";
+import { build } from "rolldown";
+import { createRolldownPlugin } from "unplugin";
 
 //#region src/bundle.ts
 /**
@@ -18,27 +19,40 @@ import { createEsbuildPlugin } from "unplugin";
 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({
-		entryPoints: [path],
-		write: false,
-		sourcemap: false,
-		splitting: false,
-		treeShaking: true,
+	const userOptions = omit(options, [
+		"name",
+		"resolve",
+		"plugins"
+	]);
+	const plugins = await Promise.resolve(options.plugins);
+	const result = await build({
 		bundle: true,
-		packages: "bundle",
 		platform: "node",
+		...resolveOptions(context),
+		...userOptions,
 		logLevel: "silent",
-		...omit(options, ["name", "resolve"])
-	}, resolveOptions(context), { plugins: [createEsbuildPlugin(createUnpluginResolver(context, {
-		name: options.name ?? `${findFileName(file)} Bundler`,
-		prefix: false,
-		overrides: defu(options.resolve ?? {}, { skipNodeModulesBundle: false }, context.config.resolve),
-		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];
+		output: {
+			dir: context.config.output.path,
+			format: "es",
+			sourcemap: false,
+			codeSplitting: false,
+			minify: false,
+			keepNames: true,
+			exports: "named",
+			...userOptions.output
+		},
+		input: [path],
+		write: false,
+		plugins: [...plugins ? toArray(plugins) : [], createRolldownPlugin(createUnpluginResolver(context, {
+			name: options.name ?? `${findFileName(file)} Bundler`,
+			prefix: false,
+			overrides: defu(options.resolve ?? {}, { skipNodeModulesBundle: false }, context.config.resolve),
+			silenceHookLogging: true
+		}))()].filter(Boolean)
+	});
+	if (!result.output || result.output.length === 0) throw new Error(`No output files generated for ${file}. Please check the configuration and try again.`);
+	if (result.output.length > 1) context.warn(`Multiple output files generated for "${file}". Only the first file will be used. Please check the configuration to ensure only one output file is generated.`);
+	return result.output[0];
 }
 
 //#endregion

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,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"}
+{"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/rolldown\";\nimport { toArray } from \"@stryke/convert/to-array\";\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, OutputChunk } from \"rolldown\";\nimport { build } from \"rolldown\";\nimport { createRolldownPlugin } from \"unplugin\";\n\nexport type BundleOptions = DeepPartial<\n  Omit<BuildOptions, \"input\" | \"write\">\n> & {\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<OutputChunk> {\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 userOptions = omit(options, [\"name\", \"resolve\", \"plugins\"]);\n  const plugins = await Promise.resolve(options.plugins);\n\n  const resolvedOptions = resolveOptions(context);\n\n  const result = await build({\n    bundle: true,\n    platform: \"node\",\n    ...resolvedOptions,\n    ...userOptions,\n    logLevel: \"silent\",\n    output: {\n      dir: context.config.output.path,\n      format: \"es\",\n      sourcemap: false,\n      codeSplitting: false,\n      minify: false,\n      keepNames: true,\n      exports: \"named\",\n      ...userOptions.output\n    },\n    input: [path],\n    write: false,\n    plugins: [\n      ...(plugins ? toArray(plugins) : []),\n      createRolldownPlugin(\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    ].filter(Boolean)\n  } as BuildOptions);\n  if (!result.output || result.output.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  if (result.output.length > 1) {\n    context.warn(\n      `Multiple output files generated for \"${\n        file\n      }\". Only the first file will be used. Please check the configuration to ensure only one output file is generated.`\n    );\n  }\n\n  return result.output[0];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiDA,eAAsB,OACpB,SACA,MACA,UAAyB,CAAC,GACJ;CACtB,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,cAAc,KAAK,SAAS;EAAC;EAAQ;EAAW;CAAS,CAAC;CAChE,MAAM,UAAU,MAAM,QAAQ,QAAQ,QAAQ,OAAO;CAIrD,MAAM,SAAS,MAAM,MAAM;EACzB,QAAQ;EACR,UAAU;EACV,GALsB,eAAe,OAKpB;EACjB,GAAG;EACH,UAAU;EACV,QAAQ;GACN,KAAK,QAAQ,OAAO,OAAO;GAC3B,QAAQ;GACR,WAAW;GACX,eAAe;GACf,QAAQ;GACR,WAAW;GACX,SAAS;GACT,GAAG,YAAY;EACjB;EACA,OAAO,CAAC,IAAI;EACZ,OAAO;EACP,SAAS,CACP,GAAI,UAAU,QAAQ,OAAO,IAAI,CAAC,GAClC,qBACE,uBAAuB,SAAS;GAC9B,MAAM,QAAQ,QAAQ,GAAG,aAAa,IAAI,EAAE;GAC5C,QAAQ;GACR,WAAW,KACT,QAAQ,WAAW,CAAC,GACpB,EAAE,uBAAuB,MAAM,GAC/B,QAAQ,OAAO,OACjB;GACA,oBAAoB;EACtB,CAAC,CACH,EAAE,CACJ,EAAE,OAAO,OAAO;CAClB,CAAiB;CACjB,IAAI,CAAC,OAAO,UAAU,OAAO,OAAO,WAAW,GAC7C,MAAM,IAAI,MACR,iCACE,KACD,gDACH;CAEF,IAAI,OAAO,OAAO,SAAS,GACzB,QAAQ,KACN,wCACE,KACD,iHACH;CAGF,OAAO,OAAO,OAAO;AACvB"}

package/dist/codegen.cjs

@@ -1,70 +1,74 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 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');
 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_set_string = require("@stryke/type-checks/is-set-string");
 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);
+let ajv = require("ajv");
+ajv = require_runtime.__toESM(ajv, 1);
+let ajv_formats_dist_formats_js = require("ajv-formats/dist/formats.js");
+let ajv_dist_compile_codegen_index_js = require("ajv/dist/compile/codegen/index.js");
+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 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.
+* 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 && 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);
+	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() : JSON.stringify(value);
 }
 /**
-* 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.
+* Stringifies a JSON Schema fragment into a TypeScript-like type string.
 */
 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";
+	if ((0, _stryke_type_checks_is_set_string.isSetString)(schema.$ref)) return /^#\/(?:definitions|\$defs)\/(.+)$/.exec(schema.$ref)?.[1] ?? schema.$ref;
+	const primaryType = require_metadata.getPrimarySchemaType(schema);
+	if (primaryType) {
+		if (primaryType === "integer" || primaryType === "number") return "number";
+		return primaryType;
+	}
+	if (Array.isArray(schema.enum)) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if (schema.const !== void 0) return JSON.stringify(schema.const);
+	if (schema.type === "array" || schema.items) return `${stringifyType(Array.isArray(schema.items) ? schema.items[0] : schema.items)}[]`;
+	if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object") return `{ [key: string]: ${stringifyType(schema.additionalProperties)} }`;
+		if (require_type_checks.isJsonSchemaObject(schema)) return `{ ${require_helpers.getPropertiesList(schema).map((property) => {
+			const suffix = property.optional || property.nullable ? `${property.optional ? "?" : ""}${property.nullable ? " | null" : ""}` : "";
+			return `${property.key}${suffix}: ${stringifyType(property.value)}`;
+		}).join(";\n")} }`;
+	}
+	if (schema.oneOf || schema.anyOf) return (schema.oneOf ?? schema.anyOf ?? []).map((branch) => stringifyType(branch)).join(" | ");
+	if (schema.allOf) 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.
-* @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.
-* @returns A promise that resolves to a string containing the generated standalone validation code.
+* Generates standalone JSON Schema validation code using Ajv.
 */
 async function generateCode(schemas, refsOrFuncts) {
-	return (0, ajv_lib_standalone_index_ts.default)(new ajv_lib_jtd_ts.default({
+	const ajv$1 = new ajv.default({
 		schemas,
 		code: {
 			source: true,
 			esm: true
 		}
-	}), refsOrFuncts);
+	});
+	ajv$1.opts.code.formats ??= ajv_dist_compile_codegen_index_js._`await import("ajv-formats/dist/formats").${new ajv_dist_compile_codegen_index_js.Name("fullFormats")}`;
+	for (const formatName of ajv_formats_dist_formats_js.formatNames) ajv$1.addFormat(formatName, ajv_formats_dist_formats_js.fullFormats[formatName]);
+	return (0, ajv_dist_standalone_index_js.default)(ajv$1, refsOrFuncts);
+}
+function isNullableSchema(schema) {
+	return require_metadata.isSchemaNullable(schema);
 }
 
 //#endregion
 exports.generateCode = generateCode;
+exports.isNullableSchema = isNullableSchema;
 exports.stringifyType = stringifyType;
 exports.stringifyValue = stringifyValue;

package/dist/codegen.d.cts

@@ -1,33 +1,21 @@
-import { JTDSchemaType, JTDType } from "./types.cjs";
-import { Options } from "ajv/lib/jtd.ts";
-import standaloneCode from "ajv/lib/standalone/index.ts";
+import { JsonSchema, JsonSchemaPrimitiveType } from "./types.cjs";
+import { Options } from "ajv";
+import standaloneCode from "ajv/dist/standalone/index.js";
 
 //#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.
+ * Stringifies a value for generated TypeScript code.
  */
-declare function stringifyValue(value?: unknown, type?: JTDType): string;
+declare function stringifyValue(value?: unknown, type?: JsonSchemaPrimitiveType | string): 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.
+ * Stringifies a JSON Schema fragment into a TypeScript-like type string.
  */
-declare function stringifyType(schema?: JTDSchemaType): string;
+declare function stringifyType<T = unknown>(schema?: JsonSchema<T>): 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.
- *
- * @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.
- * @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.
- * @returns A promise that resolves to a string containing the generated standalone validation code.
+ * Generates standalone JSON Schema validation code using Ajv.
  */
 declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
+declare function isNullableSchema(schema?: JsonSchema): boolean;
 //#endregion
-export { generateCode, stringifyType, stringifyValue };
+export { generateCode, isNullableSchema, 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":";;;;;;;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"}
+{"version":3,"file":"codegen.d.cts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;;AAqCA;iBAAgB,cAAA,CACd,KAAA,YACA,IAAA,GAAO,uBAAuB;;;;iBAoBhB,aAAA,aAAA,CAA2B,MAAA,GAAS,UAAU,CAAC,CAAA;;;AApBtB;iBAgGnB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA;AAAA,iBAiBrC,gBAAA,CAAiB,MAAmB,GAAV,UAAU"}

package/dist/codegen.d.mts

@@ -1,33 +1,21 @@
-import { JTDSchemaType, JTDType } from "./types.mjs";
-import { Options } from "ajv/lib/jtd.ts";
-import standaloneCode from "ajv/lib/standalone/index.ts";
+import { JsonSchema, JsonSchemaPrimitiveType } from "./types.mjs";
+import { Options } from "ajv";
+import standaloneCode from "ajv/dist/standalone/index.js";
 
 //#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.
+ * Stringifies a value for generated TypeScript code.
  */
-declare function stringifyValue(value?: unknown, type?: JTDType): string;
+declare function stringifyValue(value?: unknown, type?: JsonSchemaPrimitiveType | string): 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.
+ * Stringifies a JSON Schema fragment into a TypeScript-like type string.
  */
-declare function stringifyType(schema?: JTDSchemaType): string;
+declare function stringifyType<T = unknown>(schema?: JsonSchema<T>): 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.
- *
- * @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.
- * @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.
- * @returns A promise that resolves to a string containing the generated standalone validation code.
+ * Generates standalone JSON Schema validation code using Ajv.
  */
 declare function generateCode(schemas: Options["schemas"], refsOrFuncts?: Parameters<typeof standaloneCode>[1]): Promise<string>;
+declare function isNullableSchema(schema?: JsonSchema): boolean;
 //#endregion
-export { generateCode, stringifyType, stringifyValue };
+export { generateCode, isNullableSchema, 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":";;;;;;;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"}
+{"version":3,"file":"codegen.d.mts","names":[],"sources":["../src/codegen.ts"],"mappings":";;;;;;;AAqCA;iBAAgB,cAAA,CACd,KAAA,YACA,IAAA,GAAO,uBAAuB;;;;iBAoBhB,aAAA,aAAA,CAA2B,MAAA,GAAS,UAAU,CAAC,CAAA;;;AApBtB;iBAgGnB,YAAA,CACpB,OAAA,EAAS,OAAA,aACT,YAAA,GAAe,UAAA,QAAkB,cAAA,OAAkB,OAAA;AAAA,iBAiBrC,gBAAA,CAAiB,MAAmB,GAAV,UAAU"}

package/dist/codegen.mjs

@@ -1,65 +1,68 @@
-import { getProperties } from "./helpers.mjs";
+import { getPrimarySchemaType, isSchemaNullable } from "./metadata.mjs";
+import { isJsonSchemaObject } from "./type-checks.mjs";
+import { getPropertiesList } 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 { isSetString } from "@stryke/type-checks/is-set-string";
 import { isUndefined } from "@stryke/type-checks/is-undefined";
-import Ajv from "ajv/lib/jtd.ts";
-import standaloneCode from "ajv/lib/standalone/index.ts";
+import Ajv from "ajv";
+import { formatNames, fullFormats } from "ajv-formats/dist/formats.js";
+import { Name, _ } from "ajv/dist/compile/codegen/index.js";
+import standaloneCode from "ajv/dist/standalone/index.js";
 
 //#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.
+* Stringifies a value for generated TypeScript code.
 */
 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);
+	return isUndefined(value) ? "undefined" : isNull(value) ? "null" : type === "boolean" || isBoolean(value) ? String(toBool(value)) : type === "number" || isNumber(value) ? Number.parseFloat(String(value)).toLocaleString(void 0, { maximumFractionDigits: 20 }) : type === "integer" ? Number.parseInt(String(value)).toLocaleString() : JSON.stringify(value);
 }
 /**
-* 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.
+* Stringifies a JSON Schema fragment into a TypeScript-like type string.
 */
 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";
+	if (isSetString(schema.$ref)) return /^#\/(?:definitions|\$defs)\/(.+)$/.exec(schema.$ref)?.[1] ?? schema.$ref;
+	const primaryType = getPrimarySchemaType(schema);
+	if (primaryType) {
+		if (primaryType === "integer" || primaryType === "number") return "number";
+		return primaryType;
+	}
+	if (Array.isArray(schema.enum)) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+	if (schema.const !== void 0) return JSON.stringify(schema.const);
+	if (schema.type === "array" || schema.items) return `${stringifyType(Array.isArray(schema.items) ? schema.items[0] : schema.items)}[]`;
+	if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+		if (schema.additionalProperties && typeof schema.additionalProperties === "object") return `{ [key: string]: ${stringifyType(schema.additionalProperties)} }`;
+		if (isJsonSchemaObject(schema)) return `{ ${getPropertiesList(schema).map((property) => {
+			const suffix = property.optional || property.nullable ? `${property.optional ? "?" : ""}${property.nullable ? " | null" : ""}` : "";
+			return `${property.key}${suffix}: ${stringifyType(property.value)}`;
+		}).join(";\n")} }`;
+	}
+	if (schema.oneOf || schema.anyOf) return (schema.oneOf ?? schema.anyOf ?? []).map((branch) => stringifyType(branch)).join(" | ");
+	if (schema.allOf) 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.
-* @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.
-* @returns A promise that resolves to a string containing the generated standalone validation code.
+* Generates standalone JSON Schema validation code using Ajv.
 */
 async function generateCode(schemas, refsOrFuncts) {
-	return standaloneCode(new Ajv({
+	const ajv = new Ajv({
 		schemas,
 		code: {
 			source: true,
 			esm: true
 		}
-	}), refsOrFuncts);
+	});
+	ajv.opts.code.formats ??= _`await import("ajv-formats/dist/formats").${new Name("fullFormats")}`;
+	for (const formatName of formatNames) ajv.addFormat(formatName, fullFormats[formatName]);
+	return standaloneCode(ajv, refsOrFuncts);
+}
+function isNullableSchema(schema) {
+	return isSchemaNullable(schema);
 }
 
 //#endregion
-export { generateCode, stringifyType, stringifyValue };
+export { generateCode, isNullableSchema, stringifyType, stringifyValue };
 //# sourceMappingURL=codegen.mjs.map