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

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'

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

@@ -0,0 +1,82 @@
+export type VariableBundle<K extends string> = {
+  [P in K]: boolean
+} & {
+  toInt32(): number
+  toString(): string
+}
+
+export class VariableBundleDescription<K extends string> {
+  public readonly keys: readonly K[]
+  private readonly clazz: { new (int32: number): VariableBundleImpls<K> }
+
+  public constructor(_keys: readonly K[]) {
+    const keys = Object.freeze(_keys.toSorted())
+    if (keys.length > 32) {
+      throw new Error(`cannot define ${keys.length} keys which is greater than 32`)
+    }
+    this.keys = keys
+    this.clazz = class extends VariableBundleImpls<K> {
+      public constructor(int32: number) {
+        super(keys, int32)
+      }
+    }
+    for (const [i, key] of this.keys.entries()) {
+      const mask = 1 << i
+
+      Object.defineProperty(this.clazz.prototype, key, {
+        enumerable: true,
+        get: function get(this: VariableBundleImpls<K>): boolean {
+          return !!(this.int32 & mask)
+        },
+        set: function set(this: VariableBundleImpls<K>, value: boolean): void {
+          if (value) {
+            this.int32 |= mask
+          } else {
+            this.int32 &= ~mask
+          }
+        },
+      })
+    }
+  }
+
+  public toBundle(): VariableBundle<K>
+  public toBundle(int32: number): VariableBundle<K>
+  public toBundle(variable: Partial<Record<K, boolean>>): VariableBundle<K>
+
+  public toBundle(variable?: number | Partial<Record<K, boolean>>): VariableBundle<K> {
+    let int32 = 0
+
+    if (typeof variable === 'number') {
+      int32 = variable
+    } else if (variable) {
+      for (const [i, key] of this.keys.entries()) {
+        if (variable[key]) {
+          int32 |= 1 << i
+        }
+      }
+    }
+    return new this.clazz(int32) as VariableBundle<K>
+  }
+}
+
+class VariableBundleImpls<K extends string> {
+  private readonly keys: readonly K[]
+  protected int32: number
+
+  public constructor(keys: readonly K[], int32: number) {
+    this.keys = keys
+    this.int32 = int32
+  }
+
+  public toInt32(): number {
+    return this.int32
+  }
+
+  public toString(): string {
+    const object: Record<string, boolean> = {}
+    for (const key of this.keys) {
+      object[key] = (this as unknown as Record<string, boolean>)[key]
+    }
+    return JSON.stringify(object)
+  }
+}

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

@@ -0,0 +1,106 @@
+import type { ExpressionResult, ExpressionSingleResult } from '../../expression/index.ts'
+import type { VariableBundle } from './mark.ts'
+
+import { ExpressionMaskList } from '../../expression/index.ts'
+import { VariableBundleDescription } from './mark.ts'
+
+export interface Quantum<K extends string> {
+  readonly keys: readonly K[]
+  variable(variable?: Partial<Record<K, boolean>>): QuantumVariable<K>
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type QuantumVariableType<Q extends Quantum<any>> = VariableBundle<Q['keys'][0]>
+
+export interface QuantumVariable<K extends string> extends Iterable<VariableBundle<K>> {
+  assign(other: QuantumVariable<K>): this
+  push(expression: ExpressionResult, calculate: QuantumCalculator<K>): void
+  update(invoker: (variable: VariableBundle<K>) => void): void
+}
+
+export type QuantumCalculator<K extends string> = (singleExpression: ExpressionSingleResult, variable: VariableBundle<K>) => void
+
+export function makeQuantum<K extends string>(keys: readonly K[]): Quantum<K> {
+  return new QuantumImpls(keys)
+}
+
+class QuantumImpls<K extends string> {
+  private readonly description: VariableBundleDescription<K>
+
+  public constructor(keys: readonly K[]) {
+    this.description = new VariableBundleDescription(keys)
+  }
+
+  public get keys(): readonly K[] {
+    return this.description.keys
+  }
+
+  public variable(variable?: Partial<Record<K, boolean>>): QuantumVariable<K> {
+    let int32: number | undefined
+    if (variable) {
+      int32 = this.description.toBundle(variable).toInt32()
+    }
+    return new QuantumVariableImpls(this.description, int32)
+  }
+}
+
+class QuantumVariableImpls<K extends string> implements QuantumVariable<K> {
+  private readonly description: VariableBundleDescription<K>
+  private values: Set<number> = new Set()
+
+  public constructor(description: VariableBundleDescription<K>, int32?: number) {
+    this.description = description
+    if (int32 !== undefined) {
+      this.values.add(int32)
+    }
+  }
+
+  public [Symbol.iterator](): Iterator<VariableBundle<K>> {
+    const iterator = this.values[Symbol.iterator]()
+    return {
+      next: (): IteratorResult<VariableBundle<K>> => {
+        const result = iterator.next()
+        if (result.done) {
+          return result
+        } else {
+          return {
+            done: false,
+            value: this.description.toBundle(result.value),
+          }
+        }
+      },
+    }
+  }
+
+  public assign(other: QuantumVariable<K>): this {
+    const { values } = other as QuantumVariableImpls<K>
+    for (const int32 of values) {
+      this.values.add(int32)
+    }
+    return this
+  }
+
+  public push(expression: ExpressionResult, calculate: QuantumCalculator<K>): void {
+    const nextValues = new Set<number>()
+    for (const int32 of this.values) {
+      for (const [singleExpression, mask] of ExpressionMaskList) {
+        if (expression & mask) {
+          const variable = this.description.toBundle(int32)
+          calculate(singleExpression, variable)
+          nextValues.add(variable.toInt32())
+        }
+      }
+    }
+    this.values = nextValues
+  }
+
+  public update(invoker: (variable: VariableBundle<K>) => void): void {
+    const nextValues = new Set<number>()
+    for (const int32 of this.values) {
+      const variable = this.description.toBundle(int32)
+      invoker(variable)
+      nextValues.add(variable.toInt32())
+    }
+    this.values = nextValues
+  }
+}