schemair 0.1.0 → 0.2.0

package/dist/type-interpreter/index.d.ts

@@ -1,99 +1,2 @@
-import { A as SchemaValueTypeTerm, J as SchemaNode, k as SchemaValueTypeExpr } from "../index-CEzHfht2.js";
-import { l as RelationResult, n as RelationContext, t as AsyncRelationContext } from "../index-eK2Xgrwp.js";
-
-//#region src/type-interpreter/interpreter.d.ts
-type TypeInterpreterPath = readonly (string | number)[];
-interface TypeInterpreterDiagnostic {
-  readonly code: string;
-  readonly path: TypeInterpreterPath;
-  readonly message: string;
-}
-type TypeInterpreterStatus = 'evaluated' | 'incomplete' | 'rejected';
-type EvaluatedTypeTerm = SchemaNode | SchemaValueTypeExpr;
-type TypeInterpreterResult = {
-  readonly status: 'evaluated';
-  readonly term: EvaluatedTypeTerm;
-  readonly schema?: SchemaNode;
-  readonly unresolvedTypeVars?: readonly string[];
-  readonly issues: readonly TypeInterpreterDiagnostic[];
-} | {
-  readonly status: 'incomplete';
-  readonly issues: readonly TypeInterpreterDiagnostic[];
-} | {
-  readonly status: 'rejected';
-  readonly issues: readonly TypeInterpreterDiagnostic[];
-};
-type TypeInterpreterRefResolution = SchemaNode | {
-  readonly status: 'resolved';
-  readonly schema: SchemaNode;
-} | {
-  readonly status: 'unknown' | 'unsupported';
-  readonly message?: string;
-} | undefined;
-type AsyncTypeInterpreterRefResolution = TypeInterpreterRefResolution | PromiseLike<TypeInterpreterRefResolution>;
-interface TypeInterpreterContext {
-  readonly typeVars?: Readonly<Record<string, SchemaValueTypeTerm>>;
-  readonly resolveRef?: (refPath: readonly string[]) => TypeInterpreterRefResolution;
-  readonly maxDepth?: number;
-  readonly maxSteps?: number;
-}
-interface AsyncTypeInterpreterContext {
-  readonly typeVars?: Readonly<Record<string, SchemaValueTypeTerm>>;
-  readonly resolveRef?: (refPath: readonly string[]) => AsyncTypeInterpreterRefResolution;
-  readonly maxDepth?: number;
-  readonly maxSteps?: number;
-}
-declare function evaluateExpression(term: unknown, context?: TypeInterpreterContext): TypeInterpreterResult;
-declare function evaluateExpressionAsync(term: unknown, context?: AsyncTypeInterpreterContext): Promise<TypeInterpreterResult>;
-declare const evaluateSchemaValueTypeTerm: typeof evaluateExpression;
-declare const evaluateSchemaValueTypeTermAsync: typeof evaluateExpressionAsync;
-//#endregion
-//#region src/type-interpreter/term-relation.d.ts
-interface TypeTermRelationContext {
-  readonly interpreter?: TypeInterpreterContext;
-  readonly relation?: RelationContext;
-  readonly hostTypeRelation?: (sourcePath: readonly string[], targetPath: readonly string[]) => HostTypeRelationDecision;
-}
-interface AsyncTypeTermRelationContext {
-  readonly interpreter?: AsyncTypeInterpreterContext;
-  readonly relation?: AsyncRelationContext;
-  readonly hostTypeRelation?: (sourcePath: readonly string[], targetPath: readonly string[]) => HostTypeRelationDecision | PromiseLike<HostTypeRelationDecision>;
-}
-type HostTypeRelationDecision = boolean | {
-  readonly status: 'assignable' | 'incompatible' | 'unknown' | 'unsupported';
-  readonly message?: string;
-};
-declare function checkTypeTermRelation(source: SchemaValueTypeTerm, target: SchemaValueTypeTerm, context?: TypeTermRelationContext): RelationResult;
-declare function checkTypeTermRelationAsync(source: SchemaValueTypeTerm, target: SchemaValueTypeTerm, context?: AsyncTypeTermRelationContext): Promise<RelationResult>;
-//#endregion
-//#region src/type-interpreter/type-variable-solver.d.ts
-interface TypeVariableConstraint {
-  readonly source: SchemaValueTypeTerm;
-  readonly target: SchemaValueTypeTerm;
-}
-interface TypeVariableSolverInput {
-  readonly variables: readonly string[];
-  readonly constraints: readonly TypeVariableConstraint[];
-}
-interface TypeVariableSolverIssue {
-  readonly code: string;
-  readonly constraint?: number;
-  readonly variable?: string;
-  readonly message: string;
-}
-interface TypeVariableSolverResult {
-  readonly status: 'solved' | 'unknown' | 'incompatible' | 'rejected';
-  readonly bindings: Readonly<Record<string, EvaluatedTypeTerm>>;
-  readonly unresolved: readonly string[];
-  readonly issues: readonly TypeVariableSolverIssue[];
-}
-interface TypeVariableSolverContext extends TypeTermRelationContext {
-  readonly interpreter?: TypeInterpreterContext;
-}
-interface AsyncTypeVariableSolverContext extends AsyncTypeTermRelationContext {
-  readonly interpreter?: AsyncTypeInterpreterContext;
-}
-declare function solveTypeVariables(input: TypeVariableSolverInput, context?: TypeVariableSolverContext): TypeVariableSolverResult;
-declare function solveTypeVariablesAsync(input: TypeVariableSolverInput, context?: AsyncTypeVariableSolverContext): Promise<TypeVariableSolverResult>;
-//#endregion
-export { AsyncTypeInterpreterContext, AsyncTypeInterpreterRefResolution, AsyncTypeTermRelationContext, AsyncTypeVariableSolverContext, EvaluatedTypeTerm, HostTypeRelationDecision, TypeInterpreterContext, TypeInterpreterDiagnostic, TypeInterpreterPath, TypeInterpreterRefResolution, TypeInterpreterResult, TypeInterpreterStatus, TypeTermRelationContext, TypeVariableConstraint, TypeVariableSolverContext, TypeVariableSolverInput, TypeVariableSolverIssue, TypeVariableSolverResult, checkTypeTermRelation, checkTypeTermRelationAsync, evaluateExpression, evaluateExpressionAsync, evaluateSchemaValueTypeTerm, evaluateSchemaValueTypeTermAsync, solveTypeVariables, solveTypeVariablesAsync };
+import { C as evaluateExpression, E as evaluateSchemaTypeTermAsync, S as TypeInterpreterStatus, T as evaluateSchemaTypeTerm, _ as TypeInterpreterContext, a as TypeVariableSolverIssue, b as TypeInterpreterRefResolution, c as solveTypeVariablesAsync, d as TypeTermRelationContext, f as checkTypeTermRelation, g as EvaluatedTypeTerm, h as AsyncTypeInterpreterRefResolution, i as TypeVariableSolverInput, l as AsyncTypeTermRelationContext, m as AsyncTypeInterpreterContext, n as TypeVariableConstraint, o as TypeVariableSolverResult, p as checkTypeTermRelationAsync, r as TypeVariableSolverContext, s as solveTypeVariables, t as AsyncTypeVariableSolverContext, u as HostTypeRelationDecision, v as TypeInterpreterDiagnostic, w as evaluateExpressionAsync, x as TypeInterpreterResult, y as TypeInterpreterPath } from "../index-DM5DSLLL.js";
+export { AsyncTypeInterpreterContext, AsyncTypeInterpreterRefResolution, AsyncTypeTermRelationContext, AsyncTypeVariableSolverContext, EvaluatedTypeTerm, HostTypeRelationDecision, TypeInterpreterContext, TypeInterpreterDiagnostic, TypeInterpreterPath, TypeInterpreterRefResolution, TypeInterpreterResult, TypeInterpreterStatus, TypeTermRelationContext, TypeVariableConstraint, TypeVariableSolverContext, TypeVariableSolverInput, TypeVariableSolverIssue, TypeVariableSolverResult, checkTypeTermRelation, checkTypeTermRelationAsync, evaluateExpression, evaluateExpressionAsync, evaluateSchemaTypeTerm, evaluateSchemaTypeTermAsync, solveTypeVariables, solveTypeVariablesAsync };

package/dist/type-interpreter/index.js

@@ -1,3 +1,3 @@
-import { a as evaluateSchemaValueTypeTerm, c as checkTypeTermRelationAsync, i as evaluateExpressionAsync, n as solveTypeVariablesAsync, o as evaluateSchemaValueTypeTermAsync, r as evaluateExpression, s as checkTypeTermRelation, t as solveTypeVariables } from "../type-interpreter-Ck0VDhzn.js";
+import { a as evaluateSchemaTypeTerm, c as checkTypeTermRelationAsync, i as evaluateExpressionAsync, n as solveTypeVariablesAsync, o as evaluateSchemaTypeTermAsync, r as evaluateExpression, s as checkTypeTermRelation, t as solveTypeVariables } from "../type-interpreter-DnrId8aM.js";
 
-export { checkTypeTermRelation, checkTypeTermRelationAsync, evaluateExpression, evaluateExpressionAsync, evaluateSchemaValueTypeTerm, evaluateSchemaValueTypeTermAsync, solveTypeVariables, solveTypeVariablesAsync };
+export { checkTypeTermRelation, checkTypeTermRelationAsync, evaluateExpression, evaluateExpressionAsync, evaluateSchemaTypeTerm, evaluateSchemaTypeTermAsync, solveTypeVariables, solveTypeVariablesAsync };

package/dist/{type-interpreter-Ck0VDhzn.js → type-interpreter-DnrId8aM.js}

@@ -1,5 +1,5 @@
-import { t as validateSchemaNodeDefinition } from "./definition-BXj3T94L.js";
-import { i as checkSchemaRelationAsync, r as checkSchemaRelation } from "./relations-By0bK3UK.js";
+import { a as expressionShapeIssue, f as validateSchemaNodeDefinition, i as expressionKinds, r as expressionFields } from "./definition-DmYnDmQO.js";
+import { a as checkSchemaRelation, o as checkSchemaRelationAsync } from "./relations-ysXDmi-Z.js";
 
 //#region src/type-interpreter/materializer.ts
 function isRecord(value) {
@@ -1087,201 +1087,6 @@ async function checkTypeTermRelationAsync(source, target, context = {}) {
 
 //#endregion
 //#region src/type-interpreter/interpreter.ts
-const expressionKinds = new Set([
-	"typeVar",
-	"opaqueHostType",
-	"absent",
-	"never",
-	"unknown",
-	"maybeAbsent",
-	"arrayOf",
-	"tupleOf",
-	"recordOf",
-	"elementOf",
-	"valueOf",
-	"elementAt",
-	"fieldOf",
-	"keyOf",
-	"fieldsOf",
-	"pickFields",
-	"omitFields",
-	"partialFields",
-	"requiredFields",
-	"mergeRecords",
-	"nullableOf",
-	"taggedUnionOf",
-	"intersect",
-	"refine",
-	"excludeVariants",
-	"extractVariants"
-]);
-const expressionFields = {
-	typeVar: {
-		required: ["name"],
-		allowed: [
-			"kind",
-			"name",
-			"extends"
-		]
-	},
-	opaqueHostType: {
-		required: ["hostPath"],
-		allowed: ["kind", "hostPath"]
-	},
-	absent: {
-		required: [],
-		allowed: ["kind"]
-	},
-	never: {
-		required: [],
-		allowed: ["kind"]
-	},
-	unknown: {
-		required: [],
-		allowed: ["kind"]
-	},
-	maybeAbsent: {
-		required: ["value"],
-		allowed: ["kind", "value"]
-	},
-	arrayOf: {
-		required: ["element"],
-		allowed: [
-			"kind",
-			"element",
-			"constraints"
-		]
-	},
-	tupleOf: {
-		required: ["elements"],
-		allowed: ["kind", "elements"]
-	},
-	recordOf: {
-		required: ["fields"],
-		allowed: [
-			"kind",
-			"fields",
-			"additionalFields",
-			"constraints"
-		]
-	},
-	nullableOf: {
-		required: ["value"],
-		allowed: ["kind", "value"]
-	},
-	taggedUnionOf: {
-		required: ["discriminator", "variants"],
-		allowed: [
-			"kind",
-			"discriminator",
-			"variants"
-		]
-	},
-	elementOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	valueOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	elementAt: {
-		required: ["source", "index"],
-		allowed: [
-			"kind",
-			"source",
-			"index"
-		]
-	},
-	fieldOf: {
-		required: ["source", "key"],
-		allowed: [
-			"kind",
-			"source",
-			"key"
-		]
-	},
-	keyOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	fieldsOf: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	pickFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	omitFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	partialFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	requiredFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	mergeRecords: {
-		required: ["sources", "conflict"],
-		allowed: [
-			"kind",
-			"sources",
-			"conflict"
-		]
-	},
-	intersect: {
-		required: ["sources"],
-		allowed: ["kind", "sources"]
-	},
-	refine: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	excludeVariants: {
-		required: ["source", "variants"],
-		allowed: [
-			"kind",
-			"source",
-			"variants"
-		]
-	},
-	extractVariants: {
-		required: ["source", "variants"],
-		allowed: [
-			"kind",
-			"source",
-			"variants"
-		]
-	}
-};
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1341,90 +1146,6 @@ function childTerms(expression) {
 	});
 	return children;
 }
-function hasOnlyKeys(value, keys) {
-	return Object.keys(value).every((key) => keys.includes(key));
-}
-function isSelector(value) {
-	if (!isObject(value)) return false;
-	if (value.kind === "all") return hasOnlyKeys(value, ["kind"]);
-	return value.kind === "keys" && hasOnlyKeys(value, [
-		"kind",
-		"keys",
-		"onMissing"
-	]) && Array.isArray(value.keys) && value.keys.every((key) => typeof key === "string") && new Set(value.keys).size === value.keys.length && (value.onMissing === "error" || value.onMissing === "ignore");
-}
-function expressionShapeIssue(expression) {
-	const kind = expression.kind;
-	if (kind === "typeVar" && (typeof expression.name !== "string" || !expression.name.trim())) return "typeVar name must be non-blank";
-	if (kind === "opaqueHostType" && (!Array.isArray(expression.hostPath) || expression.hostPath.length === 0 || expression.hostPath.some((part) => typeof part !== "string" || !part.trim()))) return "hostPath must be a non-empty path";
-	if (kind === "tupleOf" && (!Array.isArray(expression.elements) || !isDense(expression.elements))) return "elements must be a dense array";
-	if (kind === "recordOf") {
-		if (!Array.isArray(expression.fields) || !isDense(expression.fields)) return "fields must be a dense array";
-		const keys = /* @__PURE__ */ new Set();
-		for (const field of expression.fields) {
-			if (!isObject(field) || !hasOnlyKeys(field, [
-				"key",
-				"value",
-				"required",
-				"description"
-			]) || typeof field.key !== "string" || keys.has(field.key)) return "record fields must have unique keys and a valid shape";
-			if (field.required !== void 0 && typeof field.required !== "boolean") return "record field required must be a boolean";
-			if (field.description !== void 0 && typeof field.description !== "string") return "record field description must be a string";
-			keys.add(field.key);
-		}
-		if (expression.additionalFields !== void 0 && expression.additionalFields !== true && !isObject(expression.additionalFields)) return "additionalFields must be a type term or true";
-		if (expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
-	}
-	if (kind === "arrayOf" && expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
-	if (kind === "taggedUnionOf") {
-		if (typeof expression.discriminator !== "string" || !expression.discriminator.trim() || !Array.isArray(expression.variants) || !isDense(expression.variants) || expression.variants.length < 2) return "taggedUnionOf requires a discriminator and at least two dense variants";
-		const keys = /* @__PURE__ */ new Set();
-		for (const variant of expression.variants) {
-			if (!isObject(variant) || !hasOnlyKeys(variant, [
-				"key",
-				"value",
-				"description"
-			]) || typeof variant.key !== "string" || !variant.key.trim() || keys.has(variant.key)) return "taggedUnionOf variants must have unique non-blank keys and a valid shape";
-			if (variant.description !== void 0 && typeof variant.description !== "string") return "variant description must be a string";
-			keys.add(variant.key);
-		}
-	}
-	if ([
-		"fieldsOf",
-		"pickFields",
-		"omitFields",
-		"partialFields",
-		"requiredFields"
-	].includes(String(kind)) && !isSelector(expression.fields)) return "fields must be a valid field selector";
-	if ((kind === "excludeVariants" || kind === "extractVariants") && !isSelector(expression.variants)) return "variants must be a valid variant selector";
-	if (kind === "elementAt" && (!Number.isSafeInteger(expression.index) || expression.index < 0)) return "index must be a non-negative safe integer";
-	if (kind === "fieldOf" && typeof expression.key !== "string") return "key must be a string";
-	if (kind === "mergeRecords" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2 || ![
-		"leftWins",
-		"rightWins",
-		"error"
-	].includes(String(expression.conflict)))) return "mergeRecords requires at least two dense sources and a valid conflict policy";
-	if (kind === "intersect" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2)) return "intersect requires at least two dense sources";
-	if (kind === "refine") {
-		if (!Array.isArray(expression.fields) || !isDense(expression.fields) || expression.fields.length === 0) return "refine requires non-empty dense field actions";
-		const keys = /* @__PURE__ */ new Set();
-		for (const action of expression.fields) {
-			if (!isObject(action) || !hasOnlyKeys(action, [
-				"key",
-				"require",
-				"intersectWith",
-				"addConstraints"
-			]) || typeof action.key !== "string" || keys.has(action.key)) return "refine actions must have unique keys and a valid shape";
-			if (action.require !== void 0 && action.require !== true) return "refine require must be true when specified";
-			if (action.addConstraints !== void 0 && (!Array.isArray(action.addConstraints) || !isDense(action.addConstraints))) return "addConstraints must be a dense array";
-			keys.add(action.key);
-		}
-	}
-}
-function isDense(value) {
-	for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) return false;
-	return true;
-}
 function replaceChild(expression, path, value) {
 	const [key, indexText, subkey] = path.split(".");
 	if (indexText === void 0) {
@@ -1760,8 +1481,8 @@ async function evaluateExpressionAsync(term, context = {}) {
 		maxSteps: Number.MAX_SAFE_INTEGER
 	});
 }
-const evaluateSchemaValueTypeTerm = evaluateExpression;
-const evaluateSchemaValueTypeTermAsync = evaluateExpressionAsync;
+const evaluateSchemaTypeTerm = evaluateExpression;
+const evaluateSchemaTypeTermAsync = evaluateExpressionAsync;
 
 //#endregion
 //#region src/type-interpreter/type-variable-solver.ts
@@ -1932,4 +1653,4 @@ async function solveTypeVariablesAsync(input, context = {}) {
 }
 
 //#endregion
-export { evaluateSchemaValueTypeTerm as a, checkTypeTermRelationAsync as c, evaluateExpressionAsync as i, solveTypeVariablesAsync as n, evaluateSchemaValueTypeTermAsync as o, evaluateExpression as r, checkTypeTermRelation as s, solveTypeVariables as t };
+export { evaluateSchemaTypeTerm as a, checkTypeTermRelationAsync as c, evaluateExpressionAsync as i, solveTypeVariablesAsync as n, evaluateSchemaTypeTermAsync as o, evaluateExpression as r, checkTypeTermRelation as s, solveTypeVariables as t };