@powerlines/schema 0.8.67

package/dist/bundle.mjs

@@ -0,0 +1,46 @@
+import { createUnpluginResolver } from "@powerlines/core/lib/unplugin";
+import { resolveOptions } from "@powerlines/unplugin/esbuild";
+import { omit } from "@stryke/helpers/omit";
+import { findFileName } from "@stryke/path/file-path-fns";
+import defu from "defu";
+import { build } from "esbuild";
+import { createEsbuildPlugin } from "unplugin";
+
+//#region src/bundle.ts
+/**
+* Bundle a type definition to a module.
+*
+* @param context - The context object containing the environment paths.
+* @param file - The file path to bundle.
+* @param options - Optional overrides for the ESBuild configuration.
+* @returns A promise that resolves to the bundled module.
+*/
+async function bundle(context, file, options = {}) {
+	const path = await context.fs.resolve(file);
+	if (!path || !context.fs.existsSync(path)) throw new Error(`Module not found: "${file}". Please check the path and try again.`);
+	const result = await build(defu({
+		entryPoints: [path],
+		write: false,
+		sourcemap: false,
+		splitting: false,
+		treeShaking: true,
+		bundle: true,
+		packages: "bundle",
+		platform: "node",
+		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];
+}
+
+//#endregion
+export { bundle };
+//# sourceMappingURL=bundle.mjs.map

package/dist/bundle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.mjs","names":[],"sources":["../src/bundle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type {\n  CreateUnpluginResolverOptions,\n  PluginContext,\n  ResolveOptions\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 PluginContext = PluginContext>(\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"}

package/dist/extract.cjs

@@ -0,0 +1,116 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_is_schema_definition = require('./is-schema-definition.cjs');
+const require_reflection = require('./reflection.cjs');
+const require_resolve = require('./resolve.cjs');
+let defu = require("defu");
+defu = require_runtime.__toESM(defu, 1);
+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_json = require("@stryke/json");
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+let _stryke_zod = require("@stryke/zod");
+
+//#region src/extract.ts
+/**
+* Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
+*
+* @remarks
+* This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
+*
+* @param reflection - The reflected Deepkit Type to convert.
+* @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+*/
+function extractReflection(reflection) {
+	if (!(0, _powerlines_deepkit_vendor_type.isType)(reflection)) return;
+	return require_reflection.reflectionToJsonSchema(reflection);
+}
+/**
+* Extracts a JSON Schema object from a given schema definition, if possible.
+*
+* @remarks
+* This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+*
+* @param schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
+* @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+*/
+function extractJsonSchema(schema) {
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(schema) && ((0, _stryke_zod.isZod3Type)(schema) || (0, _stryke_json.isStandardJsonSchema)(schema) || (0, _stryke_json.isJsonSchema7ObjectType)(schema))) {
+		let jsonSchema;
+		if ((0, _stryke_zod.isZod3Type)(schema)) jsonSchema = (0, _stryke_zod.extractJsonSchema7)(schema);
+		else if ((0, _stryke_json.isStandardJsonSchema)(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+		else jsonSchema = schema;
+		if ((0, _stryke_json.isJsonSchema7ObjectType)(jsonSchema)) return jsonSchema;
+	}
+}
+/**
+* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+*
+* @param input - The input object to extract the schema definition from.
+* @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.
+* @throws An error if the input does not contain a valid schema definition.
+*/
+function extractSchema(input) {
+	if ((0, _stryke_type_checks_is_set_object.isSetObject)(input)) {
+		if ((0, _stryke_zod.isZod3Type)(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "zod3",
+				input
+			};
+		} else if ((0, _stryke_json.isStandardJsonSchema)(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "standard-schema",
+				input
+			};
+		} else if ((0, _stryke_json.isJsonSchema7ObjectType)(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "json-schema",
+				input
+			};
+		} else if ((0, _powerlines_deepkit_vendor_type.isType)(input)) {
+			const schema = extractReflection(input);
+			if (schema) return {
+				schema,
+				variant: "reflection",
+				input
+			};
+		}
+	}
+	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, or a reflected Deepkit Type object.`);
+}
+/**
+* Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+*
+* @example
+* ```ts
+* const schema = await extract(context, "./schemas/*.ts");
+* ```
+*
+* @param context - The plugin context used for resolving the schema definition input.
+* @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
+* @param options - Optional overrides for the ESBuild configuration used during resolution.
+* @returns A promise that resolves to a SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+*/
+async function extract(context, input, options = {}) {
+	if (require_is_schema_definition.isSchemaDefinition(input)) return input;
+	let inputObject = input;
+	if ((0, _stryke_type_checks.isSetString)(input) || (0, _powerlines_core.isTypeDefinition)(input)) inputObject = await require_resolve.resolve(context, input, (0, defu.default)(options, { plugins: [(0, _powerlines_deepkit_esbuild_plugin.esbuildPlugin)(context, {
+		reflection: "default",
+		level: "all"
+	})] }));
+	return extractSchema(inputObject);
+}
+
+//#endregion
+exports.extract = extract;
+exports.extractJsonSchema = extractJsonSchema;
+exports.extractReflection = extractReflection;
+exports.extractSchema = extractSchema;

package/dist/extract.d.cts

@@ -0,0 +1,52 @@
+import { SchemaDefinition, SchemaDefinitionInput, SchemaDefinitionParameter } from "./types.cjs";
+import { PluginContext } from "@powerlines/core";
+import { BuildOptions } from "esbuild";
+import { Type } from "@powerlines/deepkit/vendor/type";
+import { JsonSchema7Type } from "@stryke/json";
+
+//#region src/extract.d.ts
+/**
+ * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
+ *
+ * @remarks
+ * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
+ *
+ * @param reflection - The reflected Deepkit Type to convert.
+ * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+ */
+declare function extractReflection(reflection: Type): JsonSchema7Type | undefined;
+/**
+ * Extracts a JSON Schema object from a given schema definition, if possible.
+ *
+ * @remarks
+ * This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+ *
+ * @param schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
+ * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+ */
+declare function extractJsonSchema(schema: unknown): JsonSchema7Type | undefined;
+/**
+ * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+ *
+ * @param input - The input object to extract the schema definition from.
+ * @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.
+ * @throws An error if the input does not contain a valid schema definition.
+ */
+declare function extractSchema(input: SchemaDefinitionInput): SchemaDefinition;
+/**
+ * Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+ *
+ * @example
+ * ```ts
+ * const schema = await extract(context, "./schemas/*.ts");
+ * ```
+ *
+ * @param context - The plugin context used for resolving the schema definition input.
+ * @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
+ * @param options - Optional overrides for the ESBuild configuration used during resolution.
+ * @returns A promise that resolves to a SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+ */
+declare function extract<TContext extends PluginContext = PluginContext>(context: TContext, input: SchemaDefinitionParameter, options?: Partial<BuildOptions>): Promise<SchemaDefinition>;
+//#endregion
+export { extract, extractJsonSchema, extractReflection, extractSchema };
+//# sourceMappingURL=extract.d.cts.map

package/dist/extract.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.cts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;;AA+CA;;;;;;;iBAAgB,iBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;AAiBH;;;;;AAmCA;;;iBAnCgB,iBAAA,CACd,MAAA,YACC,eAAA;;;;;;AA4FH;;iBA3DgB,aAAA,CAAc,KAAA,EAAO,qBAAA,GAAwB,gBAAA;;;;;;;;;;;;;;iBA2DvC,OAAA,kBAAyB,aAAA,GAAgB,aAAA,CAAA,CAC7D,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,yBAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,gBAAA"}

package/dist/extract.d.mts

@@ -0,0 +1,52 @@
+import { SchemaDefinition, SchemaDefinitionInput, SchemaDefinitionParameter } from "./types.mjs";
+import { BuildOptions } from "esbuild";
+import { PluginContext } from "@powerlines/core";
+import { Type } from "@powerlines/deepkit/vendor/type";
+import { JsonSchema7Type } from "@stryke/json";
+
+//#region src/extract.d.ts
+/**
+ * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
+ *
+ * @remarks
+ * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
+ *
+ * @param reflection - The reflected Deepkit Type to convert.
+ * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+ */
+declare function extractReflection(reflection: Type): JsonSchema7Type | undefined;
+/**
+ * Extracts a JSON Schema object from a given schema definition, if possible.
+ *
+ * @remarks
+ * This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+ *
+ * @param schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
+ * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+ */
+declare function extractJsonSchema(schema: unknown): JsonSchema7Type | undefined;
+/**
+ * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+ *
+ * @param input - The input object to extract the schema definition from.
+ * @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.
+ * @throws An error if the input does not contain a valid schema definition.
+ */
+declare function extractSchema(input: SchemaDefinitionInput): SchemaDefinition;
+/**
+ * Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+ *
+ * @example
+ * ```ts
+ * const schema = await extract(context, "./schemas/*.ts");
+ * ```
+ *
+ * @param context - The plugin context used for resolving the schema definition input.
+ * @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
+ * @param options - Optional overrides for the ESBuild configuration used during resolution.
+ * @returns A promise that resolves to a SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+ */
+declare function extract<TContext extends PluginContext = PluginContext>(context: TContext, input: SchemaDefinitionParameter, options?: Partial<BuildOptions>): Promise<SchemaDefinition>;
+//#endregion
+export { extract, extractJsonSchema, extractReflection, extractSchema };
+//# sourceMappingURL=extract.d.mts.map

package/dist/extract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.mts","names":[],"sources":["../src/extract.ts"],"mappings":";;;;;;;;;AA+CA;;;;;;;iBAAgB,iBAAA,CACd,UAAA,EAAY,IAAA,GACX,eAAA;;AAiBH;;;;;AAmCA;;;iBAnCgB,iBAAA,CACd,MAAA,YACC,eAAA;;;;;;AA4FH;;iBA3DgB,aAAA,CAAc,KAAA,EAAO,qBAAA,GAAwB,gBAAA;;;;;;;;;;;;;;iBA2DvC,OAAA,kBAAyB,aAAA,GAAgB,aAAA,CAAA,CAC7D,OAAA,EAAS,QAAA,EACT,KAAA,EAAO,yBAAA,EACP,OAAA,GAAS,OAAA,CAAQ,YAAA,IAChB,OAAA,CAAQ,gBAAA"}

package/dist/extract.mjs

@@ -0,0 +1,111 @@
+import { isSchemaDefinition } from "./is-schema-definition.mjs";
+import { reflectionToJsonSchema } from "./reflection.mjs";
+import { resolve } from "./resolve.mjs";
+import defu from "defu";
+import { isTypeDefinition } from "@powerlines/core";
+import { esbuildPlugin } from "@powerlines/deepkit/esbuild-plugin";
+import { isType } from "@powerlines/deepkit/vendor/type";
+import { isJsonSchema7ObjectType, isStandardJsonSchema } from "@stryke/json";
+import { isSetString } from "@stryke/type-checks";
+import { isSetObject as isSetObject$1 } from "@stryke/type-checks/is-set-object";
+import { extractJsonSchema7, isZod3Type } from "@stryke/zod";
+
+//#region src/extract.ts
+/**
+* Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.
+*
+* @remarks
+* This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.
+*
+* @param reflection - The reflected Deepkit Type to convert.
+* @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.
+*/
+function extractReflection(reflection) {
+	if (!isType(reflection)) return;
+	return reflectionToJsonSchema(reflection);
+}
+/**
+* Extracts a JSON Schema object from a given schema definition, if possible.
+*
+* @remarks
+* This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.
+*
+* @param schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.
+* @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.
+*/
+function extractJsonSchema(schema) {
+	if (isSetObject$1(schema) && (isZod3Type(schema) || isStandardJsonSchema(schema) || isJsonSchema7ObjectType(schema))) {
+		let jsonSchema;
+		if (isZod3Type(schema)) jsonSchema = extractJsonSchema7(schema);
+		else if (isStandardJsonSchema(schema)) jsonSchema = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+		else jsonSchema = schema;
+		if (isJsonSchema7ObjectType(jsonSchema)) return jsonSchema;
+	}
+}
+/**
+* Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.
+*
+* @param input - The input object to extract the schema definition from.
+* @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.
+* @throws An error if the input does not contain a valid schema definition.
+*/
+function extractSchema(input) {
+	if (isSetObject$1(input)) {
+		if (isZod3Type(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "zod3",
+				input
+			};
+		} else if (isStandardJsonSchema(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "standard-schema",
+				input
+			};
+		} else if (isJsonSchema7ObjectType(input)) {
+			const schema = extractJsonSchema(input);
+			if (schema) return {
+				schema,
+				variant: "json-schema",
+				input
+			};
+		} else if (isType(input)) {
+			const schema = extractReflection(input);
+			if (schema) return {
+				schema,
+				variant: "reflection",
+				input
+			};
+		}
+	}
+	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, or a reflected Deepkit Type object.`);
+}
+/**
+* Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.
+*
+* @example
+* ```ts
+* const schema = await extract(context, "./schemas/*.ts");
+* ```
+*
+* @param context - The plugin context used for resolving the schema definition input.
+* @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.
+* @param options - Optional overrides for the ESBuild configuration used during resolution.
+* @returns A promise that resolves to a SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.
+*/
+async function extract(context, input, options = {}) {
+	if (isSchemaDefinition(input)) return input;
+	let inputObject = input;
+	if (isSetString(input) || isTypeDefinition(input)) inputObject = await resolve(context, input, defu(options, { plugins: [esbuildPlugin(context, {
+		reflection: "default",
+		level: "all"
+	})] }));
+	return extractSchema(inputObject);
+}
+
+//#endregion
+export { extract, extractJsonSchema, extractReflection, extractSchema };
+//# sourceMappingURL=extract.mjs.map

package/dist/extract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.mjs","names":["isSetObject"],"sources":["../src/extract.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 { PluginContext } from \"@powerlines/core\";\nimport { isTypeDefinition } from \"@powerlines/core\";\nimport { esbuildPlugin } from \"@powerlines/deepkit/esbuild-plugin\";\nimport { isType, Type } from \"@powerlines/deepkit/vendor/type\";\nimport type { JsonSchema7Type } from \"@stryke/json\";\nimport { isJsonSchema7ObjectType, isStandardJsonSchema } from \"@stryke/json\";\nimport { isSetString } from \"@stryke/type-checks\";\nimport { isSetObject } from \"@stryke/type-checks/is-set-object\";\nimport { extractJsonSchema7, isZod3Type } from \"@stryke/zod\";\nimport defu from \"defu\";\nimport type { BuildOptions } from \"esbuild\";\nimport { isSchemaDefinition } from \"./is-schema-definition\";\nimport { reflectionToJsonSchema } from \"./reflection\";\nimport { resolve } from \"./resolve\";\nimport {\n  SchemaDefinition,\n  SchemaDefinitionInput,\n  SchemaDefinitionParameter\n} from \"./types\";\n\n/**\n * Converts a reflected Deepkit {@link @powerlines/deepkit/vendor/type#Type} into a JSON Schema (draft-07) representation.\n *\n * @remarks\n * This function delegates to an internal recursive walker that handles the full set of Deepkit reflection kinds.\n *\n * @param reflection - The reflected Deepkit Type to convert.\n * @returns A JSON Schema (draft-07) fragment representing the type, or `undefined` when no schema could be produced.\n */\nexport function extractReflection(\n  reflection: Type\n): JsonSchema7Type | undefined {\n  if (!isType(reflection)) {\n    return undefined;\n  }\n\n  return reflectionToJsonSchema(reflection);\n}\n\n/**\n * Extracts a JSON Schema object from a given schema definition, if possible.\n *\n * @remarks\n * This function checks if the provided schema is a Zod schema, a Standard JSON Schema, or already a JSON Schema object. If it is a Zod schema, it extracts the corresponding JSON Schema. If it is a Standard JSON Schema, it retrieves the input JSON Schema targeting draft-07. Finally, it checks if the resulting JSON Schema is an object type and returns it if so.\n *\n * @param schema - The schema definition to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, or a JSON Schema object.\n * @returns The extracted JSON Schema (draft-07) object if successful, otherwise undefined.\n */\nexport function extractJsonSchema(\n  schema: unknown\n): JsonSchema7Type | undefined {\n  if (\n    isSetObject(schema) &&\n    (isZod3Type(schema) ||\n      isStandardJsonSchema(schema) ||\n      isJsonSchema7ObjectType(schema))\n  ) {\n    let jsonSchema: JsonSchema7Type;\n    if (isZod3Type(schema)) {\n      jsonSchema = extractJsonSchema7(schema);\n    } else if (isStandardJsonSchema(schema)) {\n      jsonSchema = schema[\"~standard\"].jsonSchema.input({\n        target: \"draft-07\"\n      });\n    } else {\n      jsonSchema = schema;\n    }\n\n    if (isJsonSchema7ObjectType(jsonSchema)) {\n      return jsonSchema;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Extracts a schema definition from a given input object, which can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a reflected Deepkit Type object. The function checks the type of the input and attempts to extract the corresponding schema based on its variant. If the input is a Zod schema, it extracts the JSON Schema using the `extractJsonSchema` function. If the input is a Standard JSON Schema, it retrieves the JSON Schema targeting draft-07. If the input is already a JSON Schema object, it uses it directly. If the input is a reflected Deepkit Type object, it extracts the schema using the `extractReflection` function. The function returns a `SchemaDefinition` containing the extracted schema and its variant if successful; otherwise, it throws an error.\n *\n * @param input - The input object to extract the schema definition from.\n * @returns A `SchemaDefinition` containing the extracted schema and its variant if successful.\n * @throws An error if the input does not contain a valid schema definition.\n */\nexport function extractSchema(input: SchemaDefinitionInput): SchemaDefinition {\n  if (isSetObject(input)) {\n    if (isZod3Type(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"zod3\",\n          input\n        };\n      }\n    } else if (isStandardJsonSchema(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"standard-schema\",\n          input\n        };\n      }\n    } else if (isJsonSchema7ObjectType(input)) {\n      const schema = extractJsonSchema(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"json-schema\",\n          input\n        };\n      }\n    } else if (isType(input)) {\n      const schema = extractReflection(input);\n      if (schema) {\n        return {\n          schema,\n          variant: \"reflection\",\n          input\n        };\n      }\n    }\n  }\n\n  throw new Error(\n    `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, or a reflected Deepkit Type object.`\n  );\n}\n\n/**\n * Resolves the provided entry points to their corresponding type definitions. The function accepts an array of entry points, which can be strings (file paths) or type definition objects. It processes each entry point, resolving file paths and glob patterns to find matching files. For each resolved file, it creates a type definition object and resolves it using the `resolveInput` function. The function returns an array of resolved entry type definitions.\n *\n * @example\n * ```ts\n * const schema = await extract(context, \"./schemas/*.ts\");\n * ```\n *\n * @param context - The plugin context used for resolving the schema definition input.\n * @param input - The schema definition input to extract the JSON Schema from. This can be a Zod schema, a Standard JSON Schema, a JSON Schema object, or a TypeScript type definition.\n * @param options - Optional overrides for the ESBuild configuration used during resolution.\n * @returns A promise that resolves to a SchemaDefinition containing the extracted JSON Schema and its variant, or the bytecode if JSON Schema extraction is not possible.\n */\nexport async function extract<TContext extends PluginContext = PluginContext>(\n  context: TContext,\n  input: SchemaDefinitionParameter,\n  options: Partial<BuildOptions> = {}\n): Promise<SchemaDefinition> {\n  if (isSchemaDefinition(input)) {\n    return input;\n  }\n\n  let inputObject = input as SchemaDefinitionInput;\n  if (isSetString(input) || isTypeDefinition(input)) {\n    inputObject = await resolve<SchemaDefinitionInput>(\n      context,\n      input,\n      defu(options, {\n        plugins: [\n          esbuildPlugin(context, {\n            reflection: \"default\",\n            level: \"all\"\n          })\n        ]\n      })\n    );\n  }\n\n  return extractSchema(inputObject);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,kBACd,YAC6B;AAC7B,KAAI,CAAC,OAAO,WAAW,CACrB;AAGF,QAAO,uBAAuB,WAAW;;;;;;;;;;;AAY3C,SAAgB,kBACd,QAC6B;AAC7B,KACEA,cAAY,OAAO,KAClB,WAAW,OAAO,IACjB,qBAAqB,OAAO,IAC5B,wBAAwB,OAAO,GACjC;EACA,IAAI;AACJ,MAAI,WAAW,OAAO,CACpB,cAAa,mBAAmB,OAAO;WAC9B,qBAAqB,OAAO,CACrC,cAAa,OAAO,aAAa,WAAW,MAAM,EAChD,QAAQ,YACT,CAAC;MAEF,cAAa;AAGf,MAAI,wBAAwB,WAAW,CACrC,QAAO;;;;;;;;;;AAcb,SAAgB,cAAc,OAAgD;AAC5E,KAAIA,cAAY,MAAM,EACpB;MAAI,WAAW,MAAM,EAAE;GACrB,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,qBAAqB,MAAM,EAAE;GACtC,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,wBAAwB,MAAM,EAAE;GACzC,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;aAEM,OAAO,MAAM,EAAE;GACxB,MAAM,SAAS,kBAAkB,MAAM;AACvC,OAAI,OACF,QAAO;IACL;IACA,SAAS;IACT;IACD;;;AAKP,OAAM,IAAI,MACR,8KACD;;;;;;;;;;;;;;;AAgBH,eAAsB,QACpB,SACA,OACA,UAAiC,EAAE,EACR;AAC3B,KAAI,mBAAmB,MAAM,CAC3B,QAAO;CAGT,IAAI,cAAc;AAClB,KAAI,YAAY,MAAM,IAAI,iBAAiB,MAAM,CAC/C,eAAc,MAAM,QAClB,SACA,OACA,KAAK,SAAS,EACZ,SAAS,CACP,cAAc,SAAS;EACrB,YAAY;EACZ,OAAO;EACR,CAAC,CACH,EACF,CAAC,CACH;AAGH,QAAO,cAAc,YAAY"}

package/dist/index.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_bundle = require('./bundle.cjs');
+const require_is_schema_definition = require('./is-schema-definition.cjs');
+const require_reflection = require('./reflection.cjs');
+const require_resolve = require('./resolve.cjs');
+const require_extract = require('./extract.cjs');
+
+exports.bundle = require_bundle.bundle;
+exports.extract = require_extract.extract;
+exports.extractJsonSchema = require_extract.extractJsonSchema;
+exports.extractReflection = require_extract.extractReflection;
+exports.extractSchema = require_extract.extractSchema;
+exports.isSchemaDefinition = require_is_schema_definition.isSchemaDefinition;
+exports.objectReflectionToJsonSchema = require_reflection.objectReflectionToJsonSchema;
+exports.reflectionToJsonSchema = require_reflection.reflectionToJsonSchema;
+exports.resolve = require_resolve.resolve;
+exports.resolveModule = require_resolve.resolveModule;
+exports.resolveReflection = require_resolve.resolveReflection;

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+import { BundleOptions, bundle } from "./bundle.cjs";
+import { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 } from "./types.cjs";
+import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.cjs";
+import { isSchemaDefinition } from "./is-schema-definition.cjs";
+import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.cjs";
+import { resolve, resolveModule, resolveReflection } from "./resolve.cjs";
+export { BundleOptions, SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3, bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { BundleOptions, bundle } from "./bundle.mjs";
+import { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 } from "./types.mjs";
+import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.mjs";
+import { isSchemaDefinition } from "./is-schema-definition.mjs";
+import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.mjs";
+import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
+export { BundleOptions, SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3, bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import { bundle } from "./bundle.mjs";
+import { isSchemaDefinition } from "./is-schema-definition.mjs";
+import { objectReflectionToJsonSchema, reflectionToJsonSchema } from "./reflection.mjs";
+import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
+import { extract, extractJsonSchema, extractReflection, extractSchema } from "./extract.mjs";
+
+export { bundle, extract, extractJsonSchema, extractReflection, extractSchema, isSchemaDefinition, objectReflectionToJsonSchema, reflectionToJsonSchema, resolve, resolveModule, resolveReflection };

package/dist/is-schema-definition.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_json_schema = require("@stryke/json/schema");
+
+//#region src/is-schema-definition.ts
+/**
+* Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a `SchemaDefinition`.
+* @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
+*/
+function isSchemaDefinition(input) {
+	return (0, _stryke_type_checks.isSetObject)(input) && "schema" in input && (0, _stryke_json_schema.isJsonSchema7ObjectType)(input.schema) && "input" in input && (0, _stryke_type_checks.isSetObject)(input.input) && "variant" in input && (input.variant === "json-schema" || input.variant === "standard-schema" || input.variant === "zod3" || input.variant === "reflection");
+}
+
+//#endregion
+exports.isSchemaDefinition = isSchemaDefinition;

package/dist/is-schema-definition.d.cts

@@ -0,0 +1,13 @@
+import { SchemaDefinition } from "./types.cjs";
+
+//#region src/is-schema-definition.d.ts
+/**
+ * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a `SchemaDefinition`.
+ * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
+ */
+declare function isSchemaDefinition(input: unknown): input is SchemaDefinition;
+//#endregion
+export { isSchemaDefinition };
+//# sourceMappingURL=is-schema-definition.d.cts.map

package/dist/is-schema-definition.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-schema-definition.d.cts","names":[],"sources":["../src/is-schema-definition.ts"],"mappings":";;;;;AA4BA;;;;iBAAgB,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,gBAAA"}

package/dist/is-schema-definition.d.mts

@@ -0,0 +1,13 @@
+import { SchemaDefinition } from "./types.mjs";
+
+//#region src/is-schema-definition.d.ts
+/**
+ * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
+ *
+ * @param input - The input to check for being a `SchemaDefinition`.
+ * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
+ */
+declare function isSchemaDefinition(input: unknown): input is SchemaDefinition;
+//#endregion
+export { isSchemaDefinition };
+//# sourceMappingURL=is-schema-definition.d.mts.map

package/dist/is-schema-definition.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-schema-definition.d.mts","names":[],"sources":["../src/is-schema-definition.ts"],"mappings":";;;;;AA4BA;;;;iBAAgB,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,gBAAA"}

package/dist/is-schema-definition.mjs

@@ -0,0 +1,17 @@
+import { isSetObject } from "@stryke/type-checks";
+import { isJsonSchema7ObjectType } from "@stryke/json/schema";
+
+//#region src/is-schema-definition.ts
+/**
+* Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
+*
+* @param input - The input to check for being a `SchemaDefinition`.
+* @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
+*/
+function isSchemaDefinition(input) {
+	return isSetObject(input) && "schema" in input && isJsonSchema7ObjectType(input.schema) && "input" in input && isSetObject(input.input) && "variant" in input && (input.variant === "json-schema" || input.variant === "standard-schema" || input.variant === "zod3" || input.variant === "reflection");
+}
+
+//#endregion
+export { isSchemaDefinition };
+//# sourceMappingURL=is-schema-definition.mjs.map

package/dist/is-schema-definition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-schema-definition.mjs","names":[],"sources":["../src/is-schema-definition.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 { isJsonSchema7ObjectType } from \"@stryke/json/schema\";\nimport { isSetObject } from \"@stryke/type-checks\";\nimport { SchemaDefinition } from \"./types\";\n\n/**\n * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants (\"json-schema\", \"standard-schema\", \"zod3\", or \"reflection\"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a `SchemaDefinition`.\n * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.\n */\nexport function isSchemaDefinition(input: unknown): input is SchemaDefinition {\n  return (\n    isSetObject(input) &&\n    \"schema\" in input &&\n    isJsonSchema7ObjectType(input.schema) &&\n    \"input\" in input &&\n    isSetObject(input.input) &&\n    \"variant\" in input &&\n    (input.variant === \"json-schema\" ||\n      input.variant === \"standard-schema\" ||\n      input.variant === \"zod3\" ||\n      input.variant === \"reflection\")\n  );\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,YAAY,MAAM,IAClB,YAAY,SACZ,wBAAwB,MAAM,OAAO,IACrC,WAAW,SACX,YAAY,MAAM,MAAM,IACxB,aAAa,UACZ,MAAM,YAAY,iBACjB,MAAM,YAAY,qBAClB,MAAM,YAAY,UAClB,MAAM,YAAY"}