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

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
+}

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

@@ -0,0 +1,354 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Schema } from '../types.ts'
+import type { Context } from './cache.ts'
+import type { QuantumVariableType } from './tools/index.ts'
+
+import { getKind, ANY, NEVER, CompiledKind } from '../compiler/index.ts'
+import {
+  ExpressionNone,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionIntersection,
+  ExpressionRejection,
+  ExpressionSingleResult,
+} from '../expression/index.ts'
+import { createRangeSplitter, toExpressionSingleResult } from './range.ts'
+import { makeQuantum } from './tools/index.ts'
+import { ValidResult, valid } from './validator.ts'
+
+const splitRange = createRangeSplitter(0)
+const quantum = makeQuantum(['hasCommonInRequired', 'hasCommonOutRequired', 'hasExtra1', 'hasExtra2', 'hasRejection'])
+
+// TODO: Handle object schemas introduced by the unsupported dependencies keyword.
+export function calculateObject<E>(context: Context<E>, schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  if (isPropertiesCountCannotMatch(schema1, schema2)) {
+    return ExpressionRejection
+  }
+  const splitRequiredResult = splitRequired(schema1, schema2)
+
+  if (!splitRequiredResult) {
+    return ExpressionRejection
+  }
+  const getProperty1 = createPropertySchemaGetter(schema1)
+  const getProperty2 = createPropertySchemaGetter(schema2)
+  const calculateKey = (key: string): ExpressionResult => {
+    const propertySchema1 = getProperty1(key)
+    const propertySchema2 = getProperty2(key)
+
+    if (areNotBothNever(propertySchema1, propertySchema2)) {
+      return context.calculate(propertySchema1, propertySchema2)
+    } else {
+      return ExpressionNone
+    }
+  }
+  const { commonRequired, extraRequired1, extraRequired2 } = splitRequiredResult
+  const quantumVariable = quantum.variable({})
+
+  for (const requiredKey of [...commonRequired].toSorted()) {
+    quantumVariable.push(calculateKey(requiredKey), calculateCommonRequiredExpression)
+  }
+  for (const requiredKey of [...extraRequired1].toSorted()) {
+    quantumVariable.push(calculateKey(requiredKey), calculateExtraRequiredExpression1)
+  }
+  for (const requiredKey of [...extraRequired2].toSorted()) {
+    quantumVariable.push(calculateKey(requiredKey), calculateExtraRequiredExpression2)
+  }
+  const { hasOptional1, hasOptional2 } = splitRequiredResult
+
+  if (hasOptional1 || hasOptional2) {
+    const calculator = calculateOptionalExpression(hasOptional1, hasOptional2)
+
+    for (const optionalKey of [...getOptionalKeys(schema1, schema2)].toSorted()) {
+      const expression = calculateKey(optionalKey)
+      if (expression !== ExpressionNone) {
+        quantumVariable.push(expression, calculator)
+      }
+    }
+    const additionalProperties1 = (schema1.additionalProperties as Schema<E>) ?? ANY
+    const additionalProperties2 = (schema2.additionalProperties as Schema<E>) ?? ANY
+
+    if (areNotBothNever(additionalProperties1, additionalProperties2)) {
+      const expression = context.calculate(additionalProperties1, additionalProperties2)
+      quantumVariable.push(expression, calculator)
+    }
+  }
+  quantumVariable.update((variable) => {
+    if (!variable.hasRejection) {
+      // Fewer required properties leave more possibilities outside the common set.
+      if (extraRequired1.size > 0) {
+        variable.hasExtra2 = true
+      }
+      if (extraRequired2.size > 0) {
+        variable.hasExtra1 = true
+      }
+    }
+  })
+  const { requiredKeysCount } = splitRequiredResult
+  let expression = ExpressionNone
+
+  for (const { hasExtra1, hasExtra2, hasCommonInRequired, hasCommonOutRequired, hasRejection } of quantumVariable) {
+    if (!hasCommonInRequired && requiredKeysCount > 0) {
+      expression |= ExpressionRejection
+    } else if (!hasCommonOutRequired && requiredKeysCount === 0) {
+      expression |= ExpressionRejection
+    } else if (hasRejection) {
+      expression |= ExpressionRejection
+    } else if (hasExtra1 && hasExtra2) {
+      expression |= ExpressionIntersection
+    } else if (hasExtra1) {
+      expression |= ExpressionContaining
+    } else if (hasExtra2) {
+      expression |= ExpressionContainedBy
+    } else {
+      expression |= ExpressionEquals
+    }
+  }
+  return expression
+}
+
+function isPropertiesCountCannotMatch<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): boolean {
+  const splitResult = splitRange(schema1.minProperties, schema1.maxProperties, schema2.minProperties, schema2.maxProperties)
+  const splitExpression = toExpressionSingleResult(splitResult)
+
+  return splitExpression === ExpressionSingleResult.Rejection
+}
+
+type SplitRequiredResult = {
+  readonly requiredKeysCount: number
+  readonly commonRequired: Set<string>
+  readonly extraRequired1: Set<string>
+  readonly extraRequired2: Set<string>
+  readonly hasOptional1: boolean
+  readonly hasOptional2: boolean
+}
+
+function splitRequired<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): SplitRequiredResult | null {
+  const extraRequired1 = new Set<string>(schema1.required)
+  const extraRequired2 = new Set<string>(schema2.required)
+  const commonRequired = new Set<string>()
+  const wholeRequired = new Set<string>()
+
+  const requiredCount1 = extraRequired1.size
+  const requiredCount2 = extraRequired2.size
+
+  for (const key of extraRequired1) {
+    if (extraRequired2.has(key)) {
+      commonRequired.add(key)
+    }
+    wholeRequired.add(key)
+  }
+  for (const key of extraRequired2) {
+    if (extraRequired1.has(key)) {
+      commonRequired.add(key)
+    }
+    wholeRequired.add(key)
+  }
+  const requiredKeysCount = wholeRequired.size
+
+  for (const key of commonRequired) {
+    extraRequired1.delete(key)
+    extraRequired2.delete(key)
+  }
+  const maxProperties1 = schema1.maxProperties ?? Number.MAX_SAFE_INTEGER
+  const maxProperties2 = schema2.maxProperties ?? Number.MAX_SAFE_INTEGER
+
+  if (requiredKeysCount > maxProperties1 || requiredKeysCount > maxProperties2) {
+    return null
+  }
+  return {
+    requiredKeysCount,
+    extraRequired1,
+    extraRequired2,
+    commonRequired,
+    hasOptional1: maxProperties1 > requiredCount1,
+    hasOptional2: maxProperties2 > requiredCount2,
+  }
+}
+
+function getOptionalKeys<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): Set<string> {
+  const optionalKeys = new Set<string>(schema1.required)
+  const properties1 = schema1.properties
+  const properties2 = schema2.properties
+  const required1 = schema1.required
+  const required2 = schema2.required
+
+  if (properties1) {
+    for (const key in properties1) {
+      optionalKeys.add(key)
+    }
+  }
+  if (properties2) {
+    for (const key in properties2) {
+      optionalKeys.add(key)
+    }
+  }
+  if (required1) {
+    for (const key of required1) {
+      optionalKeys.delete(key)
+    }
+  }
+  if (required2) {
+    for (const key of required2) {
+      optionalKeys.delete(key)
+    }
+  }
+  return optionalKeys
+}
+
+const calculateCommonRequiredExpression = (singleExpression: ExpressionSingleResult, variable: QuantumVariableType<typeof quantum>): void => {
+  switch (singleExpression) {
+    case ExpressionSingleResult.Equals: {
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      variable.hasExtra1 = true
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      variable.hasExtra2 = true
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      variable.hasExtra1 = true
+      variable.hasExtra2 = true
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      variable.hasRejection = true
+      break
+    }
+  }
+}
+
+const calculateExtraRequiredExpression1 = (singleExpression: ExpressionSingleResult, variable: QuantumVariableType<typeof quantum>): void => {
+  switch (singleExpression) {
+    case ExpressionSingleResult.Equals:
+    case ExpressionSingleResult.ContainedBy: {
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Intersection:
+    case ExpressionSingleResult.Containing: {
+      variable.hasExtra1 = true
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      variable.hasRejection = true
+      break
+    }
+  }
+}
+
+const calculateExtraRequiredExpression2 = (singleExpression: ExpressionSingleResult, variable: QuantumVariableType<typeof quantum>): void => {
+  switch (singleExpression) {
+    case ExpressionSingleResult.Equals:
+    case ExpressionSingleResult.Containing: {
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Intersection:
+    case ExpressionSingleResult.ContainedBy: {
+      variable.hasExtra2 = true
+      variable.hasCommonInRequired = true
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      variable.hasRejection = true
+      break
+    }
+  }
+}
+
+const calculateOptionalExpression =
+  (hasOptional1: boolean, hasOptional2: boolean) =>
+  (singleExpression: ExpressionSingleResult, variable: QuantumVariableType<typeof quantum>): void => {
+    if (variable.hasRejection) {
+      return
+    }
+    let foundExtraPossibility1 = false
+    let foundExtraPossibility2 = false
+    let foundCommonPossibility = false
+
+    switch (singleExpression) {
+      case ExpressionSingleResult.Equals: {
+        foundCommonPossibility = true
+        break
+      }
+      case ExpressionSingleResult.Containing: {
+        foundExtraPossibility1 = true
+        foundCommonPossibility = true
+        break
+      }
+      case ExpressionSingleResult.ContainedBy: {
+        foundExtraPossibility2 = true
+        foundCommonPossibility = true
+        break
+      }
+      case ExpressionSingleResult.Intersection: {
+        foundExtraPossibility1 = true
+        foundExtraPossibility2 = true
+        foundCommonPossibility = true
+        break
+      }
+      case ExpressionSingleResult.Rejection: {
+        foundExtraPossibility1 = true
+        foundExtraPossibility2 = true
+        break
+      }
+    }
+    if (hasOptional1 && foundExtraPossibility1) {
+      variable.hasExtra1 = true
+    }
+    if (hasOptional2 && foundExtraPossibility2) {
+      variable.hasExtra2 = true
+    }
+    if (hasOptional1 && hasOptional2 && foundCommonPossibility) {
+      variable.hasCommonOutRequired = true
+    }
+  }
+
+type PropertySchemaGetter<E> = (key: string) => Schema<E>
+
+function createPropertySchemaGetter<E>(schema: CompiledSchema<E>): PropertySchemaGetter<E> {
+  const properties = schema.properties as Readonly<{ [key: string]: CompiledSchema<E> }> | undefined
+  const propertyNames = schema.propertyNames as CompiledSchema<E> | undefined
+  const additionalProperties = schema.additionalProperties as Schema<E> | undefined
+  const patternProperties: { pattern: RegExp; schema: Schema<E> }[] = []
+
+  if (schema.patternProperties) {
+    for (const pattern in schema.patternProperties) {
+      const valueSchema = schema.patternProperties[pattern] as Schema<E>
+      const regExp = new RegExp(pattern, 'i')
+      patternProperties.push({ pattern: regExp, schema: valueSchema })
+    }
+  }
+  return (key) => {
+    if (propertyNames && valid(propertyNames, key) === ValidResult.Invalid) {
+      return NEVER
+    }
+    for (const { pattern, schema: patternSchema } of patternProperties) {
+      if (pattern.test(key)) {
+        return patternSchema
+      }
+    }
+    const propertySchema = (properties && properties[key]) ?? additionalProperties
+
+    if (!propertySchema) {
+      return ANY
+    }
+    return propertySchema
+  }
+}
+
+function areNotBothNever<E>(schema1: Schema<E>, schema2: Schema<E>): boolean {
+  const kind1 = getKind(schema1)
+  const kind2 = getKind(schema2)
+  return kind1 !== CompiledKind.Never || kind2 !== CompiledKind.Never
+}

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

@@ -0,0 +1,91 @@
+import { ExpressionSingleResult } from '../expression/index.ts'
+import { splitRange } from './tools/index.ts'
+
+export type RangeSplitter = (min1?: number, max1?: number, min2?: number, max2?: number) => RangeSplitResult
+export type RangeSplitResult = {
+  readonly left?: RangeItem & { readonly isFrom1: boolean }
+  readonly right?: RangeItem & { readonly isFrom1: boolean }
+  readonly intersection?: RangeItem
+}
+
+export type RangeItem = {
+  readonly min: number
+  readonly max: number
+}
+
+export const createRangeSplitter =
+  (undefinedMin: number): RangeSplitter =>
+  (min1 = undefinedMin, max1 = Number.POSITIVE_INFINITY, min2 = undefinedMin, max2 = Number.POSITIVE_INFINITY) => {
+    const { left, center, right } = splitRange(
+      [
+        { num: min1, exclusive: false },
+        { num: max1, exclusive: false },
+      ],
+      [
+        { num: min2, exclusive: false },
+        { num: max2, exclusive: false },
+      ],
+    )
+    let leftItem: RangeSplitResult['left']
+    let rightItem: RangeSplitResult['right']
+    let intersectionItem: RangeSplitResult['intersection']
+
+    if (left) {
+      leftItem = {
+        min: left.range[0].num,
+        max: left.range[1].num,
+        isFrom1: left.fromLeft,
+      }
+    }
+    if (right) {
+      rightItem = {
+        min: right.range[0].num,
+        max: right.range[1].num,
+        isFrom1: right.fromLeft,
+      }
+    }
+    if (center) {
+      intersectionItem = {
+        min: center[0].num,
+        max: center[1].num,
+      }
+    }
+    return {
+      left: leftItem,
+      right: rightItem,
+      intersection: intersectionItem,
+    }
+  }
+
+export function toExpressionSingleResult({ left, right, intersection }: RangeSplitResult): ExpressionSingleResult {
+  if (!intersection) {
+    return ExpressionSingleResult.Rejection
+  }
+  let extra1 = false
+  let extra2 = false
+
+  if (left) {
+    if (left.isFrom1) {
+      extra1 = true
+    } else {
+      extra2 = true
+    }
+  }
+  if (right) {
+    if (right.isFrom1) {
+      extra1 = true
+    } else {
+      extra2 = true
+    }
+  }
+  if (extra1 && extra2) {
+    return ExpressionSingleResult.Intersection
+  }
+  if (extra1) {
+    return ExpressionSingleResult.Containing
+  }
+  if (extra2) {
+    return ExpressionSingleResult.ContainedBy
+  }
+  return ExpressionSingleResult.Equals
+}

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

@@ -0,0 +1,60 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+
+import {
+  ExpressionAny,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionIntersection,
+  ExpressionRejection,
+  ExpressionSingleResult,
+} from '../expression/index.ts'
+import { createRangeSplitter, toExpressionSingleResult } from './range.ts'
+
+const splitRange = createRangeSplitter(0)
+
+export function calculateString<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  if (schema2.format && !schema1.format) return ExpressionContaining
+  if (schema1.format && schema2.format && schema1.format !== schema2.format) return ExpressionAny
+  const splitResult = splitRange(schema1.minLength, schema1.maxLength, schema2.minLength, schema2.maxLength)
+  const expression = toExpressionSingleResult(splitResult)
+  const hasPattern1 = !!schema1.pattern
+  const hasPattern2 = !!schema2.pattern
+
+  switch (expression) {
+    case ExpressionSingleResult.Rejection: {
+      return ExpressionRejection
+    }
+    case ExpressionSingleResult.Containing: {
+      return hasPattern1 ? ExpressionAny : ExpressionContaining
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      return hasPattern2 ? ExpressionAny : ExpressionContainedBy
+    }
+    case ExpressionSingleResult.Equals: {
+      if (hasPattern1 && hasPattern2) {
+        return schema1.pattern === schema2.pattern ? ExpressionEquals : ExpressionAny
+      }
+      if (hasPattern1) {
+        return ExpressionEquals | ExpressionContainedBy
+      }
+      if (hasPattern2) {
+        return ExpressionEquals | ExpressionContaining
+      }
+      return ExpressionEquals
+    }
+    case ExpressionSingleResult.Intersection: {
+      if (hasPattern1 && hasPattern2) {
+        return ExpressionAny
+      }
+      if (hasPattern1) {
+        return ExpressionIntersection | ExpressionRejection | ExpressionContainedBy
+      }
+      if (hasPattern2) {
+        return ExpressionIntersection | ExpressionRejection | ExpressionContaining
+      }
+      return ExpressionIntersection
+    }
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './mark.ts'
+export * from './quantum.ts'
+export * from './range.ts'