@effected/schemastore 0.4.0 → 0.6.0

package/index.js

@@ -1,14 +1,13 @@
-import { KeywordFamilies } from "./KeywordFamilies.js";
-import { AnnotationCarriers, CarrierDepthExceededError } from "./AnnotationCarriers.js";
 import { CanonicalJson, JsonDepthExceededError, NonJsonValueError } from "./CanonicalJson.js";
 import { InvalidSchemaVersionError, SchemaVersion, SchemaVersioning } from "./SchemaVersioning.js";
 import { CatalogEntry, CatalogLintFinding } from "./CatalogEntry.js";
+import { KeywordFamilies } from "./KeywordFamilies.js";
 import { DocumentDiff } from "./DocumentDiff.js";
 import { DocumentLint, DocumentLintFinding } from "./DocumentLint.js";
 import { SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError } from "./SchemaFile.js";
 import { SchemaValidator, SchemaValidatorError, ValidationFinding } from "./SchemaValidator.js";
-import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument } from "./StoreDocument.js";
-import { PipelineFinding, SchemaGateError, SchemaPipeline } from "./SchemaPipeline.js";
+import { DRAFT_07_META_SCHEMA, SchemaConversionError, StoreDocument, UndeclaredAnnotationKeyError } from "./StoreDocument.js";
+import { ContractChangeTarget, PipelineFinding, SchemaContractChangeError, SchemaGateError, SchemaPipeline } from "./SchemaPipeline.js";
 import { SchemaTarget } from "./SchemaTarget.js";
 
-export { AnnotationCarriers, CanonicalJson, CarrierDepthExceededError, CatalogEntry, CatalogLintFinding, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, ValidationFinding };
+export { CanonicalJson, CatalogEntry, CatalogLintFinding, ContractChangeTarget, DRAFT_07_META_SCHEMA, DocumentDiff, DocumentLint, DocumentLintFinding, InvalidSchemaVersionError, JsonDepthExceededError, KeywordFamilies, NonJsonValueError, PipelineFinding, SchemaContractChangeError, SchemaConversionError, SchemaFile, SchemaFileNotFoundError, SchemaFileReadError, SchemaFileWriteError, SchemaGateError, SchemaPipeline, SchemaTarget, SchemaValidator, SchemaValidatorError, SchemaVersion, SchemaVersioning, StoreDocument, UndeclaredAnnotationKeyError, ValidationFinding };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/schemastore",
-	"version": "0.4.0",
+	"version": "0.6.0",
 	"private": false,
 	"description": "Build, validate, version and publish SchemaStore-shaped Draft-07 JSON Schema documents from Effect Schema sources: document assembly, ajv strict-mode validation, structural lints, catalog entries, canonical JSON and a content-comparing emit pipeline.",
 	"keywords": [
@@ -38,11 +38,11 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/semver": "^0.5.0",
+		"@effected/semver": "^0.6.0",
 		"ajv": "^8.20.0"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-rc.109"
+		"effect": "4.0.0-rc.112"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.12"
+      "packageVersion": "7.59.0"
     }
   ]
 }

package/AnnotationCarriers.js

@@ -1,137 +0,0 @@
-import { KeywordFamilies } from "./KeywordFamilies.js";
-import { Effect, Result, Schema } from "effect";
-
-//#region src/AnnotationCarriers.ts
-/**
-* Indicates that the carrier re-graft walk nested past the package's
-* hardening cap (256 levels), which also intercepts cyclic inputs before
-* they can recurse forever.
-*
-* Raised by {@link AnnotationCarriers.carry}.
-*
-* @public
-*/
-var CarrierDepthExceededError = class extends Schema.TaggedError()("CarrierDepthExceededError", {
-	/** JSON pointer (in the lowered document's coordinates) where the cap was hit. */
-	path: Schema.String,
-	/** The nesting cap that was exceeded. */
-	maxDepth: Schema.Number
-}) {
-	get message() {
-		return `Carrier re-graft nesting exceeds ${this.maxDepth} levels at "${this.path}"`;
-	}
-};
-var CarryFailure = class {
-	error;
-	constructor(error) {
-		this.error = error;
-	}
-};
-const escapePointerSegment = (segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1");
-const isSchemaObject = (node) => typeof node === "object" && node !== null && !Array.isArray(node);
-const graftMap = (source, target, path, depth) => {
-	if (!isSchemaObject(source) || !isSchemaObject(target)) return target;
-	const out = { ...target };
-	for (const [name, subschema] of Object.entries(source)) if (Object.hasOwn(target, name)) out[name] = graft(subschema, target[name], `${path}/${escapePointerSegment(name)}`, depth + 1);
-	return out;
-};
-const graftArray = (source, target, path, depth) => {
-	if (!Array.isArray(source) || !Array.isArray(target)) return target;
-	return target.map((element, index) => index < source.length ? graft(source[index], element, `${path}/${index}`, depth + 1) : element);
-};
-const graft = (source, target, path, depth) => {
-	if (depth >= 256) throw new CarryFailure(CarrierDepthExceededError.make({
-		path,
-		maxDepth: 256
-	}));
-	if (!isSchemaObject(source) || !isSchemaObject(target)) return target;
-	const out = { ...target };
-	for (const [key, value] of Object.entries(source)) {
-		if (KeywordFamilies.isDeclared(key)) {
-			out[key] = value;
-			continue;
-		}
-		const keyPath = `${path}/${escapePointerSegment(key)}`;
-		switch (key) {
-			case "properties":
-			case "patternProperties":
-				if (Object.hasOwn(out, key)) out[key] = graftMap(value, out[key], keyPath, depth);
-				break;
-			case "additionalProperties":
-			case "propertyNames":
-				if (Object.hasOwn(out, key)) out[key] = graft(value, out[key], keyPath, depth + 1);
-				break;
-			case "allOf":
-			case "anyOf":
-			case "oneOf":
-				if (Object.hasOwn(out, key)) out[key] = graftArray(value, out[key], keyPath, depth);
-				break;
-			case "prefixItems":
-				if (Object.hasOwn(out, "items")) out.items = Array.isArray(value) ? graftArray(value, out.items, `${path}/items`, depth) : graft(value, out.items, `${path}/items`, depth + 1);
-				break;
-			case "items": if (Object.hasOwn(source, "prefixItems")) {
-				if (Object.hasOwn(out, "additionalItems")) out.additionalItems = graft(value, out.additionalItems, `${path}/additionalItems`, depth + 1);
-			} else if (Object.hasOwn(out, "items")) out.items = graft(value, out.items, keyPath, depth + 1);
-		}
-	}
-	return out;
-};
-/**
-* Re-grafts the declared non-standard keyword families
-* ({@link KeywordFamilies}) from a Draft 2020-12 schema node onto its
-* lowered Draft-07 counterpart.
-*
-* Why this exists: annotation keys admitted into the Draft 2020-12 document
-* (core's `includeAnnotationKey`) are **dropped by core's Draft-07 lowering**,
-* whose keyword walk copies a fixed subset — verified against the installed
-* beta. Carrying `x-taplo`, `x-tombi-*`, `x-intellij-*` or the vscode set
-* into an emitted SchemaStore document therefore requires this post-lowering
-* step; it cannot ride `ToJsonSchemaOptions` alone.
-*
-* The walk mirrors the lowering's own structural rules, so every carrier
-* lands on the node the annotation was attached to — including the one
-* coordinate move the lowering makes (2020-12 `prefixItems[i]` → Draft-07
-* `items[i]`, trailing `items` → `additionalItems`). Only declared-family
-* keys are copied; nothing else about the target changes.
-*
-* `StoreDocument.fromSchema` applies this automatically to the root schema
-* and every `$defs` pool entry — annotate a schema node
-* (`Schema.String.annotate({ "x-taplo": { hidden: true } })`) and the key
-* appears in the built document. Call this directly only when driving core's
-* pipeline yourself.
-*
-* Know the boundary (core behavior, probed at the installed beta): an
-* annotation must sit on the schema **definition** node. Annotating a
-* hoisted (identifier-carrying) schema at its *usage* site — e.g.
-* `Person.annotate({...})` inside a struct field — reaches neither the
-* `$ref` node nor the pool entry, even in the 2020-12 document, so there is
-* nothing to carry.
-*
-* @public
-*/
-var AnnotationCarriers = class AnnotationCarriers {
-	constructor() {}
-	/**
-	* Grafts declared-family keys from `source` (a Draft 2020-12 schema
-	* node) onto `target` (its lowered Draft-07 counterpart), returning a
-	* new node. Pure and synchronous — the primitive form;
-	* {@link AnnotationCarriers.carry} is the same walk behind a span.
-	*/
-	static carryResult(source, target) {
-		try {
-			return Result.succeed(graft(source, target, "", 0));
-		} catch (cause) {
-			if (cause instanceof CarryFailure) return Result.fail(cause.error);
-			throw cause;
-		}
-	}
-	/**
-	* Effect form of {@link AnnotationCarriers.carryResult}, adding only the
-	* `AnnotationCarriers.carry` span. Defined in terms of the `Result`
-	* primitive — synchronous callers can use that variant directly.
-	*/
-	static carry = Effect.fn("AnnotationCarriers.carry")((source, target) => Effect.fromResult(AnnotationCarriers.carryResult(source, target)));
-};
-
-//#endregion
-export { AnnotationCarriers, CarrierDepthExceededError };