@powerlines/schema 0.11.28 → 0.11.38

package/dist/type-checks.d.mts

@@ -1,43 +1,65 @@
-import { ExtractedSchema, Schema as Schema$1, SchemaMetadata } from "./types.mjs";
+import { ExtractedSchema, JsonSchema, JsonSchemaObject, Schema as Schema$1 } from "./types.mjs";
 import { InputObject, Schema } from "untyped";
-import { JTDSchemaType } from "ajv/dist/types/jtd-schema.js";
 
 //#region src/type-checks.d.ts
 /**
- * Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+ * Type guard for JSON Schema types.
  *
- * @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
- * @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+ * @remarks
+ * This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.
+ *
+ * @param input - The value to check.
+ * @returns True if the input is a JSON Schema type, false otherwise.
  */
-declare function isJTDSchema<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is JTDSchemaType<TMetadata>;
+declare function isJsonSchema<T = unknown>(input: unknown): input is JsonSchema<T>;
 /**
- * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+ * Type guard for JSON Schema object forms.
+ *
+ * @remarks
+ * This function checks if the input is a JSON Schema object type, which is defined as having a `type` property equal to "object" or having a `properties` object. This is used to determine if a given input conforms to the structure of a JSON Schema object definition.
  *
- * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
- * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+ * @param input - The value to check.
+ * @returns True if the input is a JSON Schema object type, false otherwise.
  */
-declare function isUntypedSchema(input: unknown): input is Schema;
+declare function isJsonSchemaObject<T extends Record<string, any> = Record<string, any>>(input: unknown): input is JsonSchemaObject<T>;
 /**
- * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+ * Type guard for JSON Schemas that only accept `null`.
  *
- * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
- * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+ * @remarks
+ * This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to "null". This is useful for identifying schemas that are specifically designed to allow only `null` values.
+ *
+ * @param input - The value to check.
+ * @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
  */
-declare function isUntypedInput(input: unknown): input is InputObject;
+declare function isNullOnlyJsonSchema(input: unknown): input is JsonSchema<null>;
+/**
+ * Type guard for untyped schema objects.
+ *
+ * @remarks
+ * This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.
+ *
+ * @param input - The value to check.
+ * @returns True if the input is an untyped schema object, false otherwise.
+ */
+declare function isUntypedSchema(input: unknown): input is Schema;
 /**
- * Type guard to check if a given input is a {@link Schema} 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 {@link Schema}; otherwise, it returns `false`.
+ * Type guard for untyped input objects.
+ *
+ * @remarks
+ * This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.
  *
- * @param input - The input to check for being a {@link Schema}.
- * @returns `true` if the input is a {@link Schema}, otherwise `false`.
+ * @param input - The value to check.
+ * @returns True if the input is an untyped input object, false otherwise.
  */
-declare function isSchema<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is Schema$1<TMetadata>;
+declare function isUntypedInput(input: unknown): input is InputObject;
 /**
- * Type guard to check if a given input is a {@link ExtractedSchema} 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 {@link ExtractedSchema}; otherwise, it returns `false`.
+ * Type guard for Powerlines Schema objects.
  *
- * @param input - The input to check for being a {@link ExtractedSchema}.
- * @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
+ * @param input - The value to check.
+ * @returns True if the input is a Powerlines Schema object, false otherwise.
  */
-declare function isExtractedSchema<TMetadata extends SchemaMetadata = SchemaMetadata>(input: unknown): input is ExtractedSchema<TMetadata>;
+declare function isSchema<T = unknown>(input: unknown): input is Schema$1<T>;
+declare function isExtractedSchema<T = unknown>(input: unknown): input is ExtractedSchema<T>;
 //#endregion
-export { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema };
+export { isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isSchema, isUntypedInput, isUntypedSchema };
 //# sourceMappingURL=type-checks.d.mts.map

package/dist/type-checks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"type-checks.d.mts","names":[],"sources":["../src/type-checks.ts"],"mappings":";;;;;;;AAiCA;;;;iBAAgB,WAAA,mBAA8B,cAAA,GAAiB,cAAA,CAAA,CAC7D,KAAA,YACC,KAAA,IAAS,aAAA,CAAc,SAAA;;;;;;;iBAUV,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAA;;;;;;;iBAwD1C,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAA;;;;;;;iBAsBzC,QAAA,mBAA2B,cAAA,GAAiB,cAAA,CAAA,CAC1D,KAAA,YACC,KAAA,IAAS,QAAA,CAAO,SAAA;;AAxBnB;;;;;iBA0CgB,iBAAA,mBACI,cAAA,GAAiB,cAAA,CAAA,CACnC,KAAA,YAAiB,KAAA,IAAS,eAAA,CAAgB,SAAA"}
+{"version":3,"file":"type-checks.d.mts","names":[],"sources":["../src/type-checks.ts"],"mappings":";;;;;;AAyHA;;;;;;;iBAAgB,YAAA,aAAA,CACd,KAAA,YACC,KAAA,IAAS,UAAU,CAAC,CAAA;;;AAAC;AA4FxB;;;;;;iBAAgB,kBAAA,WACJ,MAAA,gBAAsB,MAAA,cAAA,CAChC,KAAA,YAAiB,KAAA,IAAS,gBAAA,CAAiB,CAAA;;;;;;;;;;iBAgB7B,oBAAA,CACd,KAAA,YACC,KAAA,IAAS,UAAU;AAlBwB;AAgB9C;;;;;;;;AAhB8C,iBA+B9B,eAAA,CAAgB,KAAA,YAAiB,KAAA,IAAS,MAAa;AAAvE;;;;;;;;AAAuE;AAAvE,iBA2DgB,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,WAAkB;;;;;;;iBAsB3D,QAAA,aAAA,CAAsB,KAAA,YAAiB,KAAA,IAAS,QAAM,CAAC,CAAA;AAAA,iBAYvD,iBAAA,aAAA,CACd,KAAA,YACC,KAAA,IAAS,eAAe,CAAC,CAAA"}

package/dist/type-checks.mjs

@@ -1,21 +1,124 @@
-import { isFunction, isSetObject, isSetString } from "@stryke/type-checks";
-import { isJsonSchemaObjectType } from "@stryke/json/schema";
+import { JSON_SCHEMA_DATA_TYPES } from "./constants.mjs";
+import { isFunction, isObject, isSetObject, isSetString } from "@stryke/type-checks";
+import { isJsonSchemaObjectType } from "@stryke/json";
 
 //#region src/type-checks.ts
+const JSON_SCHEMA_DATA_TYPE_SET = new Set(JSON_SCHEMA_DATA_TYPES);
+const isSetNumber = (value) => typeof value === "number" && Number.isFinite(value);
+const isSetBoolean = (value) => typeof value === "boolean";
+const isNonNegativeInteger = (value) => Number.isInteger(value) && value >= 0;
+const isSchemaLikeValue = (value) => isSetObject(value) || isSetBoolean(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => isSetString(item));
+const isRecordOfStringArrays = (value) => isSetObject(value) && Object.values(value).every((item) => isStringArray(item));
+const TYPE_KEYWORD_VALIDATORS = {
+	string: {
+		minLength: isNonNegativeInteger,
+		maxLength: isNonNegativeInteger,
+		pattern: isSetString,
+		format: isSetString,
+		contentEncoding: isSetString,
+		contentMediaType: isSetString
+	},
+	number: {
+		minimum: isSetNumber,
+		maximum: isSetNumber,
+		exclusiveMinimum: isSetNumber,
+		exclusiveMaximum: isSetNumber,
+		multipleOf: isSetNumber
+	},
+	integer: {
+		minimum: isSetNumber,
+		maximum: isSetNumber,
+		exclusiveMinimum: isSetNumber,
+		exclusiveMaximum: isSetNumber,
+		multipleOf: isSetNumber
+	},
+	boolean: {},
+	array: {
+		items: isSchemaLikeValue,
+		prefixItems: Array.isArray,
+		contains: isSchemaLikeValue,
+		minItems: isNonNegativeInteger,
+		maxItems: isNonNegativeInteger,
+		uniqueItems: isSetBoolean,
+		minContains: isNonNegativeInteger,
+		maxContains: isNonNegativeInteger
+	},
+	object: {
+		properties: isSetObject,
+		patternProperties: isSetObject,
+		additionalProperties: isSchemaLikeValue,
+		required: isStringArray,
+		minProperties: isNonNegativeInteger,
+		maxProperties: isNonNegativeInteger,
+		dependentRequired: isRecordOfStringArrays,
+		dependentSchemas: isSetObject,
+		propertyNames: isSchemaLikeValue,
+		unevaluatedProperties: isSchemaLikeValue
+	},
+	null: {}
+};
 /**
-* Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.
+* Type guard for JSON Schema types.
 *
-* @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).
-* @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.
+* @remarks
+* This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema type, false otherwise.
+*/
+function isJsonSchema(input) {
+	if (!isSetObject(input)) return false;
+	const schema = input;
+	if ("$ref" in schema && isSetString(schema.$ref)) return true;
+	if (!("type" in schema)) return false;
+	const schemaTypes = [];
+	if (isSetString(schema.type)) {
+		if (!JSON_SCHEMA_DATA_TYPE_SET.has(schema.type)) return false;
+		schemaTypes.push(schema.type);
+	} else if (Array.isArray(schema.type) && schema.type.length > 0) {
+		if (!schema.type.every((schemaType) => isSetString(schemaType) && JSON_SCHEMA_DATA_TYPE_SET.has(schemaType)) || new Set(schema.type).size !== schema.type.length) return false;
+		schemaTypes.push(...schema.type);
+	} else return false;
+	const typeKeywordValidators = schemaTypes.flatMap((schemaType) => Object.entries(TYPE_KEYWORD_VALIDATORS[schemaType]));
+	for (const [keyword, validator] of typeKeywordValidators) if (keyword in schema && !validator(schema[keyword])) return false;
+	if ("minItems" in schema && "maxItems" in schema && isNonNegativeInteger(schema.minItems) && isNonNegativeInteger(schema.maxItems) && schema.minItems > schema.maxItems) return false;
+	if ("minLength" in schema && "maxLength" in schema && isNonNegativeInteger(schema.minLength) && isNonNegativeInteger(schema.maxLength) && schema.minLength > schema.maxLength) return false;
+	if ("minProperties" in schema && "maxProperties" in schema && isNonNegativeInteger(schema.minProperties) && isNonNegativeInteger(schema.maxProperties) && schema.minProperties > schema.maxProperties) return false;
+	return true;
+}
+/**
+* Type guard for JSON Schema object forms.
+*
+* @remarks
+* This function checks if the input is a JSON Schema object type, which is defined as having a `type` property equal to "object" or having a `properties` object. This is used to determine if a given input conforms to the structure of a JSON Schema object definition.
+*
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema object type, false otherwise.
 */
-function isJTDSchema(input) {
-	return isJsonSchemaObjectType(input) && "jtd" in input && input.jtd === true;
+function isJsonSchemaObject(input) {
+	return isJsonSchemaObjectType(input) && (input.type === "object" || isObject(input.properties));
 }
 /**
-* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.
+* Type guard for JSON Schemas that only accept `null`.
+*
+* @remarks
+* This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to "null". This is useful for identifying schemas that are specifically designed to allow only `null` values.
 *
-* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.
-* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.
+* @param input - The value to check.
+* @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.
+*/
+function isNullOnlyJsonSchema(input) {
+	return isJsonSchema(input) && input.type === "null";
+}
+/**
+* Type guard for untyped schema objects.
+*
+* @remarks
+* This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped schema object, false otherwise.
 */
 function isUntypedSchema(input) {
 	if (!isSetObject(input)) return false;
@@ -35,10 +138,13 @@ function isUntypedSchema(input) {
 	return true;
 }
 /**
-* Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.
+* Type guard for untyped input objects.
 *
-* @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.
-* @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.
+* @remarks
+* This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.
+*
+* @param input - The value to check.
+* @returns True if the input is an untyped input object, false otherwise.
 */
 function isUntypedInput(input) {
 	if (!isSetObject(input)) return false;
@@ -48,24 +154,18 @@ function isUntypedInput(input) {
 	return true;
 }
 /**
-* Type guard to check if a given input is a {@link Schema} 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 {@link Schema}; otherwise, it returns `false`.
+* Type guard for Powerlines Schema objects.
 *
-* @param input - The input to check for being a {@link Schema}.
-* @returns `true` if the input is a {@link Schema}, otherwise `false`.
+* @param input - The value to check.
+* @returns True if the input is a Powerlines Schema object, false otherwise.
 */
 function isSchema(input) {
-	return isSetObject(input) && "schema" in input && isJTDSchema(input.schema) && "input" in input && isSetObject(input.input) && "variant" in input && isSetString(input.variant);
+	return isSetObject(input) && "schema" in input && isJsonSchema(input.schema) && "variant" in input && isSetString(input.variant) && "hash" in input && isSetString(input.hash);
 }
-/**
-* Type guard to check if a given input is a {@link ExtractedSchema} 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 {@link ExtractedSchema}; otherwise, it returns `false`.
-*
-* @param input - The input to check for being a {@link ExtractedSchema}.
-* @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.
-*/
 function isExtractedSchema(input) {
-	return isSchema(input) && "source" in input && isSetObject(input.source) && "schema" in input.source && isJTDSchema(input.source.schema) && "variant" in input.source && isSetString(input.source.variant);
+	return isSchema(input) && "source" in input && isSetObject(input.source) && "schema" in input.source && "variant" in input.source && isSetString(input.source.variant);
 }
 
 //#endregion
-export { isExtractedSchema, isJTDSchema, isSchema, isUntypedInput, isUntypedSchema };
+export { isExtractedSchema, isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema, isSchema, isUntypedInput, isUntypedSchema };
 //# sourceMappingURL=type-checks.mjs.map

package/dist/type-checks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"type-checks.mjs","names":[],"sources":["../src/type-checks.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 { isJsonSchemaObjectType } from \"@stryke/json/schema\";\nimport { isFunction, isSetObject, isSetString } from \"@stryke/type-checks\";\nimport { JTDSchemaType } from \"ajv/dist/types/jtd-schema\";\nimport {\n  InputObject as UntypedInputObject,\n  Schema as UntypedSchema\n} from \"untyped\";\nimport { ExtractedSchema, Schema, SchemaMetadata } from \"./types\";\n\n/**\n * Type guard to check if a given input is a [JSON Type Definition (JTD) schema object](https://tools.ietf.org/html/rfc8927). This function verifies that the input is a non-null object, contains a `jtd` property that is set to `true`, and has a `schema` property that is a JSON Schema (draft-07) object. If all these conditions are met, the function returns `true`, indicating that the input is a valid JTD schema; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a [JTD schema](https://tools.ietf.org/html/rfc8927).\n * @returns `true` if the input is a [JTD schema](https://tools.ietf.org/html/rfc8927), otherwise `false`.\n */\nexport function isJTDSchema<TMetadata extends SchemaMetadata = SchemaMetadata>(\n  input: unknown\n): input is JTDSchemaType<TMetadata> {\n  return isJsonSchemaObjectType(input) && \"jtd\" in input && input.jtd === true;\n}\n\n/**\n * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedSchema | Schema} object. This function verifies that the input is a non-null object whose optional metadata properties (`id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`) - when present - match the shapes declared by `untyped`'s [`Schema`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface.\n *\n * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) schema.\n * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) schema, otherwise `false`.\n */\nexport function isUntypedSchema(input: unknown): input is UntypedSchema {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const schema = input as Record<string, unknown>;\n  if (\"id\" in schema && !isSetString(schema.id)) {\n    return false;\n  }\n  if (\"title\" in schema && !isSetString(schema.title)) {\n    return false;\n  }\n  if (\"description\" in schema && !isSetString(schema.description)) {\n    return false;\n  }\n  if (\"$schema\" in schema && !isSetString(schema.$schema)) {\n    return false;\n  }\n  if (\"tsType\" in schema && !isSetString(schema.tsType)) {\n    return false;\n  }\n  if (\"markdownType\" in schema && !isSetString(schema.markdownType)) {\n    return false;\n  }\n  if (\n    \"type\" in schema &&\n    !isSetString(schema.type) &&\n    !Array.isArray(schema.type)\n  ) {\n    return false;\n  }\n  if (\"required\" in schema && !Array.isArray(schema.required)) {\n    return false;\n  }\n  if (\"tags\" in schema && !Array.isArray(schema.tags)) {\n    return false;\n  }\n  if (\"args\" in schema && !Array.isArray(schema.args)) {\n    return false;\n  }\n  if (\"properties\" in schema && !isSetObject(schema.properties)) {\n    return false;\n  }\n  if (\"resolve\" in schema && !isFunction(schema.resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard to check if a given input is an [untyped](https://github.com/unjs/untyped) {@link UntypedInputObject | InputObject}. This function verifies that the input is a non-null object and that any `untyped`-reserved `$`-prefixed properties have the expected shape: `$schema` (when present) must satisfy {@link isUntypedSchema} and `$resolve` (when present) must be a function. See `untyped`'s [`InputObject`](https://github.com/unjs/untyped/blob/main/src/types.ts) interface for the canonical definition.\n *\n * @param input - The input to check for being an [untyped](https://github.com/unjs/untyped) input object.\n * @returns `true` if the input is an [untyped](https://github.com/unjs/untyped) input object, otherwise `false`.\n */\nexport function isUntypedInput(input: unknown): input is UntypedInputObject {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const inputObject = input as Record<string, unknown>;\n  if (\"$schema\" in inputObject && !isUntypedSchema(inputObject.$schema)) {\n    return false;\n  }\n  if (\"$resolve\" in inputObject && !isFunction(inputObject.$resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard to check if a given input is a {@link Schema} 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 {@link Schema}; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a {@link Schema}.\n * @returns `true` if the input is a {@link Schema}, otherwise `false`.\n */\nexport function isSchema<TMetadata extends SchemaMetadata = SchemaMetadata>(\n  input: unknown\n): input is Schema<TMetadata> {\n  return (\n    isSetObject(input) &&\n    \"schema\" in input &&\n    isJTDSchema(input.schema) &&\n    \"input\" in input &&\n    isSetObject(input.input) &&\n    \"variant\" in input &&\n    isSetString(input.variant)\n  );\n}\n\n/**\n * Type guard to check if a given input is a {@link ExtractedSchema} 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 {@link ExtractedSchema}; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a {@link ExtractedSchema}.\n * @returns `true` if the input is a {@link ExtractedSchema}, otherwise `false`.\n */\nexport function isExtractedSchema<\n  TMetadata extends SchemaMetadata = SchemaMetadata\n>(input: unknown): input is ExtractedSchema<TMetadata> {\n  return (\n    isSchema<TMetadata>(input) &&\n    \"source\" in input &&\n    isSetObject(input.source) &&\n    \"schema\" in input.source &&\n    isJTDSchema(input.source.schema) &&\n    \"variant\" in input.source &&\n    isSetString(input.source.variant)\n  );\n}\n"],"mappings":";;;;;;;;;;AAiCA,SAAgB,YACd,OACmC;AACnC,QAAO,uBAAuB,MAAM,IAAI,SAAS,SAAS,MAAM,QAAQ;;;;;;;;AAS1E,SAAgB,gBAAgB,OAAwC;AACtE,KAAI,CAAC,YAAY,MAAM,CACrB,QAAO;CAGT,MAAM,SAAS;AACf,KAAI,QAAQ,UAAU,CAAC,YAAY,OAAO,GAAG,CAC3C,QAAO;AAET,KAAI,WAAW,UAAU,CAAC,YAAY,OAAO,MAAM,CACjD,QAAO;AAET,KAAI,iBAAiB,UAAU,CAAC,YAAY,OAAO,YAAY,CAC7D,QAAO;AAET,KAAI,aAAa,UAAU,CAAC,YAAY,OAAO,QAAQ,CACrD,QAAO;AAET,KAAI,YAAY,UAAU,CAAC,YAAY,OAAO,OAAO,CACnD,QAAO;AAET,KAAI,kBAAkB,UAAU,CAAC,YAAY,OAAO,aAAa,CAC/D,QAAO;AAET,KACE,UAAU,UACV,CAAC,YAAY,OAAO,KAAK,IACzB,CAAC,MAAM,QAAQ,OAAO,KAAK,CAE3B,QAAO;AAET,KAAI,cAAc,UAAU,CAAC,MAAM,QAAQ,OAAO,SAAS,CACzD,QAAO;AAET,KAAI,UAAU,UAAU,CAAC,MAAM,QAAQ,OAAO,KAAK,CACjD,QAAO;AAET,KAAI,UAAU,UAAU,CAAC,MAAM,QAAQ,OAAO,KAAK,CACjD,QAAO;AAET,KAAI,gBAAgB,UAAU,CAAC,YAAY,OAAO,WAAW,CAC3D,QAAO;AAET,KAAI,aAAa,UAAU,CAAC,WAAW,OAAO,QAAQ,CACpD,QAAO;AAGT,QAAO;;;;;;;;AAST,SAAgB,eAAe,OAA6C;AAC1E,KAAI,CAAC,YAAY,MAAM,CACrB,QAAO;CAGT,MAAM,cAAc;AACpB,KAAI,aAAa,eAAe,CAAC,gBAAgB,YAAY,QAAQ,CACnE,QAAO;AAET,KAAI,cAAc,eAAe,CAAC,WAAW,YAAY,SAAS,CAChE,QAAO;AAGT,QAAO;;;;;;;;AAST,SAAgB,SACd,OAC4B;AAC5B,QACE,YAAY,MAAM,IAClB,YAAY,SACZ,YAAY,MAAM,OAAO,IACzB,WAAW,SACX,YAAY,MAAM,MAAM,IACxB,aAAa,SACb,YAAY,MAAM,QAAQ;;;;;;;;AAU9B,SAAgB,kBAEd,OAAqD;AACrD,QACE,SAAoB,MAAM,IAC1B,YAAY,SACZ,YAAY,MAAM,OAAO,IACzB,YAAY,MAAM,UAClB,YAAY,MAAM,OAAO,OAAO,IAChC,aAAa,MAAM,UACnB,YAAY,MAAM,OAAO,QAAQ"}
+{"version":3,"file":"type-checks.mjs","names":[],"sources":["../src/type-checks.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 { isJsonSchemaObjectType } from \"@stryke/json\";\nimport {\n  isFunction,\n  isObject,\n  isSetObject,\n  isSetString\n} from \"@stryke/type-checks\";\nimport {\n  InputObject as UntypedInputObject,\n  Schema as UntypedSchema\n} from \"untyped\";\nimport { JSON_SCHEMA_DATA_TYPES } from \"./constants\";\nimport { ExtractedSchema, JsonSchema, JsonSchemaObject, Schema } from \"./types\";\n\ntype JsonSchemaDataType = (typeof JSON_SCHEMA_DATA_TYPES)[number];\n\nconst JSON_SCHEMA_DATA_TYPE_SET = new Set<JsonSchemaDataType>(\n  JSON_SCHEMA_DATA_TYPES\n);\n\ntype SchemaKeywordValidator = (value: unknown) => boolean;\n\nconst isSetNumber = (value: unknown): value is number =>\n  typeof value === \"number\" && Number.isFinite(value);\n\nconst isSetBoolean = (value: unknown): value is boolean =>\n  typeof value === \"boolean\";\n\nconst isNonNegativeInteger = (value: unknown): value is number =>\n  Number.isInteger(value) && (value as number) >= 0;\n\nconst isSchemaLikeValue = (value: unknown): boolean =>\n  isSetObject(value) || isSetBoolean(value);\n\nconst isStringArray = (value: unknown): value is string[] =>\n  Array.isArray(value) && value.every(item => isSetString(item));\n\nconst isRecordOfStringArrays = (\n  value: unknown\n): value is Record<string, string[]> =>\n  isSetObject(value) && Object.values(value).every(item => isStringArray(item));\n\nconst TYPE_KEYWORD_VALIDATORS: Record<\n  JsonSchemaDataType,\n  Record<string, SchemaKeywordValidator>\n> = {\n  string: {\n    minLength: isNonNegativeInteger,\n    maxLength: isNonNegativeInteger,\n    pattern: isSetString,\n    format: isSetString,\n    contentEncoding: isSetString,\n    contentMediaType: isSetString\n  },\n  number: {\n    minimum: isSetNumber,\n    maximum: isSetNumber,\n    exclusiveMinimum: isSetNumber,\n    exclusiveMaximum: isSetNumber,\n    multipleOf: isSetNumber\n  },\n  integer: {\n    minimum: isSetNumber,\n    maximum: isSetNumber,\n    exclusiveMinimum: isSetNumber,\n    exclusiveMaximum: isSetNumber,\n    multipleOf: isSetNumber\n  },\n  boolean: {},\n  array: {\n    items: isSchemaLikeValue,\n    prefixItems: Array.isArray,\n    contains: isSchemaLikeValue,\n    minItems: isNonNegativeInteger,\n    maxItems: isNonNegativeInteger,\n    uniqueItems: isSetBoolean,\n    minContains: isNonNegativeInteger,\n    maxContains: isNonNegativeInteger\n  },\n  object: {\n    properties: isSetObject,\n    patternProperties: isSetObject,\n    additionalProperties: isSchemaLikeValue,\n    required: isStringArray,\n    minProperties: isNonNegativeInteger,\n    maxProperties: isNonNegativeInteger,\n    dependentRequired: isRecordOfStringArrays,\n    dependentSchemas: isSetObject,\n    propertyNames: isSchemaLikeValue,\n    unevaluatedProperties: isSchemaLikeValue\n  },\n  null: {}\n};\n\n/**\n * Type guard for JSON Schema types.\n *\n * @remarks\n * This function checks if the input is a JSON Schema type, which is defined as having a `type` property or a `$ref` property. This is used to determine if a given input conforms to the structure of a JSON Schema definition that includes type information.\n *\n * @param input - The value to check.\n * @returns True if the input is a JSON Schema type, false otherwise.\n */\nexport function isJsonSchema<T = unknown>(\n  input: unknown\n): input is JsonSchema<T> {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const schema = input as Record<string, unknown>;\n\n  if (\"$ref\" in schema && isSetString(schema.$ref)) {\n    return true;\n  }\n\n  if (!(\"type\" in schema)) {\n    return false;\n  }\n\n  const schemaTypes: JsonSchemaDataType[] = [];\n\n  if (isSetString(schema.type)) {\n    if (!JSON_SCHEMA_DATA_TYPE_SET.has(schema.type as JsonSchemaDataType)) {\n      return false;\n    }\n\n    schemaTypes.push(schema.type as JsonSchemaDataType);\n  } else if (Array.isArray(schema.type) && schema.type.length > 0) {\n    if (\n      !schema.type.every(\n        schemaType =>\n          isSetString(schemaType) &&\n          JSON_SCHEMA_DATA_TYPE_SET.has(schemaType as JsonSchemaDataType)\n      ) ||\n      new Set(schema.type).size !== schema.type.length\n    ) {\n      return false;\n    }\n\n    schemaTypes.push(...(schema.type as JsonSchemaDataType[]));\n  } else {\n    return false;\n  }\n\n  const typeKeywordValidators = schemaTypes.flatMap(schemaType =>\n    Object.entries(TYPE_KEYWORD_VALIDATORS[schemaType])\n  );\n\n  for (const [keyword, validator] of typeKeywordValidators) {\n    if (keyword in schema && !validator(schema[keyword])) {\n      return false;\n    }\n  }\n\n  if (\n    \"minItems\" in schema &&\n    \"maxItems\" in schema &&\n    isNonNegativeInteger(schema.minItems) &&\n    isNonNegativeInteger(schema.maxItems) &&\n    schema.minItems > schema.maxItems\n  ) {\n    return false;\n  }\n\n  if (\n    \"minLength\" in schema &&\n    \"maxLength\" in schema &&\n    isNonNegativeInteger(schema.minLength) &&\n    isNonNegativeInteger(schema.maxLength) &&\n    schema.minLength > schema.maxLength\n  ) {\n    return false;\n  }\n\n  if (\n    \"minProperties\" in schema &&\n    \"maxProperties\" in schema &&\n    isNonNegativeInteger(schema.minProperties) &&\n    isNonNegativeInteger(schema.maxProperties) &&\n    schema.minProperties > schema.maxProperties\n  ) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for JSON Schema object forms.\n *\n * @remarks\n * This function checks if the input is a JSON Schema object type, which is defined as having a `type` property equal to \"object\" or having a `properties` object. This is used to determine if a given input conforms to the structure of a JSON Schema object definition.\n *\n * @param input - The value to check.\n * @returns True if the input is a JSON Schema object type, false otherwise.\n */\nexport function isJsonSchemaObject<\n  T extends Record<string, any> = Record<string, any>\n>(input: unknown): input is JsonSchemaObject<T> {\n  return (\n    isJsonSchemaObjectType(input) &&\n    (input.type === \"object\" || isObject(input.properties))\n  );\n}\n\n/**\n * Type guard for JSON Schemas that only accept `null`.\n *\n * @remarks\n * This function checks if the input is a JSON Schema that exclusively accepts the `null` type. It verifies that the input is a valid JSON Schema and that its `type` property is set to \"null\". This is useful for identifying schemas that are specifically designed to allow only `null` values.\n *\n * @param input - The value to check.\n * @returns True if the input is a JSON Schema that only accepts `null`, false otherwise.\n */\nexport function isNullOnlyJsonSchema(\n  input: unknown\n): input is JsonSchema<null> {\n  return isJsonSchema(input) && input.type === \"null\";\n}\n\n/**\n * Type guard for untyped schema objects.\n *\n * @remarks\n * This function checks if the input is an untyped schema object, which is defined as having certain properties that are commonly found in untyped schema definitions. This includes properties such as `id`, `title`, `description`, `$schema`, `tsType`, `markdownType`, `type`, `required`, `tags`, `args`, `properties`, and `resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., strings for certain properties, arrays for others). This type guard is used to determine if a given input can be treated as an untyped schema object within the context of the Powerlines schema system.\n *\n * @param input - The value to check.\n * @returns True if the input is an untyped schema object, false otherwise.\n */\nexport function isUntypedSchema(input: unknown): input is UntypedSchema {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const schema = input as Record<string, unknown>;\n  if (\"id\" in schema && !isSetString(schema.id)) {\n    return false;\n  }\n  if (\"title\" in schema && !isSetString(schema.title)) {\n    return false;\n  }\n  if (\"description\" in schema && !isSetString(schema.description)) {\n    return false;\n  }\n  if (\"$schema\" in schema && !isSetString(schema.$schema)) {\n    return false;\n  }\n  if (\"tsType\" in schema && !isSetString(schema.tsType)) {\n    return false;\n  }\n  if (\"markdownType\" in schema && !isSetString(schema.markdownType)) {\n    return false;\n  }\n  if (\n    \"type\" in schema &&\n    !isSetString(schema.type) &&\n    !Array.isArray(schema.type)\n  ) {\n    return false;\n  }\n  if (\"required\" in schema && !Array.isArray(schema.required)) {\n    return false;\n  }\n  if (\"tags\" in schema && !Array.isArray(schema.tags)) {\n    return false;\n  }\n  if (\"args\" in schema && !Array.isArray(schema.args)) {\n    return false;\n  }\n  if (\"properties\" in schema && !isSetObject(schema.properties)) {\n    return false;\n  }\n  if (\"resolve\" in schema && !isFunction(schema.resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for untyped input objects.\n *\n * @remarks\n * This function checks if the input is an untyped input object, which is defined as having certain properties that are commonly found in untyped input definitions. This includes properties such as `$schema` and `$resolve`. The function verifies that these properties, if present, conform to the expected types (e.g., objects for `$schema`, functions for `$resolve`). This type guard is used to determine if a given input can be treated as an untyped input object within the context of the Powerlines schema system.\n *\n * @param input - The value to check.\n * @returns True if the input is an untyped input object, false otherwise.\n */\nexport function isUntypedInput(input: unknown): input is UntypedInputObject {\n  if (!isSetObject(input)) {\n    return false;\n  }\n\n  const inputObject = input as Record<string, unknown>;\n  if (\"$schema\" in inputObject && !isUntypedSchema(inputObject.$schema)) {\n    return false;\n  }\n  if (\"$resolve\" in inputObject && !isFunction(inputObject.$resolve)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for Powerlines Schema objects.\n *\n * @param input - The value to check.\n * @returns True if the input is a Powerlines Schema object, false otherwise.\n */\nexport function isSchema<T = unknown>(input: unknown): input is Schema<T> {\n  return (\n    isSetObject(input) &&\n    \"schema\" in input &&\n    isJsonSchema(input.schema) &&\n    \"variant\" in input &&\n    isSetString(input.variant) &&\n    \"hash\" in input &&\n    isSetString(input.hash)\n  );\n}\n\nexport function isExtractedSchema<T = unknown>(\n  input: unknown\n): input is ExtractedSchema<T> {\n  return (\n    isSchema<T>(input) &&\n    \"source\" in input &&\n    isSetObject(input.source) &&\n    \"schema\" in input.source &&\n    \"variant\" in input.source &&\n    isSetString(input.source.variant)\n  );\n}\n"],"mappings":"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"}