schemair 0.1.0 → 0.2.0

package/dist/definition-DSZZTz4e.cjs

@@ -1,473 +0,0 @@
-
-//#region src/definition/validator.ts
-const NODE_KINDS = new Set([
-	"primitive",
-	"literal",
-	"record",
-	"array",
-	"tuple",
-	"literalUnion",
-	"nullable",
-	"taggedUnion",
-	"ref",
-	"selfRef"
-]);
-const PRIMITIVE_NAMES = new Set([
-	"string",
-	"number",
-	"boolean",
-	"null"
-]);
-function isRecord(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-}
-function hasOwn(value, key) {
-	return Object.prototype.hasOwnProperty.call(value, key);
-}
-function ownKeys(value) {
-	return Reflect.ownKeys(value);
-}
-function hasAccessor(value) {
-	return ownKeys(value).some((key) => {
-		const descriptor = Object.getOwnPropertyDescriptor(value, key);
-		return descriptor !== void 0 && ("get" in descriptor || "set" in descriptor);
-	});
-}
-function isDenseArray(value) {
-	if (!Array.isArray(value)) return false;
-	for (const key of Reflect.ownKeys(value)) {
-		if (typeof key === "symbol") return false;
-		const descriptor = Object.getOwnPropertyDescriptor(value, key);
-		if (descriptor !== void 0 && ("get" in descriptor || "set" in descriptor)) return false;
-		if (key !== "length" && !/^(0|[1-9]\d*)$/.test(key)) return false;
-	}
-	for (let index = 0; index < value.length; index += 1) if (!hasOwn(value, String(index))) return false;
-	return true;
-}
-function isFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-function isLiteral(value) {
-	return typeof value === "string" || typeof value === "boolean" || isFiniteNumber(value);
-}
-function scalarDomain(value) {
-	if (typeof value === "string") return "string";
-	if (typeof value === "boolean") return "boolean";
-	return "number";
-}
-function equalLiteral(left, right) {
-	return typeof left === typeof right && Object.is(left, right) || left === right;
-}
-function describe(value) {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "array";
-	return typeof value;
-}
-var DefinitionValidator = class {
-	issues = [];
-	active = /* @__PURE__ */ new WeakSet();
-	validateRoot(value) {
-		if (this.validateNode(value, [], true)) return {
-			ok: true,
-			node: value,
-			issues: []
-		};
-		return {
-			ok: false,
-			issues: this.issues
-		};
-	}
-	issue(code, path, message) {
-		this.issues.push({
-			code,
-			path,
-			message
-		});
-	}
-	checkObject(value, path, label) {
-		if (!isRecord(value)) {
-			this.issue("schema.object.invalid", path, `${label} must be a plain object`);
-			return false;
-		}
-		if (hasAccessor(value)) {
-			this.issue("schema.object.accessor", path, `${label} must not contain accessor properties`);
-			return false;
-		}
-		if (ownKeys(value).some((key) => typeof key === "symbol")) {
-			this.issue("schema.object.symbol-key", path, `${label} must not contain symbol keys`);
-			return false;
-		}
-		return true;
-	}
-	checkFields(value, allowed, required, path) {
-		let valid = true;
-		for (const key of Object.getOwnPropertyNames(value)) if (!allowed.includes(key)) {
-			this.issue("schema.field.unknown", [...path, key], `unknown field '${key}'`);
-			valid = false;
-		}
-		for (const key of required) if (!hasOwn(value, key)) {
-			this.issue("schema.field.missing", [...path, key], `missing required field '${key}'`);
-			valid = false;
-		}
-		return valid;
-	}
-	enter(value, path) {
-		if (this.active.has(value)) {
-			this.issue("schema.cycle", path, "actual object cycles are not valid schema data");
-			return false;
-		}
-		this.active.add(value);
-		return true;
-	}
-	leave(value) {
-		this.active.delete(value);
-	}
-	validateNode(value, path, root) {
-		if (!this.checkObject(value, path, "schema node")) return false;
-		if (!this.enter(value, path)) return false;
-		let valid = true;
-		const kind = value.kind;
-		if (typeof kind !== "string" || !NODE_KINDS.has(kind)) {
-			this.issue("schema.kind.invalid", [...path, "kind"], `unsupported schema kind '${String(kind)}'`);
-			valid = false;
-		} else switch (kind) {
-			case "primitive":
-				valid = this.validatePrimitive(value, path);
-				break;
-			case "literal":
-				valid = this.validateLiteral(value, path);
-				break;
-			case "record":
-				valid = this.validateRecord(value, path);
-				break;
-			case "array":
-				valid = this.validateArray(value, path);
-				break;
-			case "tuple":
-				valid = this.validateTuple(value, path);
-				break;
-			case "literalUnion":
-				valid = this.validateLiteralUnion(value, path);
-				break;
-			case "nullable":
-				valid = this.validateNullable(value, path);
-				break;
-			case "taggedUnion":
-				valid = this.validateTaggedUnion(value, path);
-				break;
-			case "ref":
-				valid = this.validateRef(value, path);
-				break;
-			case "selfRef":
-				valid = this.checkFields(value, ["kind"], [], path);
-				if (root) {
-					this.issue("schema.selfRef.root", path, "a root schema cannot consist only of selfRef");
-					valid = false;
-				}
-				break;
-			default: valid = false;
-		}
-		this.leave(value);
-		return valid;
-	}
-	validatePrimitive(value, path) {
-		let valid = this.checkFields(value, [
-			"kind",
-			"name",
-			"semanticPath",
-			"constraints"
-		], ["name"], path);
-		const name = value.name;
-		if (typeof name !== "string" || !PRIMITIVE_NAMES.has(name)) {
-			this.issue("schema.primitive.name", [...path, "name"], `primitive name must be one of string, number, boolean, or null`);
-			return false;
-		}
-		if (!(name === "string" || name === "number") && (hasOwn(value, "semanticPath") || hasOwn(value, "constraints"))) {
-			this.issue("schema.primitive.metadata", path, "semanticPath and constraints are only supported on string and number primitives");
-			valid = false;
-		}
-		if (hasOwn(value, "semanticPath")) valid = this.validatePath(value.semanticPath, [...path, "semanticPath"], "semanticPath") && valid;
-		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
-		return valid;
-	}
-	validateLiteral(value, path) {
-		let valid = this.checkFields(value, ["kind", "literal"], ["literal"], path);
-		if (!isLiteral(value.literal)) {
-			this.issue("schema.literal.value", [...path, "literal"], "literal must be a finite string, number, or boolean");
-			valid = false;
-		}
-		return valid;
-	}
-	validateRecord(value, path) {
-		let valid = this.checkFields(value, [
-			"kind",
-			"fields",
-			"additionalFields",
-			"constraints"
-		], ["fields"], path);
-		if (!isDenseArray(value.fields)) {
-			this.issue("schema.record.fields", [...path, "fields"], "fields must be a dense array");
-			return false;
-		}
-		const keys = /* @__PURE__ */ new Set();
-		value.fields.forEach((field, index) => {
-			const fieldPath = [
-				...path,
-				"fields",
-				index
-			];
-			if (!this.checkObject(field, fieldPath, "record field")) {
-				valid = false;
-				return;
-			}
-			valid = this.checkFields(field, [
-				"key",
-				"schema",
-				"required",
-				"description"
-			], ["key", "schema"], fieldPath) && valid;
-			if (typeof field.key !== "string") {
-				this.issue("schema.record.field-key", [...fieldPath, "key"], "record field key must be a string");
-				valid = false;
-			} else if (keys.has(field.key)) {
-				this.issue("schema.record.field-key.duplicate", [...fieldPath, "key"], `duplicate record field key '${field.key}'`);
-				valid = false;
-			} else keys.add(field.key);
-			if (hasOwn(field, "required") && typeof field.required !== "boolean") {
-				this.issue("schema.record.required", [...fieldPath, "required"], "required must be a boolean");
-				valid = false;
-			}
-			if (hasOwn(field, "description") && typeof field.description !== "string") {
-				this.issue("schema.record.description", [...fieldPath, "description"], "description must be a string");
-				valid = false;
-			}
-			valid = this.validateNode(field.schema, [...fieldPath, "schema"], false) && valid;
-		});
-		if (hasOwn(value, "additionalFields")) {
-			if (value.additionalFields !== true) valid = this.validateNode(value.additionalFields, [...path, "additionalFields"], false) && valid;
-		}
-		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
-		return valid;
-	}
-	validateArray(value, path) {
-		let valid = this.checkFields(value, [
-			"kind",
-			"elementSchema",
-			"constraints"
-		], ["elementSchema"], path);
-		valid = this.validateNode(value.elementSchema, [...path, "elementSchema"], false) && valid;
-		if (hasOwn(value, "constraints")) valid = this.validateConstraints(value.constraints, [...path, "constraints"], "constraints") && valid;
-		return valid;
-	}
-	validateTuple(value, path) {
-		let valid = this.checkFields(value, ["kind", "elementSchemas"], ["elementSchemas"], path);
-		if (!isDenseArray(value.elementSchemas)) {
-			this.issue("schema.tuple.elements", [...path, "elementSchemas"], "elementSchemas must be a dense array");
-			return false;
-		}
-		value.elementSchemas.forEach((child, index) => {
-			valid = this.validateNode(child, [
-				...path,
-				"elementSchemas",
-				index
-			], false) && valid;
-		});
-		return valid;
-	}
-	validateLiteralUnion(value, path) {
-		let valid = this.checkFields(value, ["kind", "values"], ["values"], path);
-		if (!isDenseArray(value.values)) {
-			this.issue("schema.literalUnion.values", [...path, "values"], "values must be a dense array");
-			return false;
-		}
-		if (value.values.length < 2) {
-			this.issue("schema.literalUnion.cardinality", [...path, "values"], "literalUnion requires at least two values");
-			valid = false;
-		}
-		let domain;
-		const literals = [];
-		value.values.forEach((candidate, index) => {
-			const candidatePath = [
-				...path,
-				"values",
-				index
-			];
-			if (!isLiteral(candidate)) {
-				this.issue("schema.literalUnion.value", candidatePath, "literalUnion values must be finite strings, numbers, or booleans");
-				valid = false;
-				return;
-			}
-			const candidateDomain = scalarDomain(candidate);
-			if (domain === void 0) domain = candidateDomain;
-			else if (domain !== candidateDomain) {
-				this.issue("schema.literalUnion.domain", candidatePath, "literalUnion values must share one scalar domain");
-				valid = false;
-			}
-			if (literals.some((existing) => equalLiteral(existing, candidate))) {
-				this.issue("schema.literalUnion.duplicate", candidatePath, "literalUnion values must be unique");
-				valid = false;
-			}
-			literals.push(candidate);
-		});
-		return valid;
-	}
-	validateNullable(value, path) {
-		let valid = this.checkFields(value, ["kind", "value"], ["value"], path);
-		valid = this.validateNode(value.value, [...path, "value"], false) && valid;
-		if (isRecord(value.value) && (value.value.kind === "nullable" || value.value.kind === "primitive" && value.value.name === "null")) {
-			this.issue("schema.nullable.redundant", [...path, "value"], "nullable cannot wrap null or another nullable node");
-			valid = false;
-		}
-		return valid;
-	}
-	validateTaggedUnion(value, path) {
-		let valid = this.checkFields(value, [
-			"kind",
-			"discriminator",
-			"variants"
-		], ["discriminator", "variants"], path);
-		if (typeof value.discriminator !== "string") {
-			this.issue("schema.taggedUnion.discriminator", [...path, "discriminator"], "discriminator must be a string");
-			valid = false;
-		}
-		if (!isDenseArray(value.variants)) {
-			this.issue("schema.taggedUnion.variants", [...path, "variants"], "variants must be a dense array");
-			return false;
-		}
-		if (value.variants.length < 2) {
-			this.issue("schema.taggedUnion.cardinality", [...path, "variants"], "taggedUnion requires at least two variants");
-			valid = false;
-		}
-		const variantKeys = /* @__PURE__ */ new Set();
-		const tags = /* @__PURE__ */ new Set();
-		value.variants.forEach((variant, index) => {
-			const variantPath = [
-				...path,
-				"variants",
-				index
-			];
-			if (!this.checkObject(variant, variantPath, "tagged-union variant")) {
-				valid = false;
-				return;
-			}
-			valid = this.checkFields(variant, [
-				"key",
-				"schema",
-				"description"
-			], ["key", "schema"], variantPath) && valid;
-			if (typeof variant.key !== "string" || variant.key.trim() === "") {
-				this.issue("schema.taggedUnion.variant-key", [...variantPath, "key"], "variant key must be a non-blank string");
-				valid = false;
-			} else if (variantKeys.has(variant.key)) {
-				this.issue("schema.taggedUnion.variant-key.duplicate", [...variantPath, "key"], `duplicate variant key '${variant.key}'`);
-				valid = false;
-			} else variantKeys.add(variant.key);
-			if (hasOwn(variant, "description") && typeof variant.description !== "string") {
-				this.issue("schema.taggedUnion.description", [...variantPath, "description"], "description must be a string");
-				valid = false;
-			}
-			valid = this.validateNode(variant.schema, [...variantPath, "schema"], false) && valid;
-			if (!isRecord(variant.schema) || variant.schema.kind !== "record") {
-				this.issue("schema.taggedUnion.variant-schema", [...variantPath, "schema"], "tagged-union variants must be direct record schemas");
-				valid = false;
-				return;
-			}
-			const field = (isDenseArray(variant.schema.fields) ? variant.schema.fields : []).find((candidate) => isRecord(candidate) && candidate.key === value.discriminator);
-			if (!field || field.required !== true || !isRecord(field.schema) || field.schema.kind !== "literal" || typeof field.schema.literal !== "string") {
-				this.issue("schema.taggedUnion.discriminator-field", [
-					...variantPath,
-					"schema",
-					"fields"
-				], "each variant must have a required string-literal discriminator field");
-				valid = false;
-			} else if (tags.has(field.schema.literal)) {
-				this.issue("schema.taggedUnion.discriminator-duplicate", [
-					...variantPath,
-					"schema",
-					"fields"
-				], "discriminator literal tags must be unique");
-				valid = false;
-			} else tags.add(field.schema.literal);
-		});
-		return valid;
-	}
-	validateRef(value, path) {
-		let valid = this.checkFields(value, ["kind", "refPath"], ["refPath"], path);
-		valid = this.validatePath(value.refPath, [...path, "refPath"], "refPath") && valid;
-		return valid;
-	}
-	validatePath(value, path, label) {
-		if (!isDenseArray(value) || value.length === 0 || value.some((segment) => typeof segment !== "string" || segment.trim() === "")) {
-			this.issue("schema.path.invalid", path, `${label} must be a non-empty dense array of non-blank strings`);
-			return false;
-		}
-		return true;
-	}
-	validateConstraints(value, path, label) {
-		if (!isDenseArray(value)) {
-			this.issue("schema.constraints.invalid", path, `${label} must be a dense array`);
-			return false;
-		}
-		let valid = true;
-		value.forEach((constraint, index) => {
-			const constraintPath = [...path, index];
-			if (!this.checkObject(constraint, constraintPath, "constraint")) {
-				valid = false;
-				return;
-			}
-			valid = this.checkFields(constraint, ["constraintPath", "args"], ["constraintPath"], constraintPath) && valid;
-			valid = this.validatePath(constraint.constraintPath, [...constraintPath, "constraintPath"], "constraintPath") && valid;
-			if (hasOwn(constraint, "args")) valid = this.validateJsonValue(constraint.args, [...constraintPath, "args"], /* @__PURE__ */ new WeakSet()) && valid;
-		});
-		return valid;
-	}
-	validateJsonValue(value, path, active) {
-		if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-		if (typeof value === "number") {
-			if (Number.isFinite(value)) return true;
-			this.issue("schema.json-value.number", path, "JSON numbers must be finite");
-			return false;
-		}
-		if (typeof value !== "object") {
-			this.issue("schema.json-value.type", path, `value of type ${describe(value)} is not JSON-compatible`);
-			return false;
-		}
-		if (active.has(value)) {
-			this.issue("schema.json-value.cycle", path, "actual object cycles are not JSON-compatible");
-			return false;
-		}
-		if (Array.isArray(value)) {
-			if (!isDenseArray(value)) {
-				this.issue("schema.json-value.array", path, "JSON arrays must be dense and have no symbol keys");
-				return false;
-			}
-			active.add(value);
-			let valid$1 = true;
-			value.forEach((child, index) => {
-				valid$1 = this.validateJsonValue(child, [...path, index], active) && valid$1;
-			});
-			active.delete(value);
-			return valid$1;
-		}
-		if (!this.checkObject(value, path, "JSON object")) return false;
-		active.add(value);
-		let valid = true;
-		for (const key of Object.keys(value)) valid = this.validateJsonValue(value[key], [...path, key], active) && valid;
-		active.delete(value);
-		return valid;
-	}
-};
-/** Validate only the serializable structural definition of one SchemaNode. */
-function validateSchemaNodeDefinition(value) {
-	return new DefinitionValidator().validateRoot(value);
-}
-
-//#endregion
-Object.defineProperty(exports, 'validateSchemaNodeDefinition', {
-  enumerable: true,
-  get: function () {
-    return validateSchemaNodeDefinition;
-  }
-});