@powerlines/schema 0.11.27 → 0.11.37

package/dist/helpers.d.cts

@@ -1,44 +1,48 @@
-import { JTDSchemaObjectType, JTDSchemaType, ObjectSchema, SchemaMetadata } from "./types.cjs";
+import { JsonSchema, JsonSchemaProperty, Schema } from "./types.cjs";
 
 //#region src/helpers.d.ts
 /**
- * A helper function to extract the properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns a record of its properties, where each key is the property name and the value is the corresponding JTD schema type along with an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function checks both `properties` and `optionalProperties` of the JTD schema to construct the resulting record.
+ * Extracts object properties from a JSON Schema object form.
  *
- * @param obj - The {@link ObjectSchema} from which to extract the properties.
- * @returns A record of the properties defined in the JTD object schema, where each key is the property name and the value is an object containing the JTD schema type and an `optional` flag.
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
  */
-declare function getProperties<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>): Record<string, JTDSchemaType<TMetadata> & {
-  name: string;
-  optional: boolean;
-}>;
+declare function getProperties<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>): Record<string, JsonSchemaProperty<T>>;
 /**
- * A helper function to get a list of properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns an array of its properties, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function utilizes the `getProperties` helper function to first retrieve the properties as a record and then converts that record into an array format for easier iteration and access.
+ * Returns object properties as an array.
+ *
+ * @remarks
+ * This is a convenience function that extracts properties using `getProperties` and returns them as an array.
  *
- * @param obj - The {@link ObjectSchema} from which to extract the properties.
- * @returns An array of properties defined in the JTD object schema, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag.
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An array of JSON Schema fragments representing the properties, each including metadata.
  */
-declare function getPropertiesList<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>): Array<JTDSchemaType<TMetadata> & {
-  name: string;
-  optional: boolean;
-}>;
+declare function getPropertiesList<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>): Array<JsonSchemaProperty<T>>;
 /**
- * A helper function to add a property to a JTD object schema. This function takes a JTD object schema (either {@link JTDSchemaObjectType} or {@link ObjectSchema}), a property name, and a JTD schema type as input. It adds the specified property to the appropriate section of the JTD schema based on whether the property is optional or required. If the property is optional (i.e., has `nullable: true`), it is added to the `optionalProperties` section of the schema; otherwise, it is added to the `properties` section. The function also ensures that the property's metadata includes its name for easier identification and access in future operations.
+ * Adds a property to a JSON Schema object form.
+ *
+ * @remarks
+ * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
  *
- * @param obj - The JTD object schema to which the property should be added.
+ * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
  * @param name - The name of the property to add.
- * @param property - The JTD schema type of the property to add, which may include a `nullable` flag indicating whether the property is optional.
+ * @param property - The JSON Schema fragment representing the property's schema, including metadata.
+ * @throws Will throw an error if the provided schema is not an object form.
  */
-declare function addProperty<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>, name: string, property: JTDSchemaType<TMetadata>): void;
+declare function addProperty<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>, name: string, property: JsonSchemaProperty<T>): void;
 /**
- * Merges multiple JTD object schemas into a single schema. This function takes an array of JTD object schemas (either {@link JTDSchemaObjectType} or {@link ObjectSchema}) and combines their properties into a single JTD object schema. The resulting schema will contain all properties from the input schemas, with optional properties marked accordingly. If there are overlapping properties between the input schemas, the function will merge them using a deep merge strategy (via `defu`) if they are both JTD object schemas; otherwise, the property from the first schema in the input array will take precedence.
+ * Merges multiple JSON Schema object forms into one.
  *
  * @remarks
- * This function attempts to mimic {@link defu}'s behavior for merging objects, but with special handling for JTD schemas. When merging properties, if a property exists in multiple input schemas and is defined as a JTD object schema in all of them, the function will perform a deep merge of those schemas. If the property is not a JTD object schema in any of the input schemas, the function will simply take the first definition it encounters.
+ * This function takes multiple JSON Schema objects or Schema wrappers and merges them into a single JSON Schema object. The merging process combines properties and metadata from all provided schemas, with later schemas in the arguments list taking precedence over earlier ones in case of conflicts. The resulting schema will include all unique properties and metadata from the input schemas.
  *
- * @param schemas - An array of JTD object schemas to merge.
- * @returns A single JTD object schema that combines the properties of all input schemas.
+ * @param schemas - An array of JSON Schema objects or Schema wrappers to merge.
+ * @returns A new JSON Schema object that is the result of merging all input schemas.
  */
-declare function mergeSchemas<TMetadata extends SchemaMetadata>(...schemas: (JTDSchemaObjectType<TMetadata> | ObjectSchema<TMetadata>)[]): JTDSchemaObjectType<TMetadata>;
+declare function mergeSchemas<T extends Record<string, any> = Record<string, any>>(...schemas: (JsonSchema<T> | Schema<T>)[]): JsonSchema<T>;
 //#endregion
 export { addProperty, getProperties, getPropertiesList, mergeSchemas };
 //# sourceMappingURL=helpers.d.cts.map

package/dist/helpers.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.cts","names":[],"sources":["../src/helpers.ts"],"mappings":";;;;;AAkCA;;;;iBAAgB,aAAA,mBAAgC,cAAA,CAAA,CAC9C,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,IAClD,MAAA,SAED,aAAA,CAAc,SAAA;EAAe,IAAA;EAAc,QAAA;AAAA;;;;;;;iBAgC7B,iBAAA,mBAAoC,cAAA,CAAA,CAClD,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,IAClD,KAAA,CAAM,aAAA,CAAc,SAAA;EAAe,IAAA;EAAc,QAAA;AAAA;;;;;;;;iBAWpC,WAAA,mBAA8B,cAAA,CAAA,CAC5C,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,GACnD,IAAA,UACA,QAAA,EAAU,aAAA,CAAc,SAAA;AAhD2B;AAgCrD;;;;;;;;AAhCqD,iBA2ErC,YAAA,mBAA+B,cAAA,CAAA,CAAA,GAC1C,OAAA,GAAU,mBAAA,CAAoB,SAAA,IAAa,YAAA,CAAa,SAAA,OAC1D,mBAAA,CAAoB,SAAA"}
+{"version":3,"file":"helpers.d.cts","names":[],"sources":["../src/helpers.ts"],"mappings":";;;;;AAsCA;;;;;;;iBAAgB,aAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAChC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,IAAK,MAAA,SAAe,kBAAA,CAAmB,CAAA;;;;;;;;;;iBA2BrD,iBAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAChC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,IAAK,KAAA,CAAM,kBAAA,CAAmB,CAAA;;;;;;;;;AA7BU;AA2BtE;;iBAiBgB,WAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAEhC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,GAC5B,IAAA,UACA,QAAA,EAAU,kBAAA,CAAmB,CAAA;;;;;;;;;;iBA+Bf,YAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAAA,GAC7B,OAAA,GAAU,UAAA,CAAW,CAAA,IAAK,MAAA,CAAO,CAAA,OAAQ,UAAA,CAAW,CAAA"}

package/dist/helpers.d.mts

@@ -1,44 +1,48 @@
-import { JTDSchemaObjectType, JTDSchemaType, ObjectSchema, SchemaMetadata } from "./types.mjs";
+import { JsonSchema, JsonSchemaProperty, Schema } from "./types.mjs";
 
 //#region src/helpers.d.ts
 /**
- * A helper function to extract the properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns a record of its properties, where each key is the property name and the value is the corresponding JTD schema type along with an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function checks both `properties` and `optionalProperties` of the JTD schema to construct the resulting record.
+ * Extracts object properties from a JSON Schema object form.
  *
- * @param obj - The {@link ObjectSchema} from which to extract the properties.
- * @returns A record of the properties defined in the JTD object schema, where each key is the property name and the value is an object containing the JTD schema type and an `optional` flag.
+ * @remarks
+ * This function returns an empty object if the schema is not an object form or if it has no properties.
+ *
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
  */
-declare function getProperties<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>): Record<string, JTDSchemaType<TMetadata> & {
-  name: string;
-  optional: boolean;
-}>;
+declare function getProperties<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>): Record<string, JsonSchemaProperty<T>>;
 /**
- * A helper function to get a list of properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns an array of its properties, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function utilizes the `getProperties` helper function to first retrieve the properties as a record and then converts that record into an array format for easier iteration and access.
+ * Returns object properties as an array.
+ *
+ * @remarks
+ * This is a convenience function that extracts properties using `getProperties` and returns them as an array.
  *
- * @param obj - The {@link ObjectSchema} from which to extract the properties.
- * @returns An array of properties defined in the JTD object schema, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag.
+ * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+ * @returns An array of JSON Schema fragments representing the properties, each including metadata.
  */
-declare function getPropertiesList<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>): Array<JTDSchemaType<TMetadata> & {
-  name: string;
-  optional: boolean;
-}>;
+declare function getPropertiesList<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>): Array<JsonSchemaProperty<T>>;
 /**
- * A helper function to add a property to a JTD object schema. This function takes a JTD object schema (either {@link JTDSchemaObjectType} or {@link ObjectSchema}), a property name, and a JTD schema type as input. It adds the specified property to the appropriate section of the JTD schema based on whether the property is optional or required. If the property is optional (i.e., has `nullable: true`), it is added to the `optionalProperties` section of the schema; otherwise, it is added to the `properties` section. The function also ensures that the property's metadata includes its name for easier identification and access in future operations.
+ * Adds a property to a JSON Schema object form.
+ *
+ * @remarks
+ * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
  *
- * @param obj - The JTD object schema to which the property should be added.
+ * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
  * @param name - The name of the property to add.
- * @param property - The JTD schema type of the property to add, which may include a `nullable` flag indicating whether the property is optional.
+ * @param property - The JSON Schema fragment representing the property's schema, including metadata.
+ * @throws Will throw an error if the provided schema is not an object form.
  */
-declare function addProperty<TMetadata extends SchemaMetadata>(obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>, name: string, property: JTDSchemaType<TMetadata>): void;
+declare function addProperty<T extends Record<string, any> = Record<string, any>>(obj: Schema<T> | JsonSchema<T>, name: string, property: JsonSchemaProperty<T>): void;
 /**
- * Merges multiple JTD object schemas into a single schema. This function takes an array of JTD object schemas (either {@link JTDSchemaObjectType} or {@link ObjectSchema}) and combines their properties into a single JTD object schema. The resulting schema will contain all properties from the input schemas, with optional properties marked accordingly. If there are overlapping properties between the input schemas, the function will merge them using a deep merge strategy (via `defu`) if they are both JTD object schemas; otherwise, the property from the first schema in the input array will take precedence.
+ * Merges multiple JSON Schema object forms into one.
  *
  * @remarks
- * This function attempts to mimic {@link defu}'s behavior for merging objects, but with special handling for JTD schemas. When merging properties, if a property exists in multiple input schemas and is defined as a JTD object schema in all of them, the function will perform a deep merge of those schemas. If the property is not a JTD object schema in any of the input schemas, the function will simply take the first definition it encounters.
+ * This function takes multiple JSON Schema objects or Schema wrappers and merges them into a single JSON Schema object. The merging process combines properties and metadata from all provided schemas, with later schemas in the arguments list taking precedence over earlier ones in case of conflicts. The resulting schema will include all unique properties and metadata from the input schemas.
  *
- * @param schemas - An array of JTD object schemas to merge.
- * @returns A single JTD object schema that combines the properties of all input schemas.
+ * @param schemas - An array of JSON Schema objects or Schema wrappers to merge.
+ * @returns A new JSON Schema object that is the result of merging all input schemas.
  */
-declare function mergeSchemas<TMetadata extends SchemaMetadata>(...schemas: (JTDSchemaObjectType<TMetadata> | ObjectSchema<TMetadata>)[]): JTDSchemaObjectType<TMetadata>;
+declare function mergeSchemas<T extends Record<string, any> = Record<string, any>>(...schemas: (JsonSchema<T> | Schema<T>)[]): JsonSchema<T>;
 //#endregion
 export { addProperty, getProperties, getPropertiesList, mergeSchemas };
 //# sourceMappingURL=helpers.d.mts.map

package/dist/helpers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.mts","names":[],"sources":["../src/helpers.ts"],"mappings":";;;;;AAkCA;;;;iBAAgB,aAAA,mBAAgC,cAAA,CAAA,CAC9C,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,IAClD,MAAA,SAED,aAAA,CAAc,SAAA;EAAe,IAAA;EAAc,QAAA;AAAA;;;;;;;iBAgC7B,iBAAA,mBAAoC,cAAA,CAAA,CAClD,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,IAClD,KAAA,CAAM,aAAA,CAAc,SAAA;EAAe,IAAA;EAAc,QAAA;AAAA;;;;;;;;iBAWpC,WAAA,mBAA8B,cAAA,CAAA,CAC5C,GAAA,EAAK,YAAA,CAAa,SAAA,IAAa,mBAAA,CAAoB,SAAA,GACnD,IAAA,UACA,QAAA,EAAU,aAAA,CAAc,SAAA;AAhD2B;AAgCrD;;;;;;;;AAhCqD,iBA2ErC,YAAA,mBAA+B,cAAA,CAAA,CAAA,GAC1C,OAAA,GAAU,mBAAA,CAAoB,SAAA,IAAa,YAAA,CAAa,SAAA,OAC1D,mBAAA,CAAoB,SAAA"}
+{"version":3,"file":"helpers.d.mts","names":[],"sources":["../src/helpers.ts"],"mappings":";;;;;AAsCA;;;;;;;iBAAgB,aAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAChC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,IAAK,MAAA,SAAe,kBAAA,CAAmB,CAAA;;;;;;;;;;iBA2BrD,iBAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAChC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,IAAK,KAAA,CAAM,kBAAA,CAAmB,CAAA;;;;;;;;;AA7BU;AA2BtE;;iBAiBgB,WAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAEhC,GAAA,EAAK,MAAA,CAAO,CAAA,IAAK,UAAA,CAAW,CAAA,GAC5B,IAAA,UACA,QAAA,EAAU,kBAAA,CAAmB,CAAA;;;;;;;;;;iBA+Bf,YAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAAA,GAC7B,OAAA,GAAU,UAAA,CAAW,CAAA,IAAK,MAAA,CAAO,CAAA,OAAQ,UAAA,CAAW,CAAA"}

package/dist/helpers.mjs

@@ -1,88 +1,82 @@
-import { isJTDSchemaObject, isObjectSchema } from "./type-checks.mjs";
+import { isPropertyOptional, isSchemaNullable } from "./metadata.mjs";
+import { isJsonSchemaObject, isSchema } from "./type-checks.mjs";
 import { defu as defu$1 } from "defu";
 import { isSetObject } from "@stryke/type-checks";
 
 //#region src/helpers.ts
 /**
-* A helper function to extract the properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns a record of its properties, where each key is the property name and the value is the corresponding JTD schema type along with an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function checks both `properties` and `optionalProperties` of the JTD schema to construct the resulting record.
+* Extracts object properties from a JSON Schema object form.
 *
-* @param obj - The {@link ObjectSchema} from which to extract the properties.
-* @returns A record of the properties defined in the JTD object schema, where each key is the property name and the value is an object containing the JTD schema type and an `optional` flag.
+* @remarks
+* This function returns an empty object if the schema is not an object form or if it has no properties.
+*
+* @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+* @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.
 */
 function getProperties(obj) {
 	const properties = {};
-	const schema = isObjectSchema(obj) ? obj.schema : obj;
-	if ("optionalProperties" in schema && isSetObject(schema.optionalProperties)) for (const [key, value] of Object.entries(schema.optionalProperties)) properties[key] = {
-		...value,
-		name: key,
-		optional: true
-	};
-	if ("properties" in schema && isSetObject(schema.properties)) for (const [key, value] of Object.entries(schema.properties)) properties[key] = {
+	const schema = isSchema(obj) ? obj.schema : obj;
+	if (!isJsonSchemaObject(schema) || !isSetObject(schema.properties)) return properties;
+	for (const [key, value] of Object.entries(schema.properties)) properties[key] = {
 		...value,
 		name: key,
-		optional: false
+		nullable: isSchemaNullable(value) || isPropertyOptional(schema, key)
 	};
 	return properties;
 }
 /**
-* A helper function to get a list of properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns an array of its properties, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function utilizes the `getProperties` helper function to first retrieve the properties as a record and then converts that record into an array format for easier iteration and access.
+* Returns object properties as an array.
+*
+* @remarks
+* This is a convenience function that extracts properties using `getProperties` and returns them as an array.
 *
-* @param obj - The {@link ObjectSchema} from which to extract the properties.
-* @returns An array of properties defined in the JTD object schema, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag.
+* @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.
+* @returns An array of JSON Schema fragments representing the properties, each including metadata.
 */
 function getPropertiesList(obj) {
 	return Object.values(getProperties(obj));
 }
 /**
-* A helper function to add a property to a JTD object schema. This function takes a JTD object schema (either {@link JTDSchemaObjectType} or {@link ObjectSchema}), a property name, and a JTD schema type as input. It adds the specified property to the appropriate section of the JTD schema based on whether the property is optional or required. If the property is optional (i.e., has `nullable: true`), it is added to the `optionalProperties` section of the schema; otherwise, it is added to the `properties` section. The function also ensures that the property's metadata includes its name for easier identification and access in future operations.
+* Adds a property to a JSON Schema object form.
+*
+* @remarks
+* This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.
 *
-* @param obj - The JTD object schema to which the property should be added.
+* @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.
 * @param name - The name of the property to add.
-* @param property - The JTD schema type of the property to add, which may include a `nullable` flag indicating whether the property is optional.
+* @param property - The JSON Schema fragment representing the property's schema, including metadata.
+* @throws Will throw an error if the provided schema is not an object form.
 */
 function addProperty(obj, name, property) {
-	const schema = isObjectSchema(obj) ? obj.schema : obj;
-	if (property.nullable) {
-		schema.optionalProperties ??= {};
-		schema.optionalProperties[name] = {
-			...property,
-			metadata: {
-				...property.metadata,
-				name
-			}
-		};
-	} else {
-		schema.properties ??= {};
-		schema.properties[name] = {
-			...property,
-			metadata: {
-				...property.metadata,
-				name
-			}
-		};
-	}
+	const schema = isSchema(obj) ? obj.schema : obj;
+	if (!isJsonSchemaObject(schema)) throw new Error("Cannot add property to non-object schema");
+	schema.properties ??= {};
+	schema.required ??= [];
+	schema.properties[name] = {
+		...property,
+		name
+	};
+	if (property?.optional) schema.required = schema.required.filter((key) => key !== name);
+	else if (!schema.required.includes(name)) schema.required.push(name);
+	if (schema.required.length === 0) delete schema.required;
 }
 /**
-* Merges multiple JTD object schemas into a single schema. This function takes an array of JTD object schemas (either {@link JTDSchemaObjectType} or {@link ObjectSchema}) and combines their properties into a single JTD object schema. The resulting schema will contain all properties from the input schemas, with optional properties marked accordingly. If there are overlapping properties between the input schemas, the function will merge them using a deep merge strategy (via `defu`) if they are both JTD object schemas; otherwise, the property from the first schema in the input array will take precedence.
+* Merges multiple JSON Schema object forms into one.
 *
 * @remarks
-* This function attempts to mimic {@link defu}'s behavior for merging objects, but with special handling for JTD schemas. When merging properties, if a property exists in multiple input schemas and is defined as a JTD object schema in all of them, the function will perform a deep merge of those schemas. If the property is not a JTD object schema in any of the input schemas, the function will simply take the first definition it encounters.
+* This function takes multiple JSON Schema objects or Schema wrappers and merges them into a single JSON Schema object. The merging process combines properties and metadata from all provided schemas, with later schemas in the arguments list taking precedence over earlier ones in case of conflicts. The resulting schema will include all unique properties and metadata from the input schemas.
 *
-* @param schemas - An array of JTD object schemas to merge.
-* @returns A single JTD object schema that combines the properties of all input schemas.
+* @param schemas - An array of JSON Schema objects or Schema wrappers to merge.
+* @returns A new JSON Schema object that is the result of merging all input schemas.
 */
 function mergeSchemas(...schemas) {
-	const mergedSchema = {
-		properties: {},
-		optionalProperties: {},
-		additionalProperties: false
-	};
-	for (const schema of schemas.reverse()) {
-		const properties = getProperties(schema);
-		for (const [key, value] of Object.entries(properties)) if (value.optional) mergedSchema.optionalProperties[key] = mergedSchema.optionalProperties[key] && isJTDSchemaObject(mergedSchema.optionalProperties[key]) && isJTDSchemaObject(value) ? defu$1(mergedSchema.optionalProperties[key], value) : value;
-		else mergedSchema.properties[key] = mergedSchema.properties[key] && isJTDSchemaObject(mergedSchema.properties[key]) && isJTDSchemaObject(value) ? defu$1(mergedSchema.properties[key], value) : value;
+	const result = {};
+	for (const schema of schemas) {
+		const jsonSchema = isSchema(schema) ? schema.schema : schema;
+		if (!isJsonSchemaObject(jsonSchema)) continue;
+		defu$1(result, jsonSchema);
 	}
-	return mergedSchema;
+	return result;
 }
 
 //#endregion

package/dist/helpers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.mjs","names":["defu"],"sources":["../src/helpers.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 { isSetObject } from \"@stryke/type-checks\";\nimport { defu } from \"defu\";\nimport { isJTDSchemaObject, isObjectSchema } from \"./type-checks\";\nimport {\n  JTDSchemaObjectType,\n  JTDSchemaType,\n  ObjectSchema,\n  SchemaMetadata\n} from \"./types\";\n\n/**\n * A helper function to extract the properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns a record of its properties, where each key is the property name and the value is the corresponding JTD schema type along with an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function checks both `properties` and `optionalProperties` of the JTD schema to construct the resulting record.\n *\n * @param obj - The {@link ObjectSchema} from which to extract the properties.\n * @returns A record of the properties defined in the JTD object schema, where each key is the property name and the value is an object containing the JTD schema type and an `optional` flag.\n */\nexport function getProperties<TMetadata extends SchemaMetadata>(\n  obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>\n): Record<\n  string,\n  JTDSchemaType<TMetadata> & { name: string; optional: boolean }\n> {\n  const properties: Record<\n    string,\n    JTDSchemaType<TMetadata> & { name: string; optional: boolean }\n  > = {};\n\n  const schema = isObjectSchema(obj) ? obj.schema : obj;\n  if (\n    \"optionalProperties\" in schema &&\n    isSetObject(schema.optionalProperties)\n  ) {\n    for (const [key, value] of Object.entries(schema.optionalProperties)) {\n      properties[key] = { ...value, name: key, optional: true };\n    }\n  }\n\n  if (\"properties\" in schema && isSetObject(schema.properties)) {\n    for (const [key, value] of Object.entries(schema.properties)) {\n      properties[key] = { ...value, name: key, optional: false };\n    }\n  }\n\n  return properties;\n}\n\n/**\n * A helper function to get a list of properties from a JTD object schema. This function takes an {@link ObjectSchema} as input and returns an array of its properties, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag indicating whether the property is optional (i.e., defined in `optionalProperties`) or required (i.e., defined in `properties`). The function utilizes the `getProperties` helper function to first retrieve the properties as a record and then converts that record into an array format for easier iteration and access.\n *\n * @param obj - The {@link ObjectSchema} from which to extract the properties.\n * @returns An array of properties defined in the JTD object schema, where each element is an object containing the property name, the corresponding JTD schema type, and an `optional` flag.\n */\nexport function getPropertiesList<TMetadata extends SchemaMetadata>(\n  obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>\n): Array<JTDSchemaType<TMetadata> & { name: string; optional: boolean }> {\n  return Object.values(getProperties(obj));\n}\n\n/**\n * A helper function to add a property to a JTD object schema. This function takes a JTD object schema (either {@link JTDSchemaObjectType} or {@link ObjectSchema}), a property name, and a JTD schema type as input. It adds the specified property to the appropriate section of the JTD schema based on whether the property is optional or required. If the property is optional (i.e., has `nullable: true`), it is added to the `optionalProperties` section of the schema; otherwise, it is added to the `properties` section. The function also ensures that the property's metadata includes its name for easier identification and access in future operations.\n *\n * @param obj - The JTD object schema to which the property should be added.\n * @param name - The name of the property to add.\n * @param property - The JTD schema type of the property to add, which may include a `nullable` flag indicating whether the property is optional.\n */\nexport function addProperty<TMetadata extends SchemaMetadata>(\n  obj: ObjectSchema<TMetadata> | JTDSchemaObjectType<TMetadata>,\n  name: string,\n  property: JTDSchemaType<TMetadata>\n) {\n  const schema = isObjectSchema(obj) ? obj.schema : obj;\n  if (property.nullable) {\n    schema.optionalProperties ??= {};\n    schema.optionalProperties[name] = {\n      ...property,\n      metadata: { ...property.metadata, name } as TMetadata\n    };\n  } else {\n    schema.properties ??= {};\n    schema.properties[name] = {\n      ...property,\n      metadata: { ...property.metadata, name } as TMetadata\n    };\n  }\n}\n\n/**\n * Merges multiple JTD object schemas into a single schema. This function takes an array of JTD object schemas (either {@link JTDSchemaObjectType} or {@link ObjectSchema}) and combines their properties into a single JTD object schema. The resulting schema will contain all properties from the input schemas, with optional properties marked accordingly. If there are overlapping properties between the input schemas, the function will merge them using a deep merge strategy (via `defu`) if they are both JTD object schemas; otherwise, the property from the first schema in the input array will take precedence.\n *\n * @remarks\n * This function attempts to mimic {@link defu}'s behavior for merging objects, but with special handling for JTD schemas. When merging properties, if a property exists in multiple input schemas and is defined as a JTD object schema in all of them, the function will perform a deep merge of those schemas. If the property is not a JTD object schema in any of the input schemas, the function will simply take the first definition it encounters.\n *\n * @param schemas - An array of JTD object schemas to merge.\n * @returns A single JTD object schema that combines the properties of all input schemas.\n */\nexport function mergeSchemas<TMetadata extends SchemaMetadata>(\n  ...schemas: (JTDSchemaObjectType<TMetadata> | ObjectSchema<TMetadata>)[]\n): JTDSchemaObjectType<TMetadata> {\n  const mergedSchema = {\n    properties: {},\n    optionalProperties: {},\n    additionalProperties: false\n  } as JTDSchemaObjectType<TMetadata>;\n  for (const schema of schemas.reverse()) {\n    const properties = getProperties(schema);\n    for (const [key, value] of Object.entries(properties)) {\n      if (value.optional) {\n        mergedSchema.optionalProperties![key] = (\n          mergedSchema.optionalProperties![key] &&\n          isJTDSchemaObject(mergedSchema.optionalProperties![key]) &&\n          isJTDSchemaObject(value)\n            ? defu(mergedSchema.optionalProperties![key], value)\n            : value\n        ) as JTDSchemaType<TMetadata>;\n      } else {\n        mergedSchema.properties![key] = (\n          mergedSchema.properties![key] &&\n          isJTDSchemaObject(mergedSchema.properties![key]) &&\n          isJTDSchemaObject(value)\n            ? defu(mergedSchema.properties![key], value)\n            : value\n        ) as JTDSchemaType<TMetadata>;\n      }\n    }\n  }\n\n  return mergedSchema;\n}\n"],"mappings":";;;;;;;;;;;AAkCA,SAAgB,cACd,KAIA;CACA,MAAM,aAGF,CAAC;CAEL,MAAM,SAAS,eAAe,GAAG,IAAI,IAAI,SAAS;CAClD,IACE,wBAAwB,UACxB,YAAY,OAAO,kBAAkB,GAErC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,kBAAkB,GACjE,WAAW,OAAO;EAAE,GAAG;EAAO,MAAM;EAAK,UAAU;CAAK;CAI5D,IAAI,gBAAgB,UAAU,YAAY,OAAO,UAAU,GACzD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,UAAU,GACzD,WAAW,OAAO;EAAE,GAAG;EAAO,MAAM;EAAK,UAAU;CAAM;CAI7D,OAAO;AACT;;;;;;;AAQA,SAAgB,kBACd,KACuE;CACvE,OAAO,OAAO,OAAO,cAAc,GAAG,CAAC;AACzC;;;;;;;;AASA,SAAgB,YACd,KACA,MACA,UACA;CACA,MAAM,SAAS,eAAe,GAAG,IAAI,IAAI,SAAS;CAClD,IAAI,SAAS,UAAU;EACrB,OAAO,uBAAuB,CAAC;EAC/B,OAAO,mBAAmB,QAAQ;GAChC,GAAG;GACH,UAAU;IAAE,GAAG,SAAS;IAAU;GAAK;EACzC;CACF,OAAO;EACL,OAAO,eAAe,CAAC;EACvB,OAAO,WAAW,QAAQ;GACxB,GAAG;GACH,UAAU;IAAE,GAAG,SAAS;IAAU;GAAK;EACzC;CACF;AACF;;;;;;;;;;AAWA,SAAgB,aACd,GAAG,SAC6B;CAChC,MAAM,eAAe;EACnB,YAAY,CAAC;EACb,oBAAoB,CAAC;EACrB,sBAAsB;CACxB;CACA,KAAK,MAAM,UAAU,QAAQ,QAAQ,GAAG;EACtC,MAAM,aAAa,cAAc,MAAM;EACvC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,UAAU,GAClD,IAAI,MAAM,UACR,aAAa,mBAAoB,OAC/B,aAAa,mBAAoB,QACjC,kBAAkB,aAAa,mBAAoB,IAAI,KACvD,kBAAkB,KAAK,IACnBA,OAAK,aAAa,mBAAoB,MAAM,KAAK,IACjD;OAGN,aAAa,WAAY,OACvB,aAAa,WAAY,QACzB,kBAAkB,aAAa,WAAY,IAAI,KAC/C,kBAAkB,KAAK,IACnBA,OAAK,aAAa,WAAY,MAAM,KAAK,IACzC;CAIZ;CAEA,OAAO;AACT"}
+{"version":3,"file":"helpers.mjs","names":[],"sources":["../src/helpers.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 { isSetObject } from \"@stryke/type-checks\";\nimport { defu } from \"defu\";\nimport { isPropertyOptional, isSchemaNullable } from \"./metadata\";\nimport { isJsonSchemaObject, isSchema } from \"./type-checks\";\nimport {\n  JsonSchema,\n  JsonSchemaObject,\n  JsonSchemaProperty,\n  Schema\n} from \"./types\";\n\n/**\n * Extracts object properties from a JSON Schema object form.\n *\n * @remarks\n * This function returns an empty object if the schema is not an object form or if it has no properties.\n *\n * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.\n * @returns An object mapping property names to their corresponding JSON Schema fragments, including metadata.\n */\nexport function getProperties<\n  T extends Record<string, any> = Record<string, any>\n>(obj: Schema<T> | JsonSchema<T>): Record<string, JsonSchemaProperty<T>> {\n  const properties: Record<string, JsonSchemaProperty<T>> = {};\n  const schema: JsonSchema<T> = isSchema<T>(obj) ? obj.schema : obj;\n  if (!isJsonSchemaObject<T>(schema) || !isSetObject(schema.properties)) {\n    return properties;\n  }\n\n  for (const [key, value] of Object.entries(schema.properties)) {\n    properties[key] = {\n      ...value,\n      name: key,\n      nullable: isSchemaNullable<T>(value) || isPropertyOptional(schema, key)\n    };\n  }\n\n  return properties;\n}\n\n/**\n * Returns object properties as an array.\n *\n * @remarks\n * This is a convenience function that extracts properties using `getProperties` and returns them as an array.\n *\n * @param obj - The JSON Schema object form or a Schema wrapper to extract properties from.\n * @returns An array of JSON Schema fragments representing the properties, each including metadata.\n */\nexport function getPropertiesList<\n  T extends Record<string, any> = Record<string, any>\n>(obj: Schema<T> | JsonSchema<T>): Array<JsonSchemaProperty<T>> {\n  return Object.values(getProperties<T>(obj));\n}\n\n/**\n * Adds a property to a JSON Schema object form.\n *\n * @remarks\n * This function modifies the provided schema in place by adding a new property with the specified name and schema. It also updates the `required` array based on the `optional` flag of the property. If the property is marked as optional, it will be removed from the `required` array; otherwise, it will be added to it.\n *\n * @param obj - The JSON Schema object form or a Schema wrapper to which the property should be added.\n * @param name - The name of the property to add.\n * @param property - The JSON Schema fragment representing the property's schema, including metadata.\n * @throws Will throw an error if the provided schema is not an object form.\n */\nexport function addProperty<\n  T extends Record<string, any> = Record<string, any>\n>(\n  obj: Schema<T> | JsonSchema<T>,\n  name: string,\n  property: JsonSchemaProperty<T>\n): void {\n  const schema = (isSchema<T>(obj) ? obj.schema : obj) as JsonSchemaObject<T>;\n  if (!isJsonSchemaObject<T>(schema)) {\n    throw new Error(\"Cannot add property to non-object schema\");\n  }\n\n  schema.properties ??= {};\n  schema.required ??= [];\n\n  schema.properties[name] = { ...property, name };\n  if (property?.optional) {\n    schema.required = schema.required.filter(key => key !== name);\n  } else if (!schema.required.includes(name)) {\n    schema.required.push(name);\n  }\n\n  if (schema.required.length === 0) {\n    delete schema.required;\n  }\n}\n\n/**\n * Merges multiple JSON Schema object forms into one.\n *\n * @remarks\n * This function takes multiple JSON Schema objects or Schema wrappers and merges them into a single JSON Schema object. The merging process combines properties and metadata from all provided schemas, with later schemas in the arguments list taking precedence over earlier ones in case of conflicts. The resulting schema will include all unique properties and metadata from the input schemas.\n *\n * @param schemas - An array of JSON Schema objects or Schema wrappers to merge.\n * @returns A new JSON Schema object that is the result of merging all input schemas.\n */\nexport function mergeSchemas<\n  T extends Record<string, any> = Record<string, any>\n>(...schemas: (JsonSchema<T> | Schema<T>)[]): JsonSchema<T> {\n  const result: JsonSchema<T> = {} as JsonSchema<T>;\n  for (const schema of schemas) {\n    const jsonSchema: JsonSchema<T> = isSchema<T>(schema)\n      ? schema.schema\n      : schema;\n    if (!isJsonSchemaObject<T>(jsonSchema)) {\n      continue;\n    }\n\n    defu(result, jsonSchema);\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsCA,SAAgB,cAEd,KAAuE;CACvE,MAAM,aAAoD,CAAC;CAC3D,MAAM,SAAwB,SAAY,GAAG,IAAI,IAAI,SAAS;CAC9D,IAAI,CAAC,mBAAsB,MAAM,KAAK,CAAC,YAAY,OAAO,UAAU,GAClE,OAAO;CAGT,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,UAAU,GACzD,WAAW,OAAO;EAChB,GAAG;EACH,MAAM;EACN,UAAU,iBAAoB,KAAK,KAAK,mBAAmB,QAAQ,GAAG;CACxE;CAGF,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,kBAEd,KAA8D;CAC9D,OAAO,OAAO,OAAO,cAAiB,GAAG,CAAC;AAC5C;;;;;;;;;;;;AAaA,SAAgB,YAGd,KACA,MACA,UACM;CACN,MAAM,SAAU,SAAY,GAAG,IAAI,IAAI,SAAS;CAChD,IAAI,CAAC,mBAAsB,MAAM,GAC/B,MAAM,IAAI,MAAM,0CAA0C;CAG5D,OAAO,eAAe,CAAC;CACvB,OAAO,aAAa,CAAC;CAErB,OAAO,WAAW,QAAQ;EAAE,GAAG;EAAU;CAAK;CAC9C,IAAI,UAAU,UACZ,OAAO,WAAW,OAAO,SAAS,QAAO,QAAO,QAAQ,IAAI;MACvD,IAAI,CAAC,OAAO,SAAS,SAAS,IAAI,GACvC,OAAO,SAAS,KAAK,IAAI;CAG3B,IAAI,OAAO,SAAS,WAAW,GAC7B,OAAO,OAAO;AAElB;;;;;;;;;;AAWA,SAAgB,aAEd,GAAG,SAAuD;CAC1D,MAAM,SAAwB,CAAC;CAC/B,KAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,aAA4B,SAAY,MAAM,IAChD,OAAO,SACP;EACJ,IAAI,CAAC,mBAAsB,UAAU,GACnC;EAGF,OAAK,QAAQ,UAAU;CACzB;CAEA,OAAO;AACT"}

package/dist/index.cjs

@@ -1,17 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_bundle = require('./bundle.cjs');
+const require_constants = require('./constants.cjs');
+const require_metadata = require('./metadata.cjs');
 const require_type_checks = require('./type-checks.cjs');
 const require_helpers = require('./helpers.cjs');
 const require_codegen = require('./codegen.cjs');
-const require_constants = require('./constants.cjs');
-const require_jtd = require('./jtd.cjs');
 const require_persistence = require('./persistence.cjs');
 const require_reflection = require('./reflection.cjs');
 const require_resolve = require('./resolve.cjs');
 const require_extract = require('./extract.cjs');
 
-exports.JTDTypes = require_constants.JTDTypes;
+exports.JSON_SCHEMA_DATA_TYPES = require_constants.JSON_SCHEMA_DATA_TYPES;
+exports.JSON_SCHEMA_METADATA_KEYS = require_constants.JSON_SCHEMA_METADATA_KEYS;
+exports.JsonSchemaTypes = require_constants.JsonSchemaTypes;
 exports.addProperty = require_helpers.addProperty;
+exports.applySchemaMetadata = require_metadata.applySchemaMetadata;
 exports.bundle = require_bundle.bundle;
 exports.extract = require_extract.extract;
 exports.extractHash = require_extract.extractHash;
@@ -25,19 +28,23 @@ exports.extractVariant = require_extract.extractVariant;
 exports.generateCode = require_codegen.generateCode;
 exports.getCacheDirectory = require_persistence.getCacheDirectory;
 exports.getCacheFilePath = require_persistence.getCacheFilePath;
+exports.getPrimarySchemaType = require_metadata.getPrimarySchemaType;
 exports.getProperties = require_helpers.getProperties;
 exports.getPropertiesList = require_helpers.getPropertiesList;
 exports.isExtractedSchema = require_type_checks.isExtractedSchema;
-exports.isJTDSchema = require_type_checks.isJTDSchema;
-exports.isJTDSchemaObject = require_type_checks.isJTDSchemaObject;
-exports.isObjectSchema = require_type_checks.isObjectSchema;
+exports.isJsonSchema = require_type_checks.isJsonSchema;
+exports.isJsonSchemaObject = require_type_checks.isJsonSchemaObject;
+exports.isNullOnlyJsonSchema = require_type_checks.isNullOnlyJsonSchema;
+exports.isNullableSchema = require_codegen.isNullableSchema;
+exports.isPropertyOptional = require_metadata.isPropertyOptional;
 exports.isSchema = require_type_checks.isSchema;
+exports.isSchemaNullable = require_metadata.isSchemaNullable;
 exports.isUntypedInput = require_type_checks.isUntypedInput;
 exports.isUntypedSchema = require_type_checks.isUntypedSchema;
-exports.jsonSchemaToJtd = require_jtd.jsonSchemaToJtd;
 exports.mergeSchemas = require_helpers.mergeSchemas;
 exports.readSchema = require_persistence.readSchema;
 exports.readSchemaSafe = require_persistence.readSchemaSafe;
+exports.readSchemaTypes = require_metadata.readSchemaTypes;
 exports.reflectionToJsonSchema = require_reflection.reflectionToJsonSchema;
 exports.resolve = require_resolve.resolve;
 exports.resolveModule = require_resolve.resolveModule;

package/dist/index.d.cts

@@ -1,12 +1,12 @@
 import { BundleOptions, bundle } from "./bundle.cjs";
-import { BaseSchemaSource, ExtractedSchema, JTDNumberType, JTDSchemaObjectForm, JTDSchemaObjectType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ObjectSchema, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.cjs";
-import { generateCode, stringifyType, stringifyValue } from "./codegen.cjs";
-import { JTDTypes } from "./constants.cjs";
+import { BaseSchemaSource, ExtractedSchema, JsonSchema, JsonSchemaLike, JsonSchemaObject, JsonSchemaPrimitiveType, JsonSchemaProperty, JsonSchemaSchemaSource, JsonType, NumberFormat, NumberKeywords, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, StringKeywords, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.cjs";
+import { generateCode, isNullableSchema, stringifyType, stringifyValue } from "./codegen.cjs";
+import { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes } from "./constants.cjs";
 import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.cjs";
 import { addProperty, getProperties, getPropertiesList, mergeSchemas } from "./helpers.cjs";
-import { jsonSchemaToJtd } from "./jtd.cjs";
+import { applySchemaMetadata, getPrimarySchemaType, isPropertyOptional, isSchemaNullable, readSchemaTypes } from "./metadata.cjs";
 import { getCacheDirectory, getCacheFilePath, readSchema, readSchemaSafe, writeSchema } from "./persistence.cjs";
 import { reflectionToJsonSchema } from "./reflection.cjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.cjs";
-import { isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.cjs";
-export { BaseSchemaSource, BundleOptions, ExtractedSchema, JTDNumberType, JTDSchemaObjectForm, JTDSchemaObjectType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JTDTypes, JsonSchemaLike, JsonSchemaSchemaSource, ObjectSchema, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, addProperty, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getProperties, getPropertiesList, isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, mergeSchemas, readSchema, readSchemaSafe, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };
+import { isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.cjs";
+export { BaseSchemaSource, BundleOptions, ExtractedSchema, JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchema, JsonSchemaLike, JsonSchemaObject, JsonSchemaPrimitiveType, JsonSchemaProperty, JsonSchemaSchemaSource, JsonSchemaTypes, JsonType, NumberFormat, NumberKeywords, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, StringKeywords, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, addProperty, applySchemaMetadata, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getPrimarySchemaType, getProperties, getPropertiesList, isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isNullableSchema, isPropertyOptional, isSchema, isSchemaNullable, isUntypedInput, isUntypedSchema, mergeSchemas, readSchema, readSchemaSafe, readSchemaTypes, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { BundleOptions, bundle } from "./bundle.mjs";
-import { BaseSchemaSource, ExtractedSchema, JTDNumberType, JTDSchemaObjectForm, JTDSchemaObjectType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ObjectSchema, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.mjs";
-import { generateCode, stringifyType, stringifyValue } from "./codegen.mjs";
-import { JTDTypes } from "./constants.mjs";
+import { BaseSchemaSource, ExtractedSchema, JsonSchema, JsonSchemaLike, JsonSchemaObject, JsonSchemaPrimitiveType, JsonSchemaProperty, JsonSchemaSchemaSource, JsonType, NumberFormat, NumberKeywords, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, StringKeywords, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource } from "./types.mjs";
+import { generateCode, isNullableSchema, stringifyType, stringifyValue } from "./codegen.mjs";
+import { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes } from "./constants.mjs";
 import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.mjs";
 import { addProperty, getProperties, getPropertiesList, mergeSchemas } from "./helpers.mjs";
-import { jsonSchemaToJtd } from "./jtd.mjs";
+import { applySchemaMetadata, getPrimarySchemaType, isPropertyOptional, isSchemaNullable, readSchemaTypes } from "./metadata.mjs";
 import { getCacheDirectory, getCacheFilePath, readSchema, readSchemaSafe, writeSchema } from "./persistence.mjs";
 import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
-import { isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
-export { BaseSchemaSource, BundleOptions, ExtractedSchema, JTDNumberType, JTDSchemaObjectForm, JTDSchemaObjectType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JTDTypes, JsonSchemaLike, JsonSchemaSchemaSource, ObjectSchema, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, addProperty, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getProperties, getPropertiesList, isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, mergeSchemas, readSchema, readSchemaSafe, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };
+import { isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
+export { BaseSchemaSource, BundleOptions, ExtractedSchema, JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchema, JsonSchemaLike, JsonSchemaObject, JsonSchemaPrimitiveType, JsonSchemaProperty, JsonSchemaSchemaSource, JsonSchemaTypes, JsonType, NumberFormat, NumberKeywords, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, StringKeywords, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource, addProperty, applySchemaMetadata, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getPrimarySchemaType, getProperties, getPropertiesList, isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isNullableSchema, isPropertyOptional, isSchema, isSchemaNullable, isUntypedInput, isUntypedSchema, mergeSchemas, readSchema, readSchemaSafe, readSchemaTypes, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { bundle } from "./bundle.mjs";
-import { isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
+import { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes } from "./constants.mjs";
+import { applySchemaMetadata, getPrimarySchemaType, isPropertyOptional, isSchemaNullable, readSchemaTypes } from "./metadata.mjs";
+import { isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isSchema, isUntypedInput, isUntypedSchema } from "./type-checks.mjs";
 import { addProperty, getProperties, getPropertiesList, mergeSchemas } from "./helpers.mjs";
-import { generateCode, stringifyType, stringifyValue } from "./codegen.mjs";
-import { JTDTypes } from "./constants.mjs";
-import { jsonSchemaToJtd } from "./jtd.mjs";
+import { generateCode, isNullableSchema, stringifyType, stringifyValue } from "./codegen.mjs";
 import { getCacheDirectory, getCacheFilePath, readSchema, readSchemaSafe, writeSchema } from "./persistence.mjs";
 import { reflectionToJsonSchema } from "./reflection.mjs";
 import { resolve, resolveModule, resolveReflection } from "./resolve.mjs";
 import { extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant } from "./extract.mjs";
 
-export { JTDTypes, addProperty, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getProperties, getPropertiesList, isExtractedSchema, isJTDSchema, isJTDSchemaObject, isObjectSchema, isSchema, isUntypedInput, isUntypedSchema, jsonSchemaToJtd, mergeSchemas, readSchema, readSchemaSafe, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };
+export { JSON_SCHEMA_DATA_TYPES, JSON_SCHEMA_METADATA_KEYS, JsonSchemaTypes, addProperty, applySchemaMetadata, bundle, extract, extractHash, extractJsonSchema, extractReflection, extractResolvedVariant, extractSchema, extractSchemaSchema, extractSource, extractVariant, generateCode, getCacheDirectory, getCacheFilePath, getPrimarySchemaType, getProperties, getPropertiesList, isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isNullableSchema, isPropertyOptional, isSchema, isSchemaNullable, isUntypedInput, isUntypedSchema, mergeSchemas, readSchema, readSchemaSafe, readSchemaTypes, reflectionToJsonSchema, resolve, resolveModule, resolveReflection, stringifyType, stringifyValue, writeSchema };

package/dist/metadata.cjs

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants = require('./constants.cjs');
+let _stryke_type_checks = require("@stryke/type-checks");
+let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
+
+//#region src/metadata.ts
+/**
+* Applies Powerlines schema metadata onto a JSON Schema fragment.
+*
+* @param schema - The JSON Schema fragment to apply metadata to.
+* @param metadata - The Powerlines schema metadata to apply.
+* @returns A new JSON Schema fragment with the metadata applied.
+*/
+function applySchemaMetadata(schema, metadata) {
+	if (!metadata) return schema;
+	const result = { ...schema };
+	for (const key of require_constants.JSON_SCHEMA_METADATA_KEYS) {
+		const value = metadata[key];
+		if (value !== void 0 && value !== null) result[key] = value;
+	}
+	return result;
+}
+/**
+* Returns whether a JSON Schema fragment accepts `null`.
+*
+* @remarks
+* This is true if the schema has `nullable: true` or if its `type` includes `"null"`.
+*
+* @param schema - The JSON Schema fragment to check.
+* @returns `true` if the schema accepts `null`, otherwise `false`.
+*/
+function isSchemaNullable(schema) {
+	if (!(0, _stryke_type_checks_is_set_object.isSetObject)(schema)) return false;
+	if (schema.nullable === true) return true;
+	return readSchemaTypes(schema).includes("null");
+}
+/**
+* Returns whether an object property is optional (not listed in `required`).
+*
+* @remarks
+* In JSON Schema, object properties are optional by default unless they are listed in the `required` array of the parent schema. This function checks whether a given property name is not included in the `required` array of its parent schema, indicating that it is optional.
+*
+* @param parent - The parent JSON Schema object containing the property.
+* @param propertyName - The name of the property to check for optionality.
+* @returns `true` if the property is optional, otherwise `false`.
+*/
+function isPropertyOptional(parent, propertyName) {
+	return !(parent.required ?? []).includes(propertyName);
+}
+/**
+* Normalizes the JSON Schema `type` keyword to a string array.
+*
+* @remarks
+* This function ensures that the `type` keyword of a JSON Schema fragment is always represented as an array of strings, even if it was originally defined as a single string. This normalization simplifies type checking and processing of JSON Schemas by providing a consistent format for the `type` information.
+*
+* @param schema - The JSON Schema fragment to read types from.
+* @returns An array of JSON Schema primitive type names defined in the `type` keyword, or an empty array if no valid types are found.
+*/
+function readSchemaTypes(schema) {
+	if (Array.isArray(schema?.type)) return schema.type.filter(_stryke_type_checks.isSetString);
+	if ((0, _stryke_type_checks.isSetString)(schema?.type)) return [schema.type];
+	return [];
+}
+/**
+* Returns the primary non-null JSON Schema type name for a fragment.
+*
+* @param schema - The JSON Schema fragment to check.
+* @returns The primary non-null JSON Schema type name, or `undefined` if none is found.
+*/
+function getPrimarySchemaType(schema) {
+	if (!(0, _stryke_type_checks_is_set_object.isSetObject)(schema)) return;
+	return readSchemaTypes(schema).find((type) => type !== "null");
+}
+
+//#endregion
+exports.applySchemaMetadata = applySchemaMetadata;
+exports.getPrimarySchemaType = getPrimarySchemaType;
+exports.isPropertyOptional = isPropertyOptional;
+exports.isSchemaNullable = isSchemaNullable;
+exports.readSchemaTypes = readSchemaTypes;