@x0k/json-schema-merge 1.0.0

package/dist/lib/json-schema/json-schema.js

@@ -0,0 +1,56 @@
+import { isRecordEmpty } from "../object.js";
+export const JSON_SCHEMA_TYPE_NAMES = [
+    "array",
+    "boolean",
+    "integer",
+    "null",
+    "number",
+    "object",
+    "string",
+];
+export const SET_OF_JSON_SCHEMA_TYPE_NAMES = new Set(JSON_SCHEMA_TYPE_NAMES);
+export function isJsonSchemaType(type) {
+    return SET_OF_JSON_SCHEMA_TYPE_NAMES.has(type);
+}
+// WARN: Order is important
+export const RECORDS_OF_SUB_SCHEMAS = [
+    "$defs",
+    "definitions",
+    "properties",
+    "patternProperties",
+    "dependencies",
+];
+export const SET_OF_RECORDS_OF_SUB_SCHEMAS = new Set(RECORDS_OF_SUB_SCHEMAS);
+// WARN: Order is important
+export const ARRAYS_OF_SUB_SCHEMAS = [
+    "items",
+    "allOf",
+    "oneOf",
+    "anyOf",
+];
+export const SET_OF_ARRAYS_OF_SUB_SCHEMAS = new Set(ARRAYS_OF_SUB_SCHEMAS);
+// WARN: Order is important
+export const SUB_SCHEMAS = [
+    "items",
+    "additionalItems",
+    "additionalProperties",
+    "propertyNames",
+    "contains",
+    "if",
+    "then",
+    "else",
+    "not",
+];
+export const SET_OF_SUB_SCHEMAS = new Set(SUB_SCHEMAS);
+// WARN: Order is important
+export const ALL_SUB_SCHEMA_KEYS = [
+    ...RECORDS_OF_SUB_SCHEMAS,
+    ...ARRAYS_OF_SUB_SCHEMAS,
+    ...SUB_SCHEMAS,
+];
+export function isSchemaObject(schemaDef) {
+    return typeof schemaDef === "object";
+}
+export function isAllowAnySchema(def) {
+    return isSchemaObject(def) ? isRecordEmpty(def) : def === true;
+}

package/dist/lib/json-schema/merge/all-of-merge.d.ts

@@ -0,0 +1,3 @@
+import type { JSONSchema7Definition } from "json-schema";
+export declare function createShallowAllOfMerge(mergeArrayOfSchemaDefinitions: (defs: JSONSchema7Definition[]) => JSONSchema7Definition): (schema: JSONSchema7Definition) => JSONSchema7Definition;
+export declare function createDeepAllOfMerge(shallowMerge: (def: JSONSchema7Definition) => JSONSchema7Definition): (schemaDef: JSONSchema7Definition) => JSONSchema7Definition;

package/dist/lib/json-schema/merge/all-of-merge.js

@@ -0,0 +1,29 @@
+import { transformSchemaDefinition } from "../transform.js";
+function getAllOfSchemas(schema) {
+    const result = [];
+    const stack = [schema];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (typeof current === "boolean" || current.allOf === undefined) {
+            result.push(current);
+            continue;
+        }
+        const { allOf, ...rest } = current;
+        result.push(rest);
+        for (let i = allOf.length - 1; i >= 0; i--) {
+            stack.push(allOf[i]);
+        }
+    }
+    return result;
+}
+export function createShallowAllOfMerge(mergeArrayOfSchemaDefinitions) {
+    return (schema) => mergeArrayOfSchemaDefinitions(getAllOfSchemas(schema));
+}
+export function createDeepAllOfMerge(shallowMerge) {
+    return (schemaDef) => transformSchemaDefinition(schemaDef, (def) => {
+        if (typeof def === "boolean" || def.allOf === undefined) {
+            return def;
+        }
+        return shallowMerge(def);
+    });
+}

package/dist/lib/json-schema/merge/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./merge.ts";
+export * from "./all-of-merge.ts";
+export * from "./patterns.ts";

package/dist/lib/json-schema/merge/index.js

@@ -0,0 +1,3 @@
+export * from "./merge.js";
+export * from "./all-of-merge.js";
+export * from "./patterns.js";

package/dist/lib/json-schema/merge/merge.d.ts

@@ -0,0 +1,91 @@
+import type { JSONSchema7, JSONSchema7Definition, JSONSchema7Type } from "json-schema";
+import { type Deduplicator, type Intersector } from "../../array.ts";
+type SchemaKey = keyof JSONSchema7;
+/**
+ * An assigner function operates at the schema-object level.
+ * It receives the partially merged `target` and the original
+ * `left` and `right` schemas.
+ *
+ * In most cases, it modifies and returns the `target` object,
+ * but it may also return a completely new schema object if needed.
+ *
+ * Assigners are used for keywords that cannot be merged by simple
+ * value-level functions, often because they interact with other
+ * keywords or require holistic decisions.
+ */
+export type Assigner<R extends {}> = (target: R, l: R, r: R) => R;
+/**
+ * A merger function combines two values for a specific JSON Schema keyword.
+ */
+export type Merger<T> = (a: T, b: T) => T;
+/**
+ * A validation function that ensures consistency between two schema keywords.
+ */
+export type Check<K extends SchemaKey> = (target: Required<Pick<JSONSchema7, K>>) => boolean;
+export type CheckEntry<A extends SchemaKey, B extends SchemaKey> = readonly [
+    A,
+    B,
+    Check<A | B>
+];
+export declare function check<A extends SchemaKey, B extends SchemaKey>(a: A, b: B, check: Check<A | B>): CheckEntry<A, B>;
+export interface MergeOptions {
+    /**
+     * Custom function to test whether a regular expression `subExpr`
+     * is considered a subset of another `superExpr`.
+     * @default Object.is
+     */
+    isSubRegExp?: (subExpr: string, superExpr: string) => boolean;
+    /**
+     * Merger function for combining regular expression patterns
+     * @default simplePatternsMerger
+     */
+    mergePatterns?: Merger<string>;
+    /**
+     * Intersector function for merging JSON values (enum keyword)
+     * @default intersection
+     */
+    intersectJson?: Intersector<JSONSchema7Type>;
+    /**
+     * Deduplication strategy for JSON Schema definitions.
+     * @default identity
+     */
+    deduplicateJsonSchemaDef?: Deduplicator<JSONSchema7Definition>;
+    /**
+     * Fallback merger applied when no keyword-specific merger is defined.
+     * @default identity
+     */
+    defaultMerger?: Merger<any>;
+    /**
+     * A mapping of schema keywords to merger functions.
+     *
+     * - A merger operates on **values of a single keyword** (`a`, `b` → merged value).
+     * - When provided, a custom merger **overrides the default merger** for that keyword.
+     */
+    mergers?: Partial<{
+        [K in SchemaKey]: Merger<Exclude<JSONSchema7[K], undefined>>;
+    }>;
+    /**
+     * A collection of keyword groups with associated assigner functions.
+     *
+     * - An assigner operates at the **schema-object level** (`target`, `left`, `right`).
+     * - Custom assigners are **appended** to the default assigners,
+     *   but can also **replace behavior** for specific keywords if they overlap.
+     */
+    assigners?: Iterable<[SchemaKey[], Assigner<JSONSchema7>]>;
+    /**
+     * Consistency checks to validate relationships between
+     * pairs of schema keywords (e.g. `minimum` ≤ `maximum`).
+     *
+     * - A check ensures that two related keywords do not conflict.
+     * - Providing this option **replaces the default checks** completely.
+     *
+     * @default DEFAULT_CHECKS
+     */
+    checks?: Iterable<CheckEntry<SchemaKey, SchemaKey>>;
+}
+export declare const DEFAULT_CHECKS: (CheckEntry<"minimum", "maximum"> | CheckEntry<"exclusiveMinimum", "maximum"> | CheckEntry<"minimum", "exclusiveMaximum"> | CheckEntry<"exclusiveMinimum", "exclusiveMaximum"> | CheckEntry<"minLength", "maxLength"> | CheckEntry<"minItems", "maxItems"> | CheckEntry<"minProperties", "maxProperties">)[];
+export declare function createMerger({ mergePatterns, isSubRegExp, intersectJson, deduplicateJsonSchemaDef, defaultMerger, assigners, checks, mergers, }?: MergeOptions): {
+    mergeSchemaDefinitions: (left: JSONSchema7Definition, right: JSONSchema7Definition) => boolean | JSONSchema7;
+    mergeArrayOfSchemaDefinitions: (schemas: JSONSchema7Definition[]) => JSONSchema7Definition;
+};
+export {};