@powerlines/schema 0.11.28 → 0.11.37

package/dist/jtd.cjs

@@ -1,385 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-let _stryke_type_checks = require("@stryke/type-checks");
-let _stryke_type_checks_is_set_object = require("@stryke/type-checks/is-set-object");
-
-//#region src/jtd.ts
-/**
-* Maps a JSON Schema `format` annotation for integers to the closest JTD numeric type.
-*
-* @param format - The JSON Schema format hint to map.
-* @returns The matching JTD numeric type, or `undefined` if no exact match exists.
-*/
-function jsonSchemaIntegerFormatToJtd(format) {
-	switch (format) {
-		case "int8": return "int8";
-		case "uint8": return "uint8";
-		case "int16": return "int16";
-		case "uint16": return "uint16";
-		case "int32": return "int32";
-		case "uint32": return "uint32";
-		case void 0:
-		default: return;
-	}
-}
-/**
-* Maps a JSON Schema `format` annotation for floating point numbers to the closest JTD numeric type.
-*
-* @param format - The JSON Schema format hint to map.
-* @returns The matching JTD numeric type, or `undefined` if no exact match exists.
-*/
-function jsonSchemaNumberFormatToJtd(format) {
-	switch (format) {
-		case "float":
-		case "float32": return "float32";
-		case "double":
-		case "float64": return "float64";
-		case void 0:
-		default: return;
-	}
-}
-/**
-* Picks the smallest unsigned JTD integer type that can hold the provided bounds.
-*
-* @param minimum - The inclusive lower bound, when known.
-* @param maximum - The inclusive upper bound, when known.
-* @returns The narrowest unsigned JTD integer type that can represent the range, or `undefined` if the range cannot be expressed as an unsigned integer.
-*/
-function pickUnsignedIntegerType(minimum, maximum) {
-	if (minimum === void 0 || minimum < 0) return;
-	if (maximum === void 0) return;
-	if (maximum <= 255) return "uint8";
-	if (maximum <= 65535) return "uint16";
-	if (maximum <= 4294967295) return "uint32";
-}
-/**
-* Picks the smallest signed JTD integer type that can hold the provided bounds.
-*
-* @param minimum - The inclusive lower bound, when known.
-* @param maximum - The inclusive upper bound, when known.
-* @returns The narrowest signed JTD integer type that can represent the range, or `undefined` if the range cannot be expressed as a signed integer.
-*/
-function pickSignedIntegerType(minimum, maximum) {
-	if (minimum !== void 0 && maximum !== void 0 && minimum >= -128 && maximum <= 127) return "int8";
-	if (minimum !== void 0 && maximum !== void 0 && minimum >= -32768 && maximum <= 32767) return "int16";
-	return "int32";
-}
-/**
-* Tests whether the provided value is a non-null object that can be inspected as a JSON Schema fragment.
-*
-* @param value - The value to test.
-* @returns `true` if the value is a plain object suitable for JSON-Schema conversion.
-*/
-function isJsonSchemaLike(value) {
-	return (0, _stryke_type_checks_is_set_object.isSetObject)(value);
-}
-/**
-* Reads the JSON Schema `type` field as an array, normalising the single-string form.
-*
-* @param schema - The JSON Schema fragment to inspect.
-* @returns The list of JSON Schema type names declared on the fragment.
-*/
-function readTypes(schema) {
-	if (Array.isArray(schema.type)) return schema.type;
-	if (typeof schema.type === "string") return [schema.type];
-	return [];
-}
-/**
-* Builds a JTD `metadata` object from the JSON Schema annotation keywords found on a fragment.
-*
-* @param schema - The source JSON Schema fragment.
-* @returns A metadata bag suitable for attaching to a JTD form, or `undefined` if no annotations are present.
-*/
-function collectMetadata(schema) {
-	const metadata = {};
-	if ((0, _stryke_type_checks.isSetString)(schema.description)) metadata.description = schema.description;
-	if ((0, _stryke_type_checks.isSetArray)(schema.examples)) metadata.examples = schema.examples;
-	if ((0, _stryke_type_checks.isSetArray)(schema.alias) && schema.alias.every(_stryke_type_checks.isSetString)) metadata.alias = schema.alias;
-	if ((0, _stryke_type_checks.isSetString)(schema.table)) metadata.default = schema.table;
-	if ((0, _stryke_type_checks.isSetString)(schema.title)) metadata.title = schema.title;
-	if (!(0, _stryke_type_checks.isUndefined)(schema.default)) metadata.default = schema.default;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isHidden)) metadata.isHidden = schema.isHidden;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.hidden)) metadata.isHidden = schema.hidden;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isIgnored)) metadata.isIgnored = schema.isIgnored;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.ignored)) metadata.isIgnored = schema.ignored;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isReadonly)) metadata.isReadonly = schema.isReadonly;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.readonly)) metadata.isReadonly = schema.readonly;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isPrimaryKey)) metadata.isPrimaryKey = schema.isPrimaryKey;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.primaryKey)) metadata.isPrimaryKey = schema.primaryKey;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isInternal)) metadata.isInternal = schema.isInternal;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.internal)) metadata.isInternal = schema.internal;
-	if ((0, _stryke_type_checks.isBoolean)(schema.isRuntime)) metadata.isRuntime = schema.isRuntime;
-	else if ((0, _stryke_type_checks.isBoolean)(schema.runtime)) metadata.isRuntime = schema.runtime;
-	if ((0, _stryke_type_checks.isSetArray)(schema.union)) metadata.union = schema.union;
-	return Object.keys(metadata).length > 0 ? metadata : void 0;
-}
-/**
-* Attaches metadata and nullability flags to a JTD form, mutating and returning the form.
-*
-* @param form - The base JTD form to decorate.
-* @param schema - The source JSON Schema fragment from which annotations are read.
-* @param nullable - Whether the schema is nullable in JTD semantics.
-* @returns The decorated JTD form.
-*/
-function decorate(form, schema, nullable) {
-	if (nullable) form.nullable = true;
-	const metadata = collectMetadata(schema);
-	if (metadata) form.metadata = metadata;
-	return form;
-}
-/**
-* Determines whether the supplied list of JSON Schema types collapses to `null` only.
-*
-* @param types - The normalized list of JSON Schema type names.
-* @returns `true` if the only declared type is `null`.
-*/
-function isNullOnly(types) {
-	return types.length > 0 && types.every((t) => t === "null");
-}
-/**
-* Splits a `null` declaration away from a list of JSON Schema types.
-*
-* @param types - The normalized list of JSON Schema type names.
-* @returns A tuple of `[nonNullTypes, nullable]` describing the remaining types and whether `null` was present.
-*/
-function stripNull(types) {
-	const nullable = types.includes("null");
-	return {
-		types: types.filter((t) => t !== "null"),
-		nullable
-	};
-}
-/**
-* Converts a JSON Schema `enum` keyword to a JTD enum form, stringifying values when required.
-*
-* @param values - The raw enum values from the JSON Schema fragment.
-* @returns A JTD enum form, or `undefined` if the enum cannot be represented (e.g. empty list).
-*/
-function enumToJtd(values) {
-	const strings = values.filter((v) => v !== null && v !== void 0).map((v) => String(v));
-	if (strings.length === 0) return;
-	return { enum: Array.from(new Set(strings)) };
-}
-/**
-* Selects the most appropriate JTD numeric `type` value for a JSON Schema integer fragment.
-*
-* @param schema - The integer JSON Schema fragment.
-* @returns The chosen JTD integer type.
-*/
-function pickIntegerJtdType(schema) {
-	const mapped = jsonSchemaIntegerFormatToJtd(schema.format);
-	if (mapped) return mapped;
-	const unsigned = pickUnsignedIntegerType(schema.minimum, schema.maximum);
-	if (unsigned) return unsigned;
-	return pickSignedIntegerType(schema.minimum, schema.maximum) ?? "int32";
-}
-/**
-* Selects the most appropriate JTD numeric `type` value for a JSON Schema number fragment.
-*
-* @param schema - The number JSON Schema fragment.
-* @returns The chosen JTD floating point type.
-*/
-function pickNumberJtdType(schema) {
-	return jsonSchemaNumberFormatToJtd(schema.format) ?? "float64";
-}
-/**
-* Selects the JTD string `type` value for a JSON Schema string fragment, mapping `format: "date-time"` to `timestamp`.
-*
-* @param schema - The string JSON Schema fragment.
-* @returns The chosen JTD string type.
-*/
-function pickStringJtdType(schema) {
-	if (schema.format === "date-time") return "timestamp";
-	return "string";
-}
-/**
-* Converts a JSON Schema object fragment into a JTD properties form.
-*
-* @param schema - The object JSON Schema fragment.
-* @param nullable - Whether the resulting JTD form should be nullable.
-* @returns The JTD properties form representing the object.
-*/
-function objectToJtd(schema, nullable) {
-	const required = new Set(schema.required ?? []);
-	const properties = {};
-	const optionalProperties = {};
-	const metadata = { default: schema.default ?? {} };
-	if (schema.properties) for (const [key, value] of Object.entries(schema.properties)) {
-		if (!(0, _stryke_type_checks.isUndefined)(value.default)) metadata.default[key] = value.default;
-		const converted = jsonSchemaToJtd(value);
-		if (!converted) continue;
-		if (required.has(key)) properties[key] = converted;
-		else optionalProperties[key] = converted;
-	}
-	const hasProperties = Object.keys(properties).length > 0;
-	const hasOptional = Object.keys(optionalProperties).length > 0;
-	if (!hasProperties && !hasOptional && isJsonSchemaLike(schema.additionalProperties)) {
-		const values = jsonSchemaToJtd(schema.additionalProperties);
-		if (values) return decorate({
-			metadata,
-			values
-		}, schema, nullable);
-	}
-	if (!hasProperties && !hasOptional && schema.patternProperties) {
-		const first = Object.values(schema.patternProperties)[0];
-		if (first) {
-			const values = jsonSchemaToJtd(first);
-			if (values) return decorate({
-				metadata,
-				values
-			}, schema, nullable);
-		}
-	}
-	const form = { metadata };
-	if (hasProperties) form.properties = properties;
-	else if (!hasOptional) form.properties = {};
-	if (hasOptional) form.optionalProperties = optionalProperties;
-	if (schema.additionalProperties === true || isJsonSchemaLike(schema.additionalProperties) || schema.patternProperties !== void 0) form.additionalProperties = true;
-	return decorate(form, schema, nullable);
-}
-/**
-* Converts a JSON Schema array fragment into a JTD elements form.
-*
-* @param schema - The array JSON Schema fragment.
-* @param nullable - Whether the resulting JTD form should be nullable.
-* @returns The JTD elements form representing the array.
-*/
-function arrayToJtd(schema, nullable) {
-	let elementSchema;
-	if (Array.isArray(schema.items)) elementSchema = schema.items[0];
-	else if (schema.items) elementSchema = schema.items;
-	return decorate({ elements: (elementSchema ? jsonSchemaToJtd(elementSchema) : {}) ?? {} }, schema, nullable);
-}
-/**
-* Attempts to detect and emit a JTD discriminator form from a JSON Schema `oneOf` or `anyOf` fragment.
-*
-* @param schemas - The list of candidate JSON Schema fragments.
-* @param nullable - Whether the resulting JTD form should be nullable.
-* @returns A discriminator form when every branch shares a single tag property, otherwise `undefined`.
-*/
-function tryDiscriminator(schemas, nullable) {
-	if (schemas.length < 2) return;
-	let candidateKey;
-	const mapping = {};
-	for (const branch of schemas) {
-		if (!isJsonSchemaLike(branch) || !branch.properties) return;
-		const constantTags = Object.entries(branch.properties).filter(([, value]) => isJsonSchemaLike(value) && (typeof value.const === "string" || Array.isArray(value.enum) && value.enum.length === 1 && typeof value.enum[0] === "string"));
-		if (constantTags.length === 0) return;
-		const [tagKey, tagSchema] = constantTags[0];
-		if (!candidateKey) candidateKey = tagKey;
-		else if (candidateKey !== tagKey) return;
-		const tag = typeof tagSchema.const === "string" ? tagSchema.const : tagSchema.enum?.[0];
-		const { [tagKey]: _omit, ...restProperties } = branch.properties;
-		const restRequired = (branch.required ?? []).filter((k) => k !== tagKey);
-		const branchForm = jsonSchemaToJtd({
-			...branch,
-			properties: restProperties,
-			required: restRequired
-		});
-		if (!branchForm || !(0, _stryke_type_checks_is_set_object.isSetObject)(branchForm) || "ref" in branchForm) return;
-		mapping[tag] = branchForm;
-	}
-	if (!candidateKey) return;
-	const form = {
-		discriminator: candidateKey,
-		mapping
-	};
-	if (nullable) form.nullable = true;
-	return form;
-}
-/**
-* Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
-*
-* Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
-*
-* @param schema - The JSON Schema fragment to convert.
-* @returns A valid JTD form, or `undefined` if the input cannot be represented.
-*/
-function jsonSchemaToJtd(schema) {
-	if (!isJsonSchemaLike(schema)) return;
-	if ((0, _stryke_type_checks.isSetString)(schema.$ref)) {
-		const match = /^#\/(?:definitions|\$defs)\/(.+)$/.exec(schema.$ref);
-		if (match) return { ref: match[1] };
-	}
-	if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-		const merged = schema.allOf.reduce((acc, current) => mergeJsonSchema(acc, current), {});
-		const { allOf: _allOf, ...rest } = schema;
-		return jsonSchemaToJtd(mergeJsonSchema(merged, rest));
-	}
-	const rawTypes = readTypes(schema);
-	const { types: nonNullTypes, nullable: typeIsNullable } = stripNull(rawTypes);
-	const nullable = Boolean(schema.nullable) || typeIsNullable;
-	if (isNullOnly(rawTypes)) return decorate({}, schema, true);
-	if (Array.isArray(schema.enum)) {
-		const enumForm = enumToJtd(schema.enum);
-		if (enumForm) return decorate(enumForm, schema, nullable);
-	}
-	if ((0, _stryke_type_checks.isSetString)(schema.const)) return decorate({ enum: [schema.const] }, schema, nullable);
-	const union = schema.oneOf ?? schema.anyOf;
-	if (Array.isArray(union) && union.length > 0) {
-		const branches = union.filter(isJsonSchemaLike);
-		const onlyNullBranches = branches.filter((b) => readTypes(b).includes("null"));
-		const nonNullBranches = branches.filter((b) => !isNullOnly(readTypes(b)) && readTypes(b).join() !== "null");
-		const unionNullable = nullable || onlyNullBranches.length > 0;
-		if (nonNullBranches.length === 1) {
-			const collapsed = jsonSchemaToJtd(nonNullBranches[0]);
-			if (collapsed) return decorate(collapsed, schema, unionNullable);
-		}
-		const discriminated = tryDiscriminator(nonNullBranches, unionNullable);
-		if (discriminated) {
-			const metadata = collectMetadata(schema);
-			if (metadata) discriminated.metadata = metadata;
-			return discriminated;
-		}
-		const fallback = decorate({}, schema, unionNullable);
-		const metadata = fallback.metadata ?? {};
-		metadata.union = union;
-		fallback.metadata = metadata;
-		return fallback;
-	}
-	if (nonNullTypes.includes("object") || schema.properties || schema.patternProperties || isJsonSchemaLike(schema.additionalProperties)) {
-		const result = objectToJtd(schema, nullable);
-		const definitions = schema.definitions ?? schema.$defs;
-		if (definitions && Object.keys(definitions).length > 0) {
-			const converted = {};
-			for (const [key, value] of Object.entries(definitions)) {
-				const def = jsonSchemaToJtd(value);
-				if (def) converted[key] = def;
-			}
-			if (Object.keys(converted).length > 0) result.definitions = converted;
-		}
-		return result;
-	}
-	if (nonNullTypes.includes("array")) return arrayToJtd(schema, nullable);
-	if (nonNullTypes.length === 1) {
-		const t = nonNullTypes[0];
-		if (t === "string") return decorate({ type: pickStringJtdType(schema) }, schema, nullable);
-		if (t === "boolean") return decorate({ type: "boolean" }, schema, nullable);
-		if (t === "integer") return decorate({ type: pickIntegerJtdType(schema) }, schema, nullable);
-		if (t === "number") return decorate({ type: pickNumberJtdType(schema) }, schema, nullable);
-	}
-	if (nonNullTypes.length > 1) return decorate({}, schema, nullable);
-	return decorate({}, schema, nullable);
-}
-/**
-* Shallow-merges two JSON Schema fragments, combining `required` arrays and `properties` maps.
-*
-* @param left - The base schema fragment.
-* @param right - The schema fragment to merge into the base.
-* @returns A merged schema fragment. Neither input is mutated.
-*/
-function mergeJsonSchema(left, right) {
-	const merged = {
-		...left,
-		...right
-	};
-	if (left.properties || right.properties) merged.properties = {
-		...left.properties ?? {},
-		...right.properties ?? {}
-	};
-	if (left.required || right.required) merged.required = Array.from(new Set([...left.required ?? [], ...right.required ?? []]));
-	return merged;
-}
-
-//#endregion
-exports.jsonSchemaToJtd = jsonSchemaToJtd;

package/dist/jtd.d.cts

@@ -1,15 +0,0 @@
-import { JTDSchemaType, JsonSchemaLike, SchemaMetadata } from "./types.cjs";
-
-//#region src/jtd.d.ts
-/**
- * Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
- *
- * Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
- *
- * @param schema - The JSON Schema fragment to convert.
- * @returns A valid JTD form, or `undefined` if the input cannot be represented.
- */
-declare function jsonSchemaToJtd<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(schema: JsonSchemaLike | undefined | null): JTDSchemaType<TMetadata> | undefined;
-//#endregion
-export { jsonSchemaToJtd };
-//# sourceMappingURL=jtd.d.cts.map

package/dist/jtd.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jtd.d.cts","names":[],"sources":["../src/jtd.ts"],"mappings":";;;;;AAgjBA;;;;;;iBAAgB,eAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,MAAA,EAAQ,cAAA,sBACP,aAAA,CAAc,SAAA"}

package/dist/jtd.d.mts

@@ -1,15 +0,0 @@
-import { JTDSchemaType, JsonSchemaLike, SchemaMetadata } from "./types.mjs";
-
-//#region src/jtd.d.ts
-/**
- * Converts a JSON Schema fragment (draft-07 style, as produced by `zod-to-json-schema`, Standard Schema, etc.) into a valid JSON Type Definition (RFC 8927) schema.
- *
- * Unsupported JSON Schema keywords (`pattern`, `const`, `minItems`, `maxItems`, `uniqueItems`, etc.) are dropped — JTD intentionally omits these. Annotation keywords (`description`, `title`, `default`, `examples`) are preserved under the JTD `metadata` field.
- *
- * @param schema - The JSON Schema fragment to convert.
- * @returns A valid JTD form, or `undefined` if the input cannot be represented.
- */
-declare function jsonSchemaToJtd<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>>(schema: JsonSchemaLike | undefined | null): JTDSchemaType<TMetadata> | undefined;
-//#endregion
-export { jsonSchemaToJtd };
-//# sourceMappingURL=jtd.d.mts.map

package/dist/jtd.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jtd.d.mts","names":[],"sources":["../src/jtd.ts"],"mappings":";;;;;AAgjBA;;;;;;iBAAgB,eAAA,mBACI,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,EAAA,CAEpD,MAAA,EAAQ,cAAA,sBACP,aAAA,CAAc,SAAA"}