@dynz/to-json-schema 0.0.1

package/LICENSE.md

@@ -0,0 +1,65 @@
+Business Source License
+=======================
+
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+“Business Source License” is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             Ruben van Rooij
+Licensed Works:       Dynz. The Licensed Work is
+                      (c) Ruben van Rooij
+Additional Use Grant: You may make use of the Licensed Work strictly for
+                      evaluation and/or non-production use only. Your use
+                      does not include offering the Licensed Work to third
+                      parties on a hosted or embedded basis.
+Change Date:          Four years from the date the Licensed Work is published
+Change License:       Apache-2.0
+
+For information about commercial licensing arrangements for the Licensed Work,
+please contact ruben@dynz.io.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

package/dist/index.cjs

@@ -0,0 +1,375 @@
+let dynz = require("dynz");
+
+//#region src/report-issue.ts
+/**
+* Reports an unsupported or unresolvable conversion according to the
+* configured error mode: throws, warns via `console.warn`, or is a no-op.
+*/
+function reportIssue(context, message) {
+	if (context.errorMode === "throw") throw new Error(message);
+	if (context.errorMode === "warn") console.warn(`[@dynz/to-json-schema] ${message}`);
+}
+
+//#endregion
+//#region src/resolve-static.ts
+/**
+* Attempts to extract a literal value from a rule parameter. Only values
+* wrapped with `v()`/`val()`/`st()` (i.e. `{ type: "st" }`) are statically
+* known — references, predicates and transformers depend on runtime data
+* and cannot be represented in a JSON Schema document.
+*/
+function resolveStatic(value) {
+	if (value !== void 0 && typeof value === "object" && "type" in value && value.type === "st") return {
+		ok: true,
+		value: value.value
+	};
+	return { ok: false };
+}
+
+//#endregion
+//#region src/convert-rules.ts
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Writes a keyword, preserving whatever constraint is already there.
+*
+* Several dynz rules map onto the same JSON Schema keyword: two `regex` rules both want
+* `pattern`, `one_of` wants the `enum` an options schema has already produced,
+* `not_includes` and `not_one_of` both want `not`. A plain assignment would silently drop
+* the constraint that got there first, so a second writer is moved into `allOf` — where
+* both still have to hold.
+*/
+function setKeyword(jsonSchema, keyword, value) {
+	if (jsonSchema[keyword] === void 0) {
+		jsonSchema[keyword] = value;
+		return;
+	}
+	jsonSchema.allOf = [...jsonSchema.allOf ?? [], { [keyword]: value }];
+}
+/**
+* Applies a dynz rule to a JSON Schema in place. Rules whose value can't be
+* statically resolved (references, predicates, transformers) or that have
+* no JSON Schema equivalent are skipped and reported via `reportIssue`.
+*/
+function applyRule(jsonSchema, rule, schemaType, context) {
+	switch (rule.type) {
+		case "min": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) setKeyword(jsonSchema, "minimum", min.value);
+			else reportIssue(context, `"min" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) setKeyword(jsonSchema, "maximum", max.value);
+			else reportIssue(context, `"max" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "min_length": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) if (schemaType === "array") setKeyword(jsonSchema, "minItems", min.value);
+			else setKeyword(jsonSchema, "minLength", min.value);
+			else reportIssue(context, `"min_length" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_length": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) if (schemaType === "array") setKeyword(jsonSchema, "maxItems", max.value);
+			else setKeyword(jsonSchema, "maxLength", max.value);
+			else reportIssue(context, `"max_length" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "min_entries": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) setKeyword(jsonSchema, "minProperties", min.value);
+			else reportIssue(context, `"min_entries" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_entries": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) setKeyword(jsonSchema, "maxProperties", max.value);
+			else reportIssue(context, `"max_entries" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_precision": {
+			const maxPrecision = resolveStatic(rule.maxPrecision);
+			if (maxPrecision.ok) setKeyword(jsonSchema, "multipleOf", 1 / 10 ** maxPrecision.value);
+			else reportIssue(context, `"max_precision" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "regex":
+			setKeyword(jsonSchema, "pattern", rule.regex);
+			if (rule.flags) reportIssue(context, `"regex" rule flags ("${rule.flags}") cannot be represented in JSON Schema's "pattern" keyword and were ignored.`);
+			break;
+		case "email":
+			setKeyword(jsonSchema, "format", "email");
+			break;
+		case "is_numeric":
+			setKeyword(jsonSchema, "pattern", "^[+-]?\\d+(\\.\\d+)?$");
+			break;
+		case "equals": {
+			const equals = resolveStatic(rule.equals);
+			if (equals.ok) setKeyword(jsonSchema, "const", equals.value);
+			else reportIssue(context, `"equals" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "includes": {
+			const includes = resolveStatic(rule.includes);
+			if (!includes.ok) {
+				reportIssue(context, `"includes" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			if (schemaType === "array") setKeyword(jsonSchema, "contains", { const: includes.value });
+			else setKeyword(jsonSchema, "pattern", escapeRegExp(String(includes.value)));
+			break;
+		}
+		case "not_includes": {
+			const notIncludes = resolveStatic(rule.notIncludes);
+			if (!notIncludes.ok) {
+				reportIssue(context, `"not_includes" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			setKeyword(jsonSchema, "not", schemaType === "array" ? { contains: { const: notIncludes.value } } : { pattern: escapeRegExp(String(notIncludes.value)) });
+			break;
+		}
+		case "one_of": {
+			const values = [];
+			for (const value of rule.values) {
+				const resolved = resolveStatic(value);
+				if (!resolved.ok) {
+					reportIssue(context, `"one_of" rule with a non-static value cannot be converted to JSON Schema.`);
+					return;
+				}
+				values.push(resolved.value);
+			}
+			setKeyword(jsonSchema, "enum", values);
+			break;
+		}
+		case "not_one_of": {
+			const values = [];
+			for (const value of rule.values) {
+				const resolved = resolveStatic(value);
+				if (!resolved.ok) {
+					reportIssue(context, `"not_one_of" rule with a non-static value cannot be converted to JSON Schema.`);
+					return;
+				}
+				values.push(resolved.value);
+			}
+			setKeyword(jsonSchema, "not", { enum: values });
+			break;
+		}
+		case "mime_type": {
+			const mimeType = resolveStatic(rule.mimeType);
+			if (!mimeType.ok) {
+				reportIssue(context, `"mime_type" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			if (typeof mimeType.value === "string") setKeyword(jsonSchema, "contentMediaType", mimeType.value);
+			else if (Array.isArray(mimeType.value) && mimeType.value.length === 1) setKeyword(jsonSchema, "contentMediaType", mimeType.value[0]);
+			else reportIssue(context, `"mime_type" rule with multiple mime types has no JSON Schema equivalent.`);
+			break;
+		}
+		case "min_date":
+		case "max_date":
+		case "before":
+		case "after":
+			reportIssue(context, `"${rule.type}" rule has no JSON Schema equivalent (date comparisons aren't representable).`);
+			break;
+		case "min_size":
+		case "max_size":
+			reportIssue(context, `"${rule.type}" rule has no JSON Schema equivalent (byte-size constraints aren't representable).`);
+			break;
+		case "custom":
+			reportIssue(context, `"custom" rule "${rule.name}" has no JSON Schema equivalent.`);
+			break;
+		case "conditional":
+			reportIssue(context, `"conditional" rule has no JSON Schema equivalent.`);
+			break;
+		default: reportIssue(context, `Unknown rule cannot be converted to JSON Schema.`);
+	}
+}
+function applyRules(jsonSchema, rules, schemaType, context) {
+	for (const rule of rules ?? []) applyRule(jsonSchema, rule, schemaType, context);
+}
+
+//#endregion
+//#region src/convert-schema.ts
+function isMandatory(schema) {
+	const isIncluded = schema.included === void 0 || schema.included === true;
+	const isRequired = schema.required === void 0 || schema.required === true;
+	return isIncluded && isRequired;
+}
+function jsonTypeOf(value) {
+	return typeof value;
+}
+function applyEnumValues(jsonSchema, values) {
+	jsonSchema.enum = values;
+	const types = Array.from(new Set(values.map(jsonTypeOf)));
+	if (types.length === 1) jsonSchema.type = types[0];
+	else if (types.length > 1) jsonSchema.type = types;
+}
+function collectOptionValues(options, context) {
+	const values = [];
+	const visit = (option) => {
+		if (typeof option !== "object") {
+			values.push(option);
+			return;
+		}
+		if (option.enabled === false) return;
+		if (typeof option.enabled === "object") reportIssue(context, `An "options" entry has a predicate-based "enabled" flag; whether it's enabled can't be determined statically, so it was included in the JSON Schema "enum" anyway.`);
+		visit(option.value);
+	};
+	for (const option of options) visit(option);
+	return values;
+}
+function isSchema(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function shouldOmitField(schema, context) {
+	if (schema.included === false) return true;
+	return context.mode === "input" && schema.type === dynz.SchemaType.EXPRESSION;
+}
+function applyPrivacyWrapper(schema, innerSchema) {
+	if (schema.private !== true) return innerSchema;
+	return { oneOf: [{
+		type: "object",
+		properties: {
+			state: { const: "plain" },
+			value: innerSchema
+		},
+		required: ["state"]
+	}, {
+		type: "object",
+		properties: {
+			state: { const: "masked" },
+			value: { type: "string" }
+		},
+		required: ["state", "value"]
+	}] };
+}
+function applyDefault(schema, jsonSchema) {
+	if (schema.default === void 0) return;
+	jsonSchema.default = schema.default instanceof Date ? schema.default.toISOString() : schema.default;
+}
+/**
+* Converts a dynz schema to a JSON Schema (2020-12) document. Rule values
+* and schema kinds without a JSON Schema equivalent are handled per
+* `context.errorMode`.
+*/
+function convertSchema(schema, context) {
+	const jsonSchema = convertSchemaKind(schema, context);
+	applyDefault(schema, jsonSchema);
+	return applyPrivacyWrapper(schema, jsonSchema);
+}
+function convertSchemaKind(schema, context) {
+	switch (schema.type) {
+		case dynz.SchemaType.STRING: {
+			const jsonSchema = { type: "string" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.NUMBER: {
+			const jsonSchema = { type: "number" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.BOOLEAN: {
+			const jsonSchema = { type: "boolean" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.DATE: {
+			const jsonSchema = {
+				type: "string",
+				format: "date-time"
+			};
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.LITERAL: return { const: schema.value };
+		case dynz.SchemaType.ENUM: {
+			const jsonSchema = {};
+			applyEnumValues(jsonSchema, Object.values(schema.enum));
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.OPTIONS: {
+			const jsonSchema = {};
+			applyEnumValues(jsonSchema, collectOptionValues(schema.options, context));
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.FILE: {
+			const jsonSchema = { type: "string" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.EXPRESSION: return {};
+		case dynz.SchemaType.ARRAY: {
+			const jsonSchema = {
+				type: "array",
+				items: convertSchema(schema.schema, context)
+			};
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.OBJECT: {
+			const properties = {};
+			const required = [];
+			for (const [key, fieldSchema] of Object.entries(schema.fields)) {
+				if (shouldOmitField(fieldSchema, context)) continue;
+				properties[key] = convertSchema(fieldSchema, context);
+				if (isMandatory(fieldSchema)) required.push(key);
+			}
+			const jsonSchema = {
+				type: "object",
+				properties
+			};
+			if (required.length > 0) jsonSchema.required = required;
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case dynz.SchemaType.DISCRIMINATED_UNION: return { oneOf: schema.schemas.map((member) => {
+			const properties = { [schema.key]: { const: member[schema.key] } };
+			const required = [schema.key];
+			for (const [key, value] of Object.entries(member)) {
+				if (key === schema.key || !isSchema(value) || shouldOmitField(value, context)) continue;
+				properties[key] = convertSchema(value, context);
+				if (isMandatory(value)) required.push(key);
+			}
+			return {
+				type: "object",
+				properties,
+				required
+			};
+		}) };
+		default:
+			reportIssue(context, `Unknown schema type cannot be converted to JSON Schema.`);
+			return {};
+	}
+}
+
+//#endregion
+//#region src/to-standard-json-schema.ts
+/**
+* Converts a dynz schema to a standard JSON Schema (2020-12) document.
+*
+* Rule values that depend on runtime data (references, predicates,
+* transformers) and schema kinds without a JSON Schema equivalent are
+* handled according to `config.errorMode` (default `"warn"`). Whether
+* `expression` fields are included is controlled by `config.mode`
+* (default `"input"`, which omits them).
+*/
+function toStandardJsonSchema(schema, config = {}) {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		...convertSchema(schema, {
+			errorMode: config.errorMode ?? "warn",
+			mode: config.mode ?? "input"
+		})
+	};
+}
+
+//#endregion
+exports.toStandardJsonSchema = toStandardJsonSchema;

package/dist/index.d.cts

@@ -0,0 +1,73 @@
+import { Schema } from "dynz";
+
+//#region src/types.d.ts
+
+/**
+ * A JSON Schema (2020-12) document. Loosely typed since the shape varies
+ * significantly by keyword combination.
+ */
+interface JsonSchema {
+  $schema?: string;
+  type?: string | string[];
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: unknown[];
+  const?: unknown;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
+  minProperties?: number;
+  maxProperties?: number;
+  pattern?: string;
+  format?: string;
+  multipleOf?: number;
+  contentMediaType?: string;
+  contains?: JsonSchema;
+  not?: JsonSchema;
+  oneOf?: JsonSchema[];
+  allOf?: JsonSchema[];
+  default?: unknown;
+  [key: string]: unknown;
+}
+/**
+ * The policy for handling schema kinds/rule values that cannot be
+ * represented in JSON Schema.
+ */
+type ErrorMode = "throw" | "warn" | "ignore";
+/**
+ * Whether the conversion targets the data a consumer sends in (`"input"`)
+ * or the data dynz produces after validation (`"output"`). `expression`
+ * schemas are computed/derived values that are never part of the input, so
+ * in `"input"` mode they're silently removed from the generated schema; in
+ * `"output"` mode they're included (using their best-effort mapping).
+ */
+type ConversionMode = "input" | "output";
+interface ConversionConfig {
+  /**
+   * Policy for handling unsupported/unresolvable rule values and schema
+   * kinds. Defaults to `"warn"`.
+   */
+  errorMode?: ErrorMode;
+  /**
+   * Whether to convert for input or output data. Defaults to `"input"`.
+   */
+  mode?: ConversionMode;
+}
+//#endregion
+//#region src/to-standard-json-schema.d.ts
+/**
+ * Converts a dynz schema to a standard JSON Schema (2020-12) document.
+ *
+ * Rule values that depend on runtime data (references, predicates,
+ * transformers) and schema kinds without a JSON Schema equivalent are
+ * handled according to `config.errorMode` (default `"warn"`). Whether
+ * `expression` fields are included is controlled by `config.mode`
+ * (default `"input"`, which omits them).
+ */
+declare function toStandardJsonSchema<T extends Schema>(schema: T, config?: ConversionConfig): JsonSchema;
+//#endregion
+export { type ConversionConfig, type ErrorMode, type JsonSchema, toStandardJsonSchema };

package/dist/index.d.mts

@@ -0,0 +1,73 @@
+import { Schema } from "dynz";
+
+//#region src/types.d.ts
+
+/**
+ * A JSON Schema (2020-12) document. Loosely typed since the shape varies
+ * significantly by keyword combination.
+ */
+interface JsonSchema {
+  $schema?: string;
+  type?: string | string[];
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: unknown[];
+  const?: unknown;
+  minimum?: number;
+  maximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  minItems?: number;
+  maxItems?: number;
+  minProperties?: number;
+  maxProperties?: number;
+  pattern?: string;
+  format?: string;
+  multipleOf?: number;
+  contentMediaType?: string;
+  contains?: JsonSchema;
+  not?: JsonSchema;
+  oneOf?: JsonSchema[];
+  allOf?: JsonSchema[];
+  default?: unknown;
+  [key: string]: unknown;
+}
+/**
+ * The policy for handling schema kinds/rule values that cannot be
+ * represented in JSON Schema.
+ */
+type ErrorMode = "throw" | "warn" | "ignore";
+/**
+ * Whether the conversion targets the data a consumer sends in (`"input"`)
+ * or the data dynz produces after validation (`"output"`). `expression`
+ * schemas are computed/derived values that are never part of the input, so
+ * in `"input"` mode they're silently removed from the generated schema; in
+ * `"output"` mode they're included (using their best-effort mapping).
+ */
+type ConversionMode = "input" | "output";
+interface ConversionConfig {
+  /**
+   * Policy for handling unsupported/unresolvable rule values and schema
+   * kinds. Defaults to `"warn"`.
+   */
+  errorMode?: ErrorMode;
+  /**
+   * Whether to convert for input or output data. Defaults to `"input"`.
+   */
+  mode?: ConversionMode;
+}
+//#endregion
+//#region src/to-standard-json-schema.d.ts
+/**
+ * Converts a dynz schema to a standard JSON Schema (2020-12) document.
+ *
+ * Rule values that depend on runtime data (references, predicates,
+ * transformers) and schema kinds without a JSON Schema equivalent are
+ * handled according to `config.errorMode` (default `"warn"`). Whether
+ * `expression` fields are included is controlled by `config.mode`
+ * (default `"input"`, which omits them).
+ */
+declare function toStandardJsonSchema<T extends Schema>(schema: T, config?: ConversionConfig): JsonSchema;
+//#endregion
+export { type ConversionConfig, type ErrorMode, type JsonSchema, toStandardJsonSchema };

package/dist/index.min.cjs

@@ -0,0 +1 @@
+let e=require(`dynz`);function t(e,t){if(e.errorMode===`throw`)throw Error(t);e.errorMode===`warn`&&console.warn(`[@dynz/to-json-schema] ${t}`)}function n(e){return e!==void 0&&typeof e==`object`&&`type`in e&&e.type===`st`?{ok:!0,value:e.value}:{ok:!1}}function r(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}function i(e,t,n){if(e[t]===void 0){e[t]=n;return}e.allOf=[...e.allOf??[],{[t]:n}]}function a(e,a,o,s){switch(a.type){case`min`:{let r=n(a.min);r.ok?i(e,`minimum`,r.value):t(s,`"min" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max`:{let r=n(a.max);r.ok?i(e,`maximum`,r.value):t(s,`"max" rule with a non-static value cannot be converted to JSON Schema.`);break}case`min_length`:{let r=n(a.min);r.ok?o===`array`?i(e,`minItems`,r.value):i(e,`minLength`,r.value):t(s,`"min_length" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_length`:{let r=n(a.max);r.ok?o===`array`?i(e,`maxItems`,r.value):i(e,`maxLength`,r.value):t(s,`"max_length" rule with a non-static value cannot be converted to JSON Schema.`);break}case`min_entries`:{let r=n(a.min);r.ok?i(e,`minProperties`,r.value):t(s,`"min_entries" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_entries`:{let r=n(a.max);r.ok?i(e,`maxProperties`,r.value):t(s,`"max_entries" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_precision`:{let r=n(a.maxPrecision);r.ok?i(e,`multipleOf`,1/10**r.value):t(s,`"max_precision" rule with a non-static value cannot be converted to JSON Schema.`);break}case`regex`:i(e,`pattern`,a.regex),a.flags&&t(s,`"regex" rule flags ("${a.flags}") cannot be represented in JSON Schema's "pattern" keyword and were ignored.`);break;case`email`:i(e,`format`,`email`);break;case`is_numeric`:i(e,`pattern`,`^[+-]?\\d+(\\.\\d+)?$`);break;case`equals`:{let r=n(a.equals);r.ok?i(e,`const`,r.value):t(s,`"equals" rule with a non-static value cannot be converted to JSON Schema.`);break}case`includes`:{let c=n(a.includes);if(!c.ok){t(s,`"includes" rule with a non-static value cannot be converted to JSON Schema.`);break}o===`array`?i(e,`contains`,{const:c.value}):i(e,`pattern`,r(String(c.value)));break}case`not_includes`:{let c=n(a.notIncludes);if(!c.ok){t(s,`"not_includes" rule with a non-static value cannot be converted to JSON Schema.`);break}i(e,`not`,o===`array`?{contains:{const:c.value}}:{pattern:r(String(c.value))});break}case`one_of`:{let r=[];for(let e of a.values){let i=n(e);if(!i.ok){t(s,`"one_of" rule with a non-static value cannot be converted to JSON Schema.`);return}r.push(i.value)}i(e,`enum`,r);break}case`not_one_of`:{let r=[];for(let e of a.values){let i=n(e);if(!i.ok){t(s,`"not_one_of" rule with a non-static value cannot be converted to JSON Schema.`);return}r.push(i.value)}i(e,`not`,{enum:r});break}case`mime_type`:{let r=n(a.mimeType);if(!r.ok){t(s,`"mime_type" rule with a non-static value cannot be converted to JSON Schema.`);break}typeof r.value==`string`?i(e,`contentMediaType`,r.value):Array.isArray(r.value)&&r.value.length===1?i(e,`contentMediaType`,r.value[0]):t(s,`"mime_type" rule with multiple mime types has no JSON Schema equivalent.`);break}case`min_date`:case`max_date`:case`before`:case`after`:t(s,`"${a.type}" rule has no JSON Schema equivalent (date comparisons aren't representable).`);break;case`min_size`:case`max_size`:t(s,`"${a.type}" rule has no JSON Schema equivalent (byte-size constraints aren't representable).`);break;case`custom`:t(s,`"custom" rule "${a.name}" has no JSON Schema equivalent.`);break;case`conditional`:t(s,`"conditional" rule has no JSON Schema equivalent.`);break;default:t(s,`Unknown rule cannot be converted to JSON Schema.`)}}function o(e,t,n,r){for(let i of t??[])a(e,i,n,r)}function s(e){let t=e.included===void 0||e.included===!0,n=e.required===void 0||e.required===!0;return t&&n}function c(e){return typeof e}function l(e,t){e.enum=t;let n=Array.from(new Set(t.map(c)));n.length===1?e.type=n[0]:n.length>1&&(e.type=n)}function u(e,n){let r=[],i=e=>{if(typeof e!=`object`){r.push(e);return}e.enabled!==!1&&(typeof e.enabled==`object`&&t(n,`An "options" entry has a predicate-based "enabled" flag; whether it's enabled can't be determined statically, so it was included in the JSON Schema "enum" anyway.`),i(e.value))};for(let t of e)i(t);return r}function d(e){return typeof e==`object`&&!!e&&`type`in e}function f(t,n){return t.included===!1?!0:n.mode===`input`&&t.type===e.SchemaType.EXPRESSION}function p(e,t){return e.private===!0?{oneOf:[{type:`object`,properties:{state:{const:`plain`},value:t},required:[`state`]},{type:`object`,properties:{state:{const:`masked`},value:{type:`string`}},required:[`state`,`value`]}]}:t}function m(e,t){e.default!==void 0&&(t.default=e.default instanceof Date?e.default.toISOString():e.default)}function h(e,t){let n=g(e,t);return m(e,n),p(e,n)}function g(n,r){switch(n.type){case e.SchemaType.STRING:{let e={type:`string`};return o(e,n.rules,n.type,r),e}case e.SchemaType.NUMBER:{let e={type:`number`};return o(e,n.rules,n.type,r),e}case e.SchemaType.BOOLEAN:{let e={type:`boolean`};return o(e,n.rules,n.type,r),e}case e.SchemaType.DATE:{let e={type:`string`,format:`date-time`};return o(e,n.rules,n.type,r),e}case e.SchemaType.LITERAL:return{const:n.value};case e.SchemaType.ENUM:{let e={};return l(e,Object.values(n.enum)),o(e,n.rules,n.type,r),e}case e.SchemaType.OPTIONS:{let e={};return l(e,u(n.options,r)),o(e,n.rules,n.type,r),e}case e.SchemaType.FILE:{let e={type:`string`};return o(e,n.rules,n.type,r),e}case e.SchemaType.EXPRESSION:return{};case e.SchemaType.ARRAY:{let e={type:`array`,items:h(n.schema,r)};return o(e,n.rules,n.type,r),e}case e.SchemaType.OBJECT:{let e={},t=[];for(let[i,a]of Object.entries(n.fields))f(a,r)||(e[i]=h(a,r),s(a)&&t.push(i));let i={type:`object`,properties:e};return t.length>0&&(i.required=t),o(i,n.rules,n.type,r),i}case e.SchemaType.DISCRIMINATED_UNION:return{oneOf:n.schemas.map(e=>{let t={[n.key]:{const:e[n.key]}},i=[n.key];for(let[a,o]of Object.entries(e))a===n.key||!d(o)||f(o,r)||(t[a]=h(o,r),s(o)&&i.push(a));return{type:`object`,properties:t,required:i}})};default:return t(r,`Unknown schema type cannot be converted to JSON Schema.`),{}}}function _(e,t={}){return{$schema:`https://json-schema.org/draft/2020-12/schema`,...h(e,{errorMode:t.errorMode??`warn`,mode:t.mode??`input`})}}exports.toStandardJsonSchema=_;

package/dist/index.min.js

@@ -0,0 +1 @@
+import{SchemaType as e}from"dynz";function t(e,t){if(e.errorMode===`throw`)throw Error(t);e.errorMode===`warn`&&console.warn(`[@dynz/to-json-schema] ${t}`)}function n(e){return e!==void 0&&typeof e==`object`&&`type`in e&&e.type===`st`?{ok:!0,value:e.value}:{ok:!1}}function r(e){return e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}function i(e,t,n){if(e[t]===void 0){e[t]=n;return}e.allOf=[...e.allOf??[],{[t]:n}]}function a(e,a,o,s){switch(a.type){case`min`:{let r=n(a.min);r.ok?i(e,`minimum`,r.value):t(s,`"min" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max`:{let r=n(a.max);r.ok?i(e,`maximum`,r.value):t(s,`"max" rule with a non-static value cannot be converted to JSON Schema.`);break}case`min_length`:{let r=n(a.min);r.ok?o===`array`?i(e,`minItems`,r.value):i(e,`minLength`,r.value):t(s,`"min_length" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_length`:{let r=n(a.max);r.ok?o===`array`?i(e,`maxItems`,r.value):i(e,`maxLength`,r.value):t(s,`"max_length" rule with a non-static value cannot be converted to JSON Schema.`);break}case`min_entries`:{let r=n(a.min);r.ok?i(e,`minProperties`,r.value):t(s,`"min_entries" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_entries`:{let r=n(a.max);r.ok?i(e,`maxProperties`,r.value):t(s,`"max_entries" rule with a non-static value cannot be converted to JSON Schema.`);break}case`max_precision`:{let r=n(a.maxPrecision);r.ok?i(e,`multipleOf`,1/10**r.value):t(s,`"max_precision" rule with a non-static value cannot be converted to JSON Schema.`);break}case`regex`:i(e,`pattern`,a.regex),a.flags&&t(s,`"regex" rule flags ("${a.flags}") cannot be represented in JSON Schema's "pattern" keyword and were ignored.`);break;case`email`:i(e,`format`,`email`);break;case`is_numeric`:i(e,`pattern`,`^[+-]?\\d+(\\.\\d+)?$`);break;case`equals`:{let r=n(a.equals);r.ok?i(e,`const`,r.value):t(s,`"equals" rule with a non-static value cannot be converted to JSON Schema.`);break}case`includes`:{let c=n(a.includes);if(!c.ok){t(s,`"includes" rule with a non-static value cannot be converted to JSON Schema.`);break}o===`array`?i(e,`contains`,{const:c.value}):i(e,`pattern`,r(String(c.value)));break}case`not_includes`:{let c=n(a.notIncludes);if(!c.ok){t(s,`"not_includes" rule with a non-static value cannot be converted to JSON Schema.`);break}i(e,`not`,o===`array`?{contains:{const:c.value}}:{pattern:r(String(c.value))});break}case`one_of`:{let r=[];for(let e of a.values){let i=n(e);if(!i.ok){t(s,`"one_of" rule with a non-static value cannot be converted to JSON Schema.`);return}r.push(i.value)}i(e,`enum`,r);break}case`not_one_of`:{let r=[];for(let e of a.values){let i=n(e);if(!i.ok){t(s,`"not_one_of" rule with a non-static value cannot be converted to JSON Schema.`);return}r.push(i.value)}i(e,`not`,{enum:r});break}case`mime_type`:{let r=n(a.mimeType);if(!r.ok){t(s,`"mime_type" rule with a non-static value cannot be converted to JSON Schema.`);break}typeof r.value==`string`?i(e,`contentMediaType`,r.value):Array.isArray(r.value)&&r.value.length===1?i(e,`contentMediaType`,r.value[0]):t(s,`"mime_type" rule with multiple mime types has no JSON Schema equivalent.`);break}case`min_date`:case`max_date`:case`before`:case`after`:t(s,`"${a.type}" rule has no JSON Schema equivalent (date comparisons aren't representable).`);break;case`min_size`:case`max_size`:t(s,`"${a.type}" rule has no JSON Schema equivalent (byte-size constraints aren't representable).`);break;case`custom`:t(s,`"custom" rule "${a.name}" has no JSON Schema equivalent.`);break;case`conditional`:t(s,`"conditional" rule has no JSON Schema equivalent.`);break;default:t(s,`Unknown rule cannot be converted to JSON Schema.`)}}function o(e,t,n,r){for(let i of t??[])a(e,i,n,r)}function s(e){let t=e.included===void 0||e.included===!0,n=e.required===void 0||e.required===!0;return t&&n}function c(e){return typeof e}function l(e,t){e.enum=t;let n=Array.from(new Set(t.map(c)));n.length===1?e.type=n[0]:n.length>1&&(e.type=n)}function u(e,n){let r=[],i=e=>{if(typeof e!=`object`){r.push(e);return}e.enabled!==!1&&(typeof e.enabled==`object`&&t(n,`An "options" entry has a predicate-based "enabled" flag; whether it's enabled can't be determined statically, so it was included in the JSON Schema "enum" anyway.`),i(e.value))};for(let t of e)i(t);return r}function d(e){return typeof e==`object`&&!!e&&`type`in e}function f(t,n){return t.included===!1?!0:n.mode===`input`&&t.type===e.EXPRESSION}function p(e,t){return e.private===!0?{oneOf:[{type:`object`,properties:{state:{const:`plain`},value:t},required:[`state`]},{type:`object`,properties:{state:{const:`masked`},value:{type:`string`}},required:[`state`,`value`]}]}:t}function m(e,t){e.default!==void 0&&(t.default=e.default instanceof Date?e.default.toISOString():e.default)}function h(e,t){let n=g(e,t);return m(e,n),p(e,n)}function g(n,r){switch(n.type){case e.STRING:{let e={type:`string`};return o(e,n.rules,n.type,r),e}case e.NUMBER:{let e={type:`number`};return o(e,n.rules,n.type,r),e}case e.BOOLEAN:{let e={type:`boolean`};return o(e,n.rules,n.type,r),e}case e.DATE:{let e={type:`string`,format:`date-time`};return o(e,n.rules,n.type,r),e}case e.LITERAL:return{const:n.value};case e.ENUM:{let e={};return l(e,Object.values(n.enum)),o(e,n.rules,n.type,r),e}case e.OPTIONS:{let e={};return l(e,u(n.options,r)),o(e,n.rules,n.type,r),e}case e.FILE:{let e={type:`string`};return o(e,n.rules,n.type,r),e}case e.EXPRESSION:return{};case e.ARRAY:{let e={type:`array`,items:h(n.schema,r)};return o(e,n.rules,n.type,r),e}case e.OBJECT:{let e={},t=[];for(let[i,a]of Object.entries(n.fields))f(a,r)||(e[i]=h(a,r),s(a)&&t.push(i));let i={type:`object`,properties:e};return t.length>0&&(i.required=t),o(i,n.rules,n.type,r),i}case e.DISCRIMINATED_UNION:return{oneOf:n.schemas.map(e=>{let t={[n.key]:{const:e[n.key]}},i=[n.key];for(let[a,o]of Object.entries(e))a===n.key||!d(o)||f(o,r)||(t[a]=h(o,r),s(o)&&i.push(a));return{type:`object`,properties:t,required:i}})};default:return t(r,`Unknown schema type cannot be converted to JSON Schema.`),{}}}function _(e,t={}){return{$schema:`https://json-schema.org/draft/2020-12/schema`,...h(e,{errorMode:t.errorMode??`warn`,mode:t.mode??`input`})}}export{_ as toStandardJsonSchema};

package/dist/index.mjs

@@ -0,0 +1,375 @@
+import { SchemaType } from "dynz";
+
+//#region src/report-issue.ts
+/**
+* Reports an unsupported or unresolvable conversion according to the
+* configured error mode: throws, warns via `console.warn`, or is a no-op.
+*/
+function reportIssue(context, message) {
+	if (context.errorMode === "throw") throw new Error(message);
+	if (context.errorMode === "warn") console.warn(`[@dynz/to-json-schema] ${message}`);
+}
+
+//#endregion
+//#region src/resolve-static.ts
+/**
+* Attempts to extract a literal value from a rule parameter. Only values
+* wrapped with `v()`/`val()`/`st()` (i.e. `{ type: "st" }`) are statically
+* known — references, predicates and transformers depend on runtime data
+* and cannot be represented in a JSON Schema document.
+*/
+function resolveStatic(value) {
+	if (value !== void 0 && typeof value === "object" && "type" in value && value.type === "st") return {
+		ok: true,
+		value: value.value
+	};
+	return { ok: false };
+}
+
+//#endregion
+//#region src/convert-rules.ts
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Writes a keyword, preserving whatever constraint is already there.
+*
+* Several dynz rules map onto the same JSON Schema keyword: two `regex` rules both want
+* `pattern`, `one_of` wants the `enum` an options schema has already produced,
+* `not_includes` and `not_one_of` both want `not`. A plain assignment would silently drop
+* the constraint that got there first, so a second writer is moved into `allOf` — where
+* both still have to hold.
+*/
+function setKeyword(jsonSchema, keyword, value) {
+	if (jsonSchema[keyword] === void 0) {
+		jsonSchema[keyword] = value;
+		return;
+	}
+	jsonSchema.allOf = [...jsonSchema.allOf ?? [], { [keyword]: value }];
+}
+/**
+* Applies a dynz rule to a JSON Schema in place. Rules whose value can't be
+* statically resolved (references, predicates, transformers) or that have
+* no JSON Schema equivalent are skipped and reported via `reportIssue`.
+*/
+function applyRule(jsonSchema, rule, schemaType, context) {
+	switch (rule.type) {
+		case "min": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) setKeyword(jsonSchema, "minimum", min.value);
+			else reportIssue(context, `"min" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) setKeyword(jsonSchema, "maximum", max.value);
+			else reportIssue(context, `"max" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "min_length": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) if (schemaType === "array") setKeyword(jsonSchema, "minItems", min.value);
+			else setKeyword(jsonSchema, "minLength", min.value);
+			else reportIssue(context, `"min_length" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_length": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) if (schemaType === "array") setKeyword(jsonSchema, "maxItems", max.value);
+			else setKeyword(jsonSchema, "maxLength", max.value);
+			else reportIssue(context, `"max_length" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "min_entries": {
+			const min = resolveStatic(rule.min);
+			if (min.ok) setKeyword(jsonSchema, "minProperties", min.value);
+			else reportIssue(context, `"min_entries" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_entries": {
+			const max = resolveStatic(rule.max);
+			if (max.ok) setKeyword(jsonSchema, "maxProperties", max.value);
+			else reportIssue(context, `"max_entries" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "max_precision": {
+			const maxPrecision = resolveStatic(rule.maxPrecision);
+			if (maxPrecision.ok) setKeyword(jsonSchema, "multipleOf", 1 / 10 ** maxPrecision.value);
+			else reportIssue(context, `"max_precision" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "regex":
+			setKeyword(jsonSchema, "pattern", rule.regex);
+			if (rule.flags) reportIssue(context, `"regex" rule flags ("${rule.flags}") cannot be represented in JSON Schema's "pattern" keyword and were ignored.`);
+			break;
+		case "email":
+			setKeyword(jsonSchema, "format", "email");
+			break;
+		case "is_numeric":
+			setKeyword(jsonSchema, "pattern", "^[+-]?\\d+(\\.\\d+)?$");
+			break;
+		case "equals": {
+			const equals = resolveStatic(rule.equals);
+			if (equals.ok) setKeyword(jsonSchema, "const", equals.value);
+			else reportIssue(context, `"equals" rule with a non-static value cannot be converted to JSON Schema.`);
+			break;
+		}
+		case "includes": {
+			const includes = resolveStatic(rule.includes);
+			if (!includes.ok) {
+				reportIssue(context, `"includes" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			if (schemaType === "array") setKeyword(jsonSchema, "contains", { const: includes.value });
+			else setKeyword(jsonSchema, "pattern", escapeRegExp(String(includes.value)));
+			break;
+		}
+		case "not_includes": {
+			const notIncludes = resolveStatic(rule.notIncludes);
+			if (!notIncludes.ok) {
+				reportIssue(context, `"not_includes" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			setKeyword(jsonSchema, "not", schemaType === "array" ? { contains: { const: notIncludes.value } } : { pattern: escapeRegExp(String(notIncludes.value)) });
+			break;
+		}
+		case "one_of": {
+			const values = [];
+			for (const value of rule.values) {
+				const resolved = resolveStatic(value);
+				if (!resolved.ok) {
+					reportIssue(context, `"one_of" rule with a non-static value cannot be converted to JSON Schema.`);
+					return;
+				}
+				values.push(resolved.value);
+			}
+			setKeyword(jsonSchema, "enum", values);
+			break;
+		}
+		case "not_one_of": {
+			const values = [];
+			for (const value of rule.values) {
+				const resolved = resolveStatic(value);
+				if (!resolved.ok) {
+					reportIssue(context, `"not_one_of" rule with a non-static value cannot be converted to JSON Schema.`);
+					return;
+				}
+				values.push(resolved.value);
+			}
+			setKeyword(jsonSchema, "not", { enum: values });
+			break;
+		}
+		case "mime_type": {
+			const mimeType = resolveStatic(rule.mimeType);
+			if (!mimeType.ok) {
+				reportIssue(context, `"mime_type" rule with a non-static value cannot be converted to JSON Schema.`);
+				break;
+			}
+			if (typeof mimeType.value === "string") setKeyword(jsonSchema, "contentMediaType", mimeType.value);
+			else if (Array.isArray(mimeType.value) && mimeType.value.length === 1) setKeyword(jsonSchema, "contentMediaType", mimeType.value[0]);
+			else reportIssue(context, `"mime_type" rule with multiple mime types has no JSON Schema equivalent.`);
+			break;
+		}
+		case "min_date":
+		case "max_date":
+		case "before":
+		case "after":
+			reportIssue(context, `"${rule.type}" rule has no JSON Schema equivalent (date comparisons aren't representable).`);
+			break;
+		case "min_size":
+		case "max_size":
+			reportIssue(context, `"${rule.type}" rule has no JSON Schema equivalent (byte-size constraints aren't representable).`);
+			break;
+		case "custom":
+			reportIssue(context, `"custom" rule "${rule.name}" has no JSON Schema equivalent.`);
+			break;
+		case "conditional":
+			reportIssue(context, `"conditional" rule has no JSON Schema equivalent.`);
+			break;
+		default: reportIssue(context, `Unknown rule cannot be converted to JSON Schema.`);
+	}
+}
+function applyRules(jsonSchema, rules, schemaType, context) {
+	for (const rule of rules ?? []) applyRule(jsonSchema, rule, schemaType, context);
+}
+
+//#endregion
+//#region src/convert-schema.ts
+function isMandatory(schema) {
+	const isIncluded = schema.included === void 0 || schema.included === true;
+	const isRequired = schema.required === void 0 || schema.required === true;
+	return isIncluded && isRequired;
+}
+function jsonTypeOf(value) {
+	return typeof value;
+}
+function applyEnumValues(jsonSchema, values) {
+	jsonSchema.enum = values;
+	const types = Array.from(new Set(values.map(jsonTypeOf)));
+	if (types.length === 1) jsonSchema.type = types[0];
+	else if (types.length > 1) jsonSchema.type = types;
+}
+function collectOptionValues(options, context) {
+	const values = [];
+	const visit = (option) => {
+		if (typeof option !== "object") {
+			values.push(option);
+			return;
+		}
+		if (option.enabled === false) return;
+		if (typeof option.enabled === "object") reportIssue(context, `An "options" entry has a predicate-based "enabled" flag; whether it's enabled can't be determined statically, so it was included in the JSON Schema "enum" anyway.`);
+		visit(option.value);
+	};
+	for (const option of options) visit(option);
+	return values;
+}
+function isSchema(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function shouldOmitField(schema, context) {
+	if (schema.included === false) return true;
+	return context.mode === "input" && schema.type === SchemaType.EXPRESSION;
+}
+function applyPrivacyWrapper(schema, innerSchema) {
+	if (schema.private !== true) return innerSchema;
+	return { oneOf: [{
+		type: "object",
+		properties: {
+			state: { const: "plain" },
+			value: innerSchema
+		},
+		required: ["state"]
+	}, {
+		type: "object",
+		properties: {
+			state: { const: "masked" },
+			value: { type: "string" }
+		},
+		required: ["state", "value"]
+	}] };
+}
+function applyDefault(schema, jsonSchema) {
+	if (schema.default === void 0) return;
+	jsonSchema.default = schema.default instanceof Date ? schema.default.toISOString() : schema.default;
+}
+/**
+* Converts a dynz schema to a JSON Schema (2020-12) document. Rule values
+* and schema kinds without a JSON Schema equivalent are handled per
+* `context.errorMode`.
+*/
+function convertSchema(schema, context) {
+	const jsonSchema = convertSchemaKind(schema, context);
+	applyDefault(schema, jsonSchema);
+	return applyPrivacyWrapper(schema, jsonSchema);
+}
+function convertSchemaKind(schema, context) {
+	switch (schema.type) {
+		case SchemaType.STRING: {
+			const jsonSchema = { type: "string" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.NUMBER: {
+			const jsonSchema = { type: "number" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.BOOLEAN: {
+			const jsonSchema = { type: "boolean" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.DATE: {
+			const jsonSchema = {
+				type: "string",
+				format: "date-time"
+			};
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.LITERAL: return { const: schema.value };
+		case SchemaType.ENUM: {
+			const jsonSchema = {};
+			applyEnumValues(jsonSchema, Object.values(schema.enum));
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.OPTIONS: {
+			const jsonSchema = {};
+			applyEnumValues(jsonSchema, collectOptionValues(schema.options, context));
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.FILE: {
+			const jsonSchema = { type: "string" };
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.EXPRESSION: return {};
+		case SchemaType.ARRAY: {
+			const jsonSchema = {
+				type: "array",
+				items: convertSchema(schema.schema, context)
+			};
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.OBJECT: {
+			const properties = {};
+			const required = [];
+			for (const [key, fieldSchema] of Object.entries(schema.fields)) {
+				if (shouldOmitField(fieldSchema, context)) continue;
+				properties[key] = convertSchema(fieldSchema, context);
+				if (isMandatory(fieldSchema)) required.push(key);
+			}
+			const jsonSchema = {
+				type: "object",
+				properties
+			};
+			if (required.length > 0) jsonSchema.required = required;
+			applyRules(jsonSchema, schema.rules, schema.type, context);
+			return jsonSchema;
+		}
+		case SchemaType.DISCRIMINATED_UNION: return { oneOf: schema.schemas.map((member) => {
+			const properties = { [schema.key]: { const: member[schema.key] } };
+			const required = [schema.key];
+			for (const [key, value] of Object.entries(member)) {
+				if (key === schema.key || !isSchema(value) || shouldOmitField(value, context)) continue;
+				properties[key] = convertSchema(value, context);
+				if (isMandatory(value)) required.push(key);
+			}
+			return {
+				type: "object",
+				properties,
+				required
+			};
+		}) };
+		default:
+			reportIssue(context, `Unknown schema type cannot be converted to JSON Schema.`);
+			return {};
+	}
+}
+
+//#endregion
+//#region src/to-standard-json-schema.ts
+/**
+* Converts a dynz schema to a standard JSON Schema (2020-12) document.
+*
+* Rule values that depend on runtime data (references, predicates,
+* transformers) and schema kinds without a JSON Schema equivalent are
+* handled according to `config.errorMode` (default `"warn"`). Whether
+* `expression` fields are included is controlled by `config.mode`
+* (default `"input"`, which omits them).
+*/
+function toStandardJsonSchema(schema, config = {}) {
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		...convertSchema(schema, {
+			errorMode: config.errorMode ?? "warn",
+			mode: config.mode ?? "input"
+		})
+	};
+}
+
+//#endregion
+export { toStandardJsonSchema };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@dynz/to-json-schema",
+  "version": "0.0.1",
+  "private": false,
+  "license": "BUSL-1.1",
+  "type": "module",
+  "sideEffects": false,
+  "keywords": [
+    "typescript",
+    "schema",
+    "validation",
+    "json-schema",
+    "form",
+    "type-safe"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rubenvanrooij/dynz"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Ruben van Rooij <ruben.van.rooij@gmail.com>",
+  "description": "Convert dynz schemas to standard JSON Schema.",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "peerDependencies": {
+    "dynz": "^1.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.16.5"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest run --watch"
+  }
+}