schemair 0.1.0 → 0.2.0

package/dist/{type-interpreter-DAIBUqKf.cjs → type-interpreter-OLt2W2yd.cjs}

@@ -1,5 +1,5 @@
-const require_definition = require('./definition-DSZZTz4e.cjs');
-const require_relations = require('./relations-CMz_0nf4.cjs');
+const require_definition = require('./definition-BLLBpLKv.cjs');
+const require_relations = require('./relations-Cymx4iTc.cjs');
 
 //#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);
 }
@@ -1292,7 +1097,7 @@ function result(term, issues = []) {
 	const unresolved = /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Set();
 	const visit = (value) => {
-		if (!isObject(value) || seen.has(value) || typeof value.kind !== "string" || !expressionKinds.has(value.kind)) return;
+		if (!isObject(value) || seen.has(value) || typeof value.kind !== "string" || !require_definition.expressionKinds.has(value.kind)) return;
 		seen.add(value);
 		if (value.kind === "typeVar" && typeof value.name === "string") unresolved.add(value.name);
 		for (const [, child] of childTerms(value)) visit(child);
@@ -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) {
@@ -1571,13 +1292,13 @@ function normalize(term, state, depth = 0) {
 		}
 	}
 	const kind = term.kind;
-	if (typeof kind !== "string" || !expressionKinds.has(kind)) return failure("rejected", "expression.kind", "term is neither a valid SchemaNode nor a supported expression");
-	const shape = expressionFields[kind];
+	if (typeof kind !== "string" || !require_definition.expressionKinds.has(kind)) return failure("rejected", "expression.kind", "term is neither a valid SchemaNode nor a supported expression");
+	const shape = require_definition.expressionFields[kind];
 	const unexpected = Object.keys(term).find((key) => !shape.allowed.includes(key));
 	if (unexpected) return failure("rejected", "expression.shape", `unknown field '${unexpected}' for expression '${kind}'`);
 	const missing = shape.required.find((key) => !(key in term));
 	if (missing) return failure("rejected", "expression.shape", `expression '${kind}' requires field '${missing}'`);
-	const shapeIssue = expressionShapeIssue(term);
+	const shapeIssue = require_definition.expressionShapeIssue(term);
 	if (shapeIssue) return failure("rejected", "expression.shape", shapeIssue);
 	if (state.active.has(term)) return failure("incomplete", "cycle.expression", "expression cycle could not be determined");
 	if (kind === "unknown") return result({ kind: "unknown" });
@@ -1738,10 +1459,10 @@ async function evaluateExpressionAsync(term, context = {}) {
 				}
 			}
 			const kind = value.kind;
-			if (typeof kind !== "string" || !expressionKinds.has(kind)) return { value };
-			const shape = expressionFields[kind];
+			if (typeof kind !== "string" || !require_definition.expressionKinds.has(kind)) return { value };
+			const shape = require_definition.expressionFields[kind];
 			if (Object.keys(value).some((key) => !shape.allowed.includes(key)) || shape.required.some((key) => !(key in value))) return { value };
-			if (expressionShapeIssue(value)) return { value };
+			if (require_definition.expressionShapeIssue(value)) return { value };
 			const copy = { ...value };
 			for (const [path, child] of childTerms(value)) {
 				const resolved$1 = await resolveTree(child, depth + 1);
@@ -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
@@ -1956,16 +1677,16 @@ Object.defineProperty(exports, 'evaluateExpressionAsync', {
     return evaluateExpressionAsync;
   }
 });
-Object.defineProperty(exports, 'evaluateSchemaValueTypeTerm', {
+Object.defineProperty(exports, 'evaluateSchemaTypeTerm', {
   enumerable: true,
   get: function () {
-    return evaluateSchemaValueTypeTerm;
+    return evaluateSchemaTypeTerm;
   }
 });
-Object.defineProperty(exports, 'evaluateSchemaValueTypeTermAsync', {
+Object.defineProperty(exports, 'evaluateSchemaTypeTermAsync', {
   enumerable: true,
   get: function () {
-    return evaluateSchemaValueTypeTermAsync;
+    return evaluateSchemaTypeTermAsync;
   }
 });
 Object.defineProperty(exports, 'solveTypeVariables', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schemair",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "TypeScript wire bindings and authoring tools for SchemaIR",
   "license": "Apache-2.0",
   "homepage": "https://github.com/schemair/schemair#readme",
@@ -16,7 +16,9 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
       "import": {
@@ -87,12 +89,42 @@
         "types": "./dist/authoring/index.d.cts",
         "default": "./dist/authoring/index.cjs"
       }
+    },
+    "./standard": {
+      "import": {
+        "types": "./dist/standard/index.d.ts",
+        "default": "./dist/standard/index.js"
+      },
+      "require": {
+        "types": "./dist/standard/index.d.cts",
+        "default": "./dist/standard/index.cjs"
+      }
+    },
+    "./standard-schema": {
+      "import": {
+        "types": "./dist/integrations/standard-schema/index.d.ts",
+        "default": "./dist/integrations/standard-schema/index.js"
+      },
+      "require": {
+        "types": "./dist/integrations/standard-schema/index.d.cts",
+        "default": "./dist/integrations/standard-schema/index.cjs"
+      }
+    },
+    "./json-schema": {
+      "import": {
+        "types": "./dist/integrations/json-schema/index.d.ts",
+        "default": "./dist/integrations/json-schema/index.js"
+      },
+      "require": {
+        "types": "./dist/integrations/json-schema/index.d.cts",
+        "default": "./dist/integrations/json-schema/index.cjs"
+      }
     }
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "tsdown",
-    "test": "node --import tsx --test tests/conformance.test.ts",
+    "test": "node --import tsx --test tests/*.test.ts",
     "test:package": "pnpm build && node --test tests/package-exports.test.mjs",
     "prepack": "pnpm build"
   },
@@ -101,5 +133,8 @@
     "tsdown": "^0.18.2",
     "tsx": "^4.20.0",
     "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0"
   }
 }