schemair 0.1.0 → 0.3.0

package/dist/authoring-DyJNYs5o.js

@@ -0,0 +1,362 @@
+import { t as __exportAll } from "./chunk-bFfwrPtJ.js";
+
+//#region src/authoring/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	array: () => array,
+	boolean: () => boolean,
+	defineSchemaRegistry: () => defineSchemaRegistry,
+	field: () => field,
+	literal: () => literal,
+	literalUnion: () => literalUnion,
+	nullValue: () => nullValue,
+	nullable: () => nullable,
+	number: () => number,
+	optionalField: () => optionalField,
+	primitive: () => primitive,
+	record: () => record,
+	ref: () => ref,
+	requiredField: () => requiredField,
+	selfRef: () => selfRef,
+	string: () => string,
+	taggedUnion: () => taggedUnion,
+	tuple: () => tuple,
+	variant: () => variant
+});
+function primitive(name, metadata) {
+	if (metadata === void 0) return {
+		kind: "primitive",
+		name
+	};
+	return {
+		kind: "primitive",
+		name,
+		...metadata
+	};
+}
+const string = (metadata) => primitive("string", metadata);
+const number = (metadata) => primitive("number", metadata);
+const boolean = () => primitive("boolean");
+const nullValue = () => primitive("null");
+function literal(value) {
+	return {
+		kind: "literal",
+		literal: value
+	};
+}
+function field(key, schema, options) {
+	return options === void 0 ? {
+		key,
+		schema
+	} : {
+		key,
+		schema,
+		...options
+	};
+}
+function requiredField(key, schema, description) {
+	return description === void 0 ? {
+		key,
+		schema,
+		required: true
+	} : {
+		key,
+		schema,
+		required: true,
+		description
+	};
+}
+function optionalField(key, schema, description) {
+	return description === void 0 ? {
+		key,
+		schema
+	} : {
+		key,
+		schema,
+		description
+	};
+}
+function record(fields, options) {
+	return options === void 0 ? {
+		kind: "record",
+		fields: [...fields]
+	} : {
+		kind: "record",
+		fields: [...fields],
+		...options
+	};
+}
+function array(elementSchema, options) {
+	return options === void 0 ? {
+		kind: "array",
+		elementSchema
+	} : {
+		kind: "array",
+		elementSchema,
+		...options
+	};
+}
+function tuple(elementSchemas) {
+	return {
+		kind: "tuple",
+		elementSchemas
+	};
+}
+function literalUnion(values) {
+	return {
+		kind: "literalUnion",
+		values
+	};
+}
+function nullable(value) {
+	return {
+		kind: "nullable",
+		value
+	};
+}
+function variant(key, schema, options) {
+	return options === void 0 ? {
+		key,
+		schema
+	} : {
+		key,
+		schema,
+		...options
+	};
+}
+function taggedUnion(discriminator, variants) {
+	return {
+		kind: "taggedUnion",
+		discriminator,
+		variants
+	};
+}
+function ref(refPath) {
+	return {
+		kind: "ref",
+		refPath
+	};
+}
+function selfRef() {
+	return { kind: "selfRef" };
+}
+/** Preserve a statically authored registry as ordinary declaration data. */
+function defineSchemaRegistry(entries) {
+	return entries;
+}
+
+//#endregion
+//#region src/authoring/expression.ts
+var expression_exports = /* @__PURE__ */ __exportAll({
+	absent: () => absent,
+	allFields: () => allFields,
+	arrayOf: () => arrayOf,
+	elementAt: () => elementAt,
+	elementOf: () => elementOf,
+	excludeVariants: () => excludeVariants,
+	extractVariants: () => extractVariants,
+	fieldOf: () => fieldOf,
+	fieldsOf: () => fieldsOf,
+	intersect: () => intersect,
+	keyOf: () => keyOf,
+	maybeAbsent: () => maybeAbsent,
+	mergeRecords: () => mergeRecords,
+	never: () => never,
+	nullableOf: () => nullableOf,
+	omitFields: () => omitFields,
+	opaqueHostType: () => opaqueHostType,
+	partialFields: () => partialFields,
+	pickFields: () => pickFields,
+	recordOf: () => recordOf,
+	refine: () => refine,
+	requiredFields: () => requiredFields,
+	selectKeys: () => selectKeys,
+	taggedUnionOf: () => taggedUnionOf,
+	tupleOf: () => tupleOf,
+	typeVar: () => typeVar,
+	unknown: () => unknown,
+	valueOf: () => valueOf
+});
+function typeVar(name, upperBound) {
+	return upperBound === void 0 ? {
+		kind: "typeVar",
+		name
+	} : {
+		kind: "typeVar",
+		name,
+		extends: upperBound
+	};
+}
+function opaqueHostType(hostPath) {
+	return {
+		kind: "opaqueHostType",
+		hostPath
+	};
+}
+function absent() {
+	return { kind: "absent" };
+}
+function never() {
+	return { kind: "never" };
+}
+function unknown() {
+	return { kind: "unknown" };
+}
+function maybeAbsent(value) {
+	return {
+		kind: "maybeAbsent",
+		value
+	};
+}
+function arrayOf(element, constraints) {
+	return constraints === void 0 ? {
+		kind: "arrayOf",
+		element
+	} : {
+		kind: "arrayOf",
+		element,
+		constraints
+	};
+}
+function tupleOf(elements) {
+	return {
+		kind: "tupleOf",
+		elements
+	};
+}
+function recordOf(fields, options) {
+	return options === void 0 ? {
+		kind: "recordOf",
+		fields
+	} : {
+		kind: "recordOf",
+		fields,
+		...options
+	};
+}
+function nullableOf(value) {
+	return {
+		kind: "nullableOf",
+		value
+	};
+}
+function taggedUnionOf(discriminator, variants) {
+	return {
+		kind: "taggedUnionOf",
+		discriminator,
+		variants
+	};
+}
+function elementOf(source) {
+	return {
+		kind: "elementOf",
+		source
+	};
+}
+function valueOf(source) {
+	return {
+		kind: "valueOf",
+		source
+	};
+}
+function elementAt(source, index) {
+	return {
+		kind: "elementAt",
+		source,
+		index
+	};
+}
+function fieldOf(source, key) {
+	return {
+		kind: "fieldOf",
+		source,
+		key
+	};
+}
+function keyOf(source) {
+	return {
+		kind: "keyOf",
+		source
+	};
+}
+function allFields() {
+	return { kind: "all" };
+}
+function selectKeys(keys, onMissing = "error") {
+	return {
+		kind: "keys",
+		keys,
+		onMissing
+	};
+}
+function fieldsOf(source, fields) {
+	return {
+		kind: "fieldsOf",
+		source,
+		fields
+	};
+}
+function pickFields(source, fields) {
+	return {
+		kind: "pickFields",
+		source,
+		fields
+	};
+}
+function omitFields(source, fields) {
+	return {
+		kind: "omitFields",
+		source,
+		fields
+	};
+}
+function partialFields(source, fields) {
+	return {
+		kind: "partialFields",
+		source,
+		fields
+	};
+}
+function requiredFields(source, fields) {
+	return {
+		kind: "requiredFields",
+		source,
+		fields
+	};
+}
+function mergeRecords(sources, conflict) {
+	return {
+		kind: "mergeRecords",
+		sources,
+		conflict
+	};
+}
+function intersect(sources) {
+	return {
+		kind: "intersect",
+		sources
+	};
+}
+function refine(source, fields) {
+	return {
+		kind: "refine",
+		source,
+		fields
+	};
+}
+function excludeVariants(source, variants) {
+	return {
+		kind: "excludeVariants",
+		source,
+		variants
+	};
+}
+function extractVariants(source, variants) {
+	return {
+		kind: "extractVariants",
+		source,
+		variants
+	};
+}
+
+//#endregion
+export { schema_exports as n, expression_exports as t };

package/dist/chunk-bFfwrPtJ.js

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/compatibility/index.cjs

@@ -0,0 +1,43 @@
+const require_relations = require('../relations-NUVJkAG8.cjs');
+
+//#region src/compatibility/index.ts
+function status(relation) {
+	if (relation.status === "assignable") return "compatible";
+	if (relation.status === "incompatible") return "breaking";
+	if (relation.status === "unknown") return "unknown";
+	return "invalid";
+}
+function check(relation) {
+	return {
+		status: status(relation),
+		relation
+	};
+}
+function combine(left, right) {
+	if (left.status === "invalid" || right.status === "invalid") return "invalid";
+	if (left.status === "breaking" || right.status === "breaking") return "breaking";
+	if (left.status === "unknown" || right.status === "unknown") return "unknown";
+	return "compatible";
+}
+function reportSchemaCompatibility(previous, next, context = {}) {
+	const previousToNext = check(require_relations.checkSchemaRelation(previous, next, context));
+	const nextToPrevious = check(require_relations.checkSchemaRelation(next, previous, context));
+	return {
+		previousToNext,
+		nextToPrevious,
+		status: combine(previousToNext, nextToPrevious)
+	};
+}
+function reportOperationCompatibility(previous, next, context = {}) {
+	const previousToNext = check(require_relations.checkOperationRelation(previous, next, context));
+	const nextToPrevious = check(require_relations.checkOperationRelation(next, previous, context));
+	return {
+		previousToNext,
+		nextToPrevious,
+		status: combine(previousToNext, nextToPrevious)
+	};
+}
+
+//#endregion
+exports.reportOperationCompatibility = reportOperationCompatibility;
+exports.reportSchemaCompatibility = reportSchemaCompatibility;

package/dist/compatibility/index.d.cts

@@ -0,0 +1,2 @@
+import { a as reportSchemaCompatibility, i as reportOperationCompatibility, n as CompatibilityReport, r as CompatibilityStatus, t as CompatibilityCheck } from "../index-BfbClf6R.cjs";
+export { CompatibilityCheck, CompatibilityReport, CompatibilityStatus, reportOperationCompatibility, reportSchemaCompatibility };

package/dist/compatibility/index.d.ts

@@ -0,0 +1,2 @@
+import { a as reportSchemaCompatibility, i as reportOperationCompatibility, n as CompatibilityReport, r as CompatibilityStatus, t as CompatibilityCheck } from "../index-T6nFhvGQ.js";
+export { CompatibilityCheck, CompatibilityReport, CompatibilityStatus, reportOperationCompatibility, reportSchemaCompatibility };

package/dist/compatibility/index.js

@@ -0,0 +1,42 @@
+import { r as checkSchemaRelation, t as checkOperationRelation } from "../relations-QtnCRW9x.js";
+
+//#region src/compatibility/index.ts
+function status(relation) {
+	if (relation.status === "assignable") return "compatible";
+	if (relation.status === "incompatible") return "breaking";
+	if (relation.status === "unknown") return "unknown";
+	return "invalid";
+}
+function check(relation) {
+	return {
+		status: status(relation),
+		relation
+	};
+}
+function combine(left, right) {
+	if (left.status === "invalid" || right.status === "invalid") return "invalid";
+	if (left.status === "breaking" || right.status === "breaking") return "breaking";
+	if (left.status === "unknown" || right.status === "unknown") return "unknown";
+	return "compatible";
+}
+function reportSchemaCompatibility(previous, next, context = {}) {
+	const previousToNext = check(checkSchemaRelation(previous, next, context));
+	const nextToPrevious = check(checkSchemaRelation(next, previous, context));
+	return {
+		previousToNext,
+		nextToPrevious,
+		status: combine(previousToNext, nextToPrevious)
+	};
+}
+function reportOperationCompatibility(previous, next, context = {}) {
+	const previousToNext = check(checkOperationRelation(previous, next, context));
+	const nextToPrevious = check(checkOperationRelation(next, previous, context));
+	return {
+		previousToNext,
+		nextToPrevious,
+		status: combine(previousToNext, nextToPrevious)
+	};
+}
+
+//#endregion
+export { reportOperationCompatibility, reportSchemaCompatibility };

package/dist/definition/index.cjs

@@ -1,3 +1,11 @@
-const require_definition = require('../definition-DSZZTz4e.cjs');
+const require_definition = require('../definition-BLLBpLKv.cjs');
 
-exports.validateSchemaNodeDefinition = require_definition.validateSchemaNodeDefinition;
+exports.isStructuredOperationContainerDefinition = require_definition.isStructuredOperationContainerDefinition;
+exports.isStructuredOperationDefinition = require_definition.isStructuredOperationDefinition;
+exports.validateOperationContainerDefinition = require_definition.validateOperationContainerDefinition;
+exports.validateOperationDefinition = require_definition.validateOperationDefinition;
+exports.validateSchemaNodeDefinition = require_definition.validateSchemaNodeDefinition;
+exports.validateSchemaTypeExprDefinition = require_definition.validateSchemaTypeExprDefinition;
+exports.validateSchemaTypeTermDefinition = require_definition.validateSchemaTypeTermDefinition;
+exports.validateStructuredOperationContainerDefinition = require_definition.validateStructuredOperationContainerDefinition;
+exports.validateStructuredOperationDefinition = require_definition.validateStructuredOperationDefinition;

package/dist/definition/index.d.cts

@@ -1,21 +1,3 @@
-import { B as JsonValue, J as SchemaNode } from "../index-rzkFjgrt.cjs";
-
-//#region src/definition/validator.d.ts
-type SchemaNodeDefinitionPath = readonly (string | number)[];
-interface SchemaNodeDefinitionDiagnostic {
-  readonly code: string;
-  readonly path: SchemaNodeDefinitionPath;
-  readonly message: string;
-}
-type SchemaNodeDefinitionValidationResult = {
-  readonly ok: true;
-  readonly node: SchemaNode;
-  readonly issues: readonly [];
-} | {
-  readonly ok: false;
-  readonly issues: readonly SchemaNodeDefinitionDiagnostic[];
-};
-/** Validate only the serializable structural definition of one SchemaNode. */
-declare function validateSchemaNodeDefinition(value: unknown): SchemaNodeDefinitionValidationResult;
-//#endregion
-export { type JsonValue, type SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, validateSchemaNodeDefinition };
+import { ct as SchemaNode, et as JsonValue } from "../index-i7Au-FQ6.cjs";
+import { _ as validateStructuredOperationDefinition, a as validateSchemaTypeTermDefinition, b as SchemaNodeDefinitionValidationResult, c as OperationDefinitionPath, d as StructuredOperationDefinitionValidationResult, f as isStructuredOperationContainerDefinition, g as validateStructuredOperationContainerDefinition, h as validateOperationDefinition, i as validateSchemaTypeExprDefinition, l as OperationDefinitionValidationResult, m as validateOperationContainerDefinition, n as SchemaTypeExprDefinitionValidationResult, o as OperationContainerDefinitionValidationResult, p as isStructuredOperationDefinition, r as SchemaTypeTermDefinitionValidationResult, s as OperationDefinitionDiagnostic, t as SchemaTypeDefinitionDiagnostic, u as StructuredOperationContainerDefinitionValidationResult, v as SchemaNodeDefinitionDiagnostic, x as validateSchemaNodeDefinition, y as SchemaNodeDefinitionPath } from "../index-DGHMUZ5m.cjs";
+export { JsonValue, OperationContainerDefinitionValidationResult, OperationDefinitionDiagnostic, OperationDefinitionPath, OperationDefinitionValidationResult, SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, SchemaTypeDefinitionDiagnostic, SchemaTypeExprDefinitionValidationResult, SchemaTypeTermDefinitionValidationResult, StructuredOperationContainerDefinitionValidationResult, StructuredOperationDefinitionValidationResult, isStructuredOperationContainerDefinition, isStructuredOperationDefinition, validateOperationContainerDefinition, validateOperationDefinition, validateSchemaNodeDefinition, validateSchemaTypeExprDefinition, validateSchemaTypeTermDefinition, validateStructuredOperationContainerDefinition, validateStructuredOperationDefinition };

package/dist/definition/index.d.ts

@@ -1,21 +1,3 @@
-import { B as JsonValue, J as SchemaNode } from "../index-CEzHfht2.js";
-
-//#region src/definition/validator.d.ts
-type SchemaNodeDefinitionPath = readonly (string | number)[];
-interface SchemaNodeDefinitionDiagnostic {
-  readonly code: string;
-  readonly path: SchemaNodeDefinitionPath;
-  readonly message: string;
-}
-type SchemaNodeDefinitionValidationResult = {
-  readonly ok: true;
-  readonly node: SchemaNode;
-  readonly issues: readonly [];
-} | {
-  readonly ok: false;
-  readonly issues: readonly SchemaNodeDefinitionDiagnostic[];
-};
-/** Validate only the serializable structural definition of one SchemaNode. */
-declare function validateSchemaNodeDefinition(value: unknown): SchemaNodeDefinitionValidationResult;
-//#endregion
-export { type JsonValue, type SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, validateSchemaNodeDefinition };
+import { ct as SchemaNode, et as JsonValue } from "../index-1sDuqu05.js";
+import { _ as validateStructuredOperationDefinition, a as validateSchemaTypeTermDefinition, b as SchemaNodeDefinitionValidationResult, c as OperationDefinitionPath, d as StructuredOperationDefinitionValidationResult, f as isStructuredOperationContainerDefinition, g as validateStructuredOperationContainerDefinition, h as validateOperationDefinition, i as validateSchemaTypeExprDefinition, l as OperationDefinitionValidationResult, m as validateOperationContainerDefinition, n as SchemaTypeExprDefinitionValidationResult, o as OperationContainerDefinitionValidationResult, p as isStructuredOperationDefinition, r as SchemaTypeTermDefinitionValidationResult, s as OperationDefinitionDiagnostic, t as SchemaTypeDefinitionDiagnostic, u as StructuredOperationContainerDefinitionValidationResult, v as SchemaNodeDefinitionDiagnostic, x as validateSchemaNodeDefinition, y as SchemaNodeDefinitionPath } from "../index-CV8EZQy8.js";
+export { JsonValue, OperationContainerDefinitionValidationResult, OperationDefinitionDiagnostic, OperationDefinitionPath, OperationDefinitionValidationResult, SchemaNode, SchemaNodeDefinitionDiagnostic, SchemaNodeDefinitionPath, SchemaNodeDefinitionValidationResult, SchemaTypeDefinitionDiagnostic, SchemaTypeExprDefinitionValidationResult, SchemaTypeTermDefinitionValidationResult, StructuredOperationContainerDefinitionValidationResult, StructuredOperationDefinitionValidationResult, isStructuredOperationContainerDefinition, isStructuredOperationDefinition, validateOperationContainerDefinition, validateOperationDefinition, validateSchemaNodeDefinition, validateSchemaTypeExprDefinition, validateSchemaTypeTermDefinition, validateStructuredOperationContainerDefinition, validateStructuredOperationDefinition };

package/dist/definition/index.js

@@ -1,3 +1,3 @@
-import { t as validateSchemaNodeDefinition } from "../definition-BXj3T94L.js";
+import { c as validateOperationContainerDefinition, d as validateStructuredOperationDefinition, f as validateSchemaNodeDefinition, l as validateOperationDefinition, n as validateSchemaTypeTermDefinition, o as isStructuredOperationContainerDefinition, s as isStructuredOperationDefinition, t as validateSchemaTypeExprDefinition, u as validateStructuredOperationContainerDefinition } from "../definition-BH_LzXGc.js";
 
-export { validateSchemaNodeDefinition };
+export { isStructuredOperationContainerDefinition, isStructuredOperationDefinition, validateOperationContainerDefinition, validateOperationDefinition, validateSchemaNodeDefinition, validateSchemaTypeExprDefinition, validateSchemaTypeTermDefinition, validateStructuredOperationContainerDefinition, validateStructuredOperationDefinition };