@x0k/json-schema-merge 1.0.4 → 1.0.6

package/src/lib/json-schema/merge/patterns.ts

@@ -0,0 +1,7 @@
+export function legacyPatternsMerger(a: string, b: string): string {
+  return a === b ? a : `(?=${a})(?=${b})`;
+}
+
+export function simplePatternsMerger(a: string, b: string): string {
+  return a === b ? a : `(?=.*(?:${a}))(?=.*(?:${b}))`;
+}

package/src/lib/json-schema/transform.ts

@@ -0,0 +1,99 @@
+import type {
+  JSONSchema7 as Schema,
+  JSONSchema7Definition as SchemaDefinition,
+} from "json-schema";
+
+import {
+  SUB_SCHEMAS,
+  RECORDS_OF_SUB_SCHEMAS,
+  ARRAYS_OF_SUB_SCHEMAS,
+  isSchemaObject,
+  type AnySubSchemaKey,
+  type TransformedSchemaDefinition,
+  type TransformedSchema,
+} from "./json-schema.ts";
+import type {
+  ArraySchemaTraverserContext,
+  RecordSchemaTraverserContext,
+  SchemaTraverserContext,
+  SubSchemaTraverserContext,
+} from "./traverse.ts";
+
+export function transformSchemaDefinition<R>(
+  schema: SchemaDefinition,
+  transform: (
+    shallowCopy: TransformedSchemaDefinition<R, Schema>,
+    ctx: SchemaTraverserContext<AnySubSchemaKey>
+  ) => R,
+  ctx: SchemaTraverserContext<AnySubSchemaKey> = { type: "root", path: [] }
+): R {
+  if (!isSchemaObject(schema)) {
+    return transform(schema, ctx);
+  }
+  const shallowCopy = {
+    ...schema,
+  } as TransformedSchema<R, Schema>;
+  for (const key of ARRAYS_OF_SUB_SCHEMAS) {
+    const array = schema[key];
+    if (array === undefined || !Array.isArray(array)) {
+      continue;
+    }
+    const c: ArraySchemaTraverserContext<AnySubSchemaKey> = {
+      type: "array",
+      parent: schema,
+      key,
+      index: 0,
+      path: ctx.path.concat(key, 0),
+    };
+    shallowCopy[key] = array.map((item, index) => {
+      c.index = index;
+      c.path[c.path.length - 1] = index;
+      return transformSchemaDefinition(item, transform, c);
+    });
+  }
+  const map = new Map<string, R | string[]>();
+  for (const key of RECORDS_OF_SUB_SCHEMAS) {
+    const record = schema[key];
+    if (record === undefined) {
+      continue;
+    }
+    const c: RecordSchemaTraverserContext<AnySubSchemaKey> = {
+      type: "record",
+      parent: schema,
+      key,
+      property: "",
+      path: ctx.path.concat(key, ""),
+    };
+    const keys = Object.keys(record);
+    const keysLen = keys.length;
+    for (let i = 0; i < keysLen; i++) {
+      const property = keys[i]!;
+      const value = record[property]!;
+      if (Array.isArray(value)) {
+        map.set(property, value);
+        continue;
+      }
+      c.property = property;
+      c.path[c.path.length - 1] = property;
+      map.set(property, transformSchemaDefinition(value, transform, c));
+    }
+    shallowCopy[key] = Object.fromEntries(map) as Record<string, R>;
+    map.clear();
+  }
+  const c: SubSchemaTraverserContext<AnySubSchemaKey> = {
+    type: "sub",
+    parent: schema,
+    key: "items",
+    path: ctx.path.concat(""),
+  };
+  for (const key of SUB_SCHEMAS) {
+    const value = schema[key];
+    if (value === undefined || Array.isArray(value)) {
+      continue;
+    }
+    c.key = key;
+    c.path[c.path.length - 1] = key;
+    shallowCopy[key] = transformSchemaDefinition(value, transform, c);
+  }
+  return transform(shallowCopy, ctx);
+}

package/src/lib/json-schema/traverse.ts

@@ -0,0 +1,61 @@
+import type {
+  JSONSchema7 as Schema,
+  JSONSchema7Definition as SchemaDefinition,
+} from "json-schema";
+
+import type { Visitor } from "../traverser.ts";
+
+import type {
+  AnySubSchemaKey,
+  SubSchemaKey,
+  SubSchemasArrayKey,
+  SubSchemasRecordKey,
+} from "./json-schema.ts";
+
+export type SchemaTraverserContextType = "array" | "record" | "sub" | "root";
+
+export interface AbstractSchemaTraverserContext<
+  T extends SchemaTraverserContextType,
+  K extends AnySubSchemaKey,
+> {
+  type: T;
+  path: SubSchemasArrayKey extends K ? Array<string | number> : string[];
+}
+
+export interface ArraySchemaTraverserContext<
+  K extends AnySubSchemaKey,
+> extends AbstractSchemaTraverserContext<"array", K> {
+  parent: Schema;
+  key: SubSchemasArrayKey & K;
+  index: number;
+}
+
+export interface RecordSchemaTraverserContext<
+  K extends AnySubSchemaKey,
+> extends AbstractSchemaTraverserContext<"record", K> {
+  parent: Schema;
+  key: SubSchemasRecordKey & K;
+  property: string;
+}
+
+export interface SubSchemaTraverserContext<
+  K extends AnySubSchemaKey,
+> extends AbstractSchemaTraverserContext<"sub", K> {
+  parent: Schema;
+  key: SubSchemaKey & K;
+}
+export interface RootSchemaTraverserContext<
+  K extends AnySubSchemaKey,
+> extends AbstractSchemaTraverserContext<"root", K> {}
+
+export type SchemaTraverserContext<K extends AnySubSchemaKey> =
+  | ArraySchemaTraverserContext<K>
+  | RecordSchemaTraverserContext<K>
+  | SubSchemaTraverserContext<K>
+  | RootSchemaTraverserContext<K>;
+
+export type SchemaDefinitionVisitor<K extends AnySubSchemaKey, R> = Visitor<
+  SchemaDefinition,
+  SchemaTraverserContext<K>,
+  R
+>;

package/src/lib/math.ts

@@ -0,0 +1,3 @@
+export const gcd = (a: number, b: number): number => (a ? gcd(b % a, a) : b);
+export const lcm = (a: number, b: number): number =>
+  Math.abs(a * b) / gcd(a, b);

package/src/lib/memoize.ts

@@ -0,0 +1,24 @@
+export interface MapLike<K, V> {
+  has(key: K): boolean;
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+}
+
+export function memoize<Arg, Return>(
+  cache: MapLike<Arg, Return>,
+  func: (arg: Arg) => Return
+): (arg: Arg) => Return {
+  return (arg: Arg) => {
+    if (cache.has(arg)) {
+      return cache.get(arg)!;
+    }
+    const ret = func(arg);
+    cache.set(arg, ret);
+    return ret;
+  };
+}
+
+export const weakMemoize = memoize as <Arg extends object, Return>(
+  cache: WeakMap<Arg, Return>,
+  fn: (arg: Arg) => Return
+) => (arg: Arg) => Return;

package/src/lib/object.ts

@@ -0,0 +1,16 @@
+export function isObject(value: unknown): value is object {
+  return value !== null && typeof value === "object";
+}
+
+const objProto = Object.prototype;
+
+export function isRecordEmpty<R extends Record<string, any>>(
+  rec: R | Record<string, never>
+): rec is Record<string, never> {
+  for (const key in rec) {
+    if (objProto.hasOwnProperty.call(rec, key)) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/lib/ord.ts

@@ -0,0 +1,16 @@
+export type Comparator<T> = (a: T, b: T) => number;
+
+export interface ComparableTypes {
+  number: number;
+  string: string;
+  boolean: boolean;
+  bigint: bigint;
+}
+
+export type Comparable = ComparableTypes[keyof ComparableTypes];
+
+export function ascComparator<T extends Comparable>(a: T, b: T) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}

package/src/lib/traverser.ts

@@ -0,0 +1,4 @@
+export interface Visitor<Node, Context, R> {
+  onEnter?: (node: Node, ctx: Context) => Generator<R>;
+  onLeave?: (node: Node, ctx: Context) => Generator<R>;
+}