import type { JsonObject } from "./types.js";
import { isJsonObject } from "./types.js";
export function areJsonValuesEqual(left: unknown, right: unknown): boolean {
if (Object.is(left, right)) {
return true;
}
if (Array.isArray(left) || Array.isArray(right)) {
if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
return false;
}
for (let i = 0; i < left.length; i += 1) {
if (!areJsonValuesEqual(left[i], right[i])) {
return false;
}
}
return true;
}
if (!isJsonObject(left) || !isJsonObject(right)) {
return false;
}
let rightLen = 0;
for (const _ in right) rightLen++;
let leftLen = 0;
for (const key in left) {
leftLen++;
if (!(key in right) || !areJsonValuesEqual(left[key], right[key])) return false;
}
return leftLen === rightLen;
}
export function mergeCompatibleEnumSchemas(existing: unknown, incoming: unknown): JsonObject | null {
if (!isJsonObject(existing) || !isJsonObject(incoming)) {
return null;
}
const existingEnum = Array.isArray(existing.enum) ? existing.enum : null;
const incomingEnum = Array.isArray(incoming.enum) ? incoming.enum : null;
if (!existingEnum || !incomingEnum) {
return null;
}
if (!areJsonValuesEqual(existing.type, incoming.type)) {
return null;
}
let existingNonEnumCount = 0;
for (const key in existing) {
if (key !== "enum") existingNonEnumCount++;
}
let incomingNonEnumCount = 0;
for (const key in incoming) {
if (key !== "enum") incomingNonEnumCount++;
}
if (existingNonEnumCount !== incomingNonEnumCount) {
return null;
}
for (const key in existing) {
if (key === "enum") continue;
if (!(key in incoming) || !areJsonValuesEqual(existing[key], incoming[key])) {
return null;
}
}
const mergedEnum = [...existingEnum];
for (const enumValue of incomingEnum) {
if (!mergedEnum.some((existingValue) => areJsonValuesEqual(existingValue, enumValue))) {
mergedEnum.push(enumValue);
}
}
return {
...existing,
enum: mergedEnum,
};
}
function getAnyOfVariants(schema: unknown): unknown[] {
if (isJsonObject(schema) && Array.isArray(schema.anyOf)) {
return schema.anyOf;
}
return [schema];
}
export function mergePropertySchemas(existing: unknown, incoming: unknown): unknown {
if (areJsonValuesEqual(existing, incoming)) {
return existing;
}
const mergedEnumSchema = mergeCompatibleEnumSchemas(existing, incoming);
if (mergedEnumSchema !== null) {
return mergedEnumSchema;
}
const mergedAnyOf = [...getAnyOfVariants(existing)];
for (const variant of getAnyOfVariants(incoming)) {
if (!mergedAnyOf.some((existingVariant) => areJsonValuesEqual(existingVariant, variant))) {
mergedAnyOf.push(variant);
}
}
return mergedAnyOf.length === 1 ? mergedAnyOf[0] : { anyOf: mergedAnyOf };
}