@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.74

package/src/json-schema-subset/checker/equals.ts

@@ -0,0 +1,93 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+import type { ExtendsContext } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+
+import { getId, isCompiledSchema } from '../compiler/index.ts'
+
+export function schemaEqualsChecker<E>(extendsContext: ExtendsContext): (schema1: Schema<E>, schema2: Schema<E>) => boolean {
+  function isSchemaEquals(schema1: Schema<E>, schema2: Schema<E>): boolean {
+    const isExtends1 = extendsContext.isExtendsSchema(schema1)
+    const isExtends2 = extendsContext.isExtendsSchema(schema2)
+
+    if (isExtends1 || isExtends2) {
+      return extendsContext.equals(schema1, schema2)
+    } else {
+      return isCompiledSchemaEquals(schema1, schema2)
+    }
+  }
+  const equalsMap = new Map<string, boolean>()
+
+  function isCompiledSchemaEquals(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): boolean {
+    const id1 = getId(schema1)
+    const id2 = getId(schema2)
+
+    if (id1 === id2) {
+      return true
+    }
+    const key = `${id1}/${id2}`
+    let isEquals = equalsMap.get(key)
+
+    if (isEquals === undefined) {
+      isEquals = isObjectLikeEquals(schema1, schema2)
+      equalsMap.set(key, isEquals)
+    }
+    return isEquals
+  }
+
+  function isObjectLikeEquals(object1: object, object2: object): boolean {
+    if (Array.isArray(object1)) {
+      if (!Array.isArray(object2)) {
+        return false
+      }
+      if (object1.length !== object2.length) {
+        return false
+      }
+      for (const [i, value1Element] of object1.entries()) {
+        if (!isValueEquals(value1Element, object2[i])) {
+          return false
+        }
+      }
+    } else {
+      if (Array.isArray(object2)) {
+        return false
+      }
+      for (const key in object1) {
+        if (!(key in object2)) {
+          return false
+        }
+        const value1: unknown = Reflect.get(object1, key)
+        const value2: unknown = Reflect.get(object2, key)
+        if (!isValueEquals(value1, value2)) {
+          return false
+        }
+      }
+      for (const key in object2) {
+        if (!(key in object1)) {
+          return false
+        }
+      }
+    }
+    return true
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function isValueEquals(value1: any, value2: any): boolean {
+    if (value1 === value2) {
+      return true
+    }
+    if (value1 === null || value2 === null) {
+      return false
+    }
+    if (typeof value1 !== 'object') {
+      return false
+    }
+    if (typeof value1 !== typeof value2) {
+      return false
+    }
+    if (isCompiledSchema<E>(value1) && isCompiledSchema<E>(value2)) {
+      return isCompiledSchemaEquals(value1, value2)
+    }
+    return isObjectLikeEquals(value1, value2)
+  }
+  return isSchemaEquals
+}

package/src/json-schema-subset/checker/numeric/checker.ts

@@ -0,0 +1,50 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { ExpressionResult } from '../../expression/index.ts'
+
+import { swap, ExpressionAny } from '../../expression/index.ts'
+import { calculateFloat, calculateFloatAndInteger } from './float.ts'
+import { calculateInteger } from './integer.ts'
+
+export function calculateNumeric<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  if (isUndefinedNumber(schema1) || isUndefinedNumber(schema2)) {
+    return ExpressionAny
+  }
+  const isFloat1 = isFloat(schema1)
+  const isFloat2 = isFloat(schema2)
+
+  if (isFloat1 && isFloat2) {
+    return calculateFloat(schema1, schema2)
+  } else if (isFloat1) {
+    return calculateFloatAndInteger(schema1, schema2)
+  } else if (isFloat2) {
+    return swap(calculateFloatAndInteger(schema2, schema1))
+  } else {
+    return calculateInteger(schema1, schema2)
+  }
+}
+
+function isUndefinedNumber<E>(schema: CompiledSchema<E>): boolean {
+  const { multipleOf } = schema
+  if (multipleOf === undefined) {
+    return false
+  }
+  if (!Number.isInteger(multipleOf)) {
+    return true
+  }
+  if (multipleOf < 0) {
+    return true
+  }
+  return false
+}
+
+function isFloat<E>(schema: CompiledSchema<E>): boolean {
+  const { multipleOf } = schema
+
+  if (multipleOf !== undefined && Number.isInteger(multipleOf)) {
+    return false
+  }
+  if (schema.type === 'integer') {
+    return false
+  }
+  return true
+}

package/src/json-schema-subset/checker/numeric/float.ts

@@ -0,0 +1,121 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { ExpressionResult } from '../../expression/index.ts'
+import type { Point, Range, SplitterSide } from '../tools/index.ts'
+
+import { ExpressionEquals, ExpressionContaining, ExpressionContainedBy, ExpressionIntersection, ExpressionRejection } from '../../expression/index.ts'
+import { splitRange } from '../tools/index.ts'
+import { isPointRange, cutRange, normalizeInteger } from './integerNormalizer.ts'
+
+export function calculateFloat<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const range1 = pickRange(schema1)
+  const range2 = pickRange(schema2)
+  const { left, right, center } = splitRange(range1, range2)
+
+  if (!center) {
+    return ExpressionRejection
+  }
+  let extraLeft = false
+  let extraRight = false
+
+  if (left) {
+    if (left.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  if (right) {
+    if (right.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  if (extraLeft && extraRight) {
+    return ExpressionIntersection
+  }
+  if (extraLeft) {
+    return ExpressionContaining
+  }
+  if (extraRight) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function calculateFloatAndInteger<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const floatRange = pickRange(schema1)
+  const integer = normalizeInteger(schema2)
+
+  if (!integer) {
+    return ExpressionContaining
+  }
+  const result = splitRange(floatRange, integer.range)
+  const intCenter = cutRange(result.center, integer.multipleOf)
+  const leftIntRange = unwrapAndCutRange(result.left, integer.multipleOf)
+  const rightIntRange = unwrapAndCutRange(result.right, integer.multipleOf)
+
+  if (!result.center) {
+    return ExpressionRejection
+  }
+  let extraFloat = false
+  let extraInteger = false
+
+  if (result.left?.fromLeft) {
+    extraFloat = true
+  }
+  if (result.right?.fromLeft) {
+    extraFloat = true
+  }
+  if (!intCenter || !isPointRange(result.center)) {
+    extraFloat = true
+  }
+  if (leftIntRange) {
+    extraInteger = true
+  }
+  if (rightIntRange) {
+    extraInteger = true
+  }
+  if (extraFloat && extraInteger) {
+    return ExpressionIntersection
+  }
+  if (extraFloat) {
+    return ExpressionContaining
+  }
+  if (extraInteger) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function pickRange<E>(schema: CompiledSchema<E>): Range {
+  let point1: Point
+  let point2: Point
+
+  if (schema.exclusiveMinimum !== undefined) {
+    point1 = { num: schema.exclusiveMinimum, exclusive: true }
+  } else if (schema.minimum !== undefined) {
+    point1 = { num: schema.minimum, exclusive: false }
+  } else {
+    point1 = { num: Number.NEGATIVE_INFINITY, exclusive: true }
+  }
+  if (schema.exclusiveMaximum !== undefined) {
+    point2 = { num: schema.exclusiveMaximum, exclusive: true }
+  } else if (schema.maximum !== undefined) {
+    point2 = { num: schema.maximum, exclusive: false }
+  } else {
+    point2 = { num: Number.POSITIVE_INFINITY, exclusive: true }
+  }
+  return [point1, point2]
+}
+
+function unwrapAndCutRange(side: SplitterSide | undefined, multipleOf: number): Range | undefined {
+  if (!side) {
+    return undefined
+  }
+  if (side.fromLeft) {
+    // left is always float in this file
+    return undefined
+  }
+  return cutRange(side.range, multipleOf)
+}

package/src/json-schema-subset/checker/numeric/index.ts

@@ -0,0 +1 @@
+export { calculateNumeric } from './checker.ts'

package/src/json-schema-subset/checker/numeric/integer.ts

@@ -0,0 +1,119 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { ExpressionResult } from '../../expression/index.ts'
+import type { Range } from '../tools/index.ts'
+import type { Integer } from './integerNormalizer.ts'
+
+import { ExpressionEquals, ExpressionContaining, ExpressionContainedBy, ExpressionIntersection, ExpressionRejection } from '../../expression/index.ts'
+import { splitRange } from '../tools/index.ts'
+import { cutRange, normalizeInteger } from './integerNormalizer.ts'
+
+export function calculateInteger<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const integer1 = normalizeInteger(schema1)
+  const integer2 = normalizeInteger(schema2)
+
+  if (!integer1 && !integer2) {
+    return ExpressionEquals
+  }
+  if (!integer1) {
+    return ExpressionContainedBy
+  }
+  if (!integer2) {
+    return ExpressionContaining
+  }
+  const { range: range1, multipleOf: multipleOf1 } = integer1
+  const { range: range2, multipleOf: multipleOf2 } = integer2
+  const result = splitRange(range1, range2)
+
+  let centerRange: Range | undefined
+  let lcm = 0
+
+  if (result.center) {
+    lcm = getLCM(multipleOf1, multipleOf2)
+    centerRange = cutRange(result.center, lcm)
+  }
+  if (!centerRange) {
+    return ExpressionRejection
+  }
+  let extraLeft = false
+  let extraRight = false
+
+  const { left, right } = result
+
+  if (left && cutRange(left.range, left.fromLeft ? multipleOf1 : multipleOf2)) {
+    if (left.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  if (right && cutRange(right.range, right.fromLeft ? multipleOf1 : multipleOf2)) {
+    if (right.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  extraLeft = extraLeft || hasExtraIntegersOnCenter(integer1, centerRange, lcm)
+  extraRight = extraRight || hasExtraIntegersOnCenter(integer2, centerRange, lcm)
+
+  if (extraLeft && extraRight) {
+    return ExpressionIntersection
+  }
+  if (extraLeft) {
+    return ExpressionContaining
+  }
+  if (extraRight) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+function hasExtraIntegersOnCenter({ range, multipleOf }: Integer, lcmCenterRange: Range, lcm: number): boolean {
+  const result = splitRange(range, lcmCenterRange)
+
+  if (cutRange(result.left?.range, multipleOf)) {
+    return true
+  }
+  if (cutRange(result.right?.range, multipleOf)) {
+    return true
+  }
+  const center = cutRange(result.center, multipleOf)
+
+  if (!center) {
+    return false
+  }
+  const lcmCenterLength = rangeLength(lcmCenterRange)
+
+  if (rangeLength(center) > lcmCenterLength) {
+    return true
+  }
+  if (lcmCenterLength === 1) {
+    return false
+  }
+  if (multipleOf < lcm) {
+    return true
+  }
+  return false
+}
+
+/** Returns the least common multiple. */
+function getLCM(a: number, b: number): number {
+  return (a * b) / getGCD(a, b)
+}
+
+/** @returns The greatest common divisor. */
+function getGCD(a: number, b: number): number {
+  if (a === 0) {
+    return b
+  }
+  return getGCD(b % a, a)
+}
+
+function rangeLength(range?: Range): number {
+  if (!range) {
+    return 0
+  }
+  const [point1, point2] = range
+  // Both endpoints are inclusive, so the range length includes one extra value.
+  return point2.num - point1.num + 1
+}

package/src/json-schema-subset/checker/numeric/integerNormalizer.ts

@@ -0,0 +1,72 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { Range } from '../tools/index.ts'
+
+import { pickRange } from './float.ts'
+
+export type Integer = {
+  readonly multipleOf: number
+  readonly range: Range
+}
+
+export function normalizeInteger<E>(schema: CompiledSchema<E>): Integer | null {
+  const floatRange = pickRange(schema)
+  const multipleOf = schema.multipleOf ?? 1
+  const range = cutRange(floatRange, multipleOf)
+
+  if (!range) {
+    return null
+  }
+  return { multipleOf, range }
+}
+
+export function isPointRange([point1, point2]: Range): boolean {
+  if (point1.num !== point2.num) {
+    return false
+  }
+  if (point1.exclusive) {
+    return false
+  }
+  if (point2.exclusive) {
+    return false
+  }
+  return true
+}
+
+export function cutRange(range: Range | undefined, multipleOf: number): Range | undefined {
+  if (!range) {
+    return undefined
+  }
+  const [originMin, originMax] = range
+  let min = nextInteger(originMin.num, multipleOf)
+  let max = previousInteger(originMax.num, multipleOf)
+
+  if (min === originMin.num && originMin.exclusive) {
+    min += multipleOf
+  }
+  if (max === originMax.num && originMax.exclusive) {
+    max -= multipleOf
+  }
+  if (min > max) {
+    return undefined
+  }
+  if (min === max) {
+    if (min === Number.POSITIVE_INFINITY) {
+      return undefined
+    }
+    if (min === Number.NEGATIVE_INFINITY) {
+      return undefined
+    }
+  }
+  return [
+    { num: min, exclusive: false },
+    { num: max, exclusive: false },
+  ]
+}
+
+function nextInteger(float: number, multipleOf: number): number {
+  return Math.ceil(float / multipleOf) * multipleOf
+}
+
+function previousInteger(float: number, multipleOf: number): number {
+  return Math.floor(float / multipleOf) * multipleOf
+}