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

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

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

@@ -0,0 +1,210 @@
+export type Range = readonly [Point, Point]
+export type Point = {
+  readonly num: number
+  readonly exclusive: boolean
+}
+
+export type Splitter = {
+  readonly left?: SplitterSide
+  readonly right?: SplitterSide
+  readonly center?: Range
+}
+
+export type SplitterSide = {
+  readonly fromLeft: boolean
+  readonly range: Range
+}
+
+export function splitRange(range1: Range, range2: Range): Splitter {
+  const [min1] = range1
+  const [min2] = range2
+
+  if (min1.num < min2.num) {
+    return splitRangeLessBranch(range1, range2)
+  } else if (min1.num > min2.num) {
+    return splitRangeGreaterBranch(range1, range2)
+  } else {
+    return splitRangeEqualsBranch(range1, range2)
+  }
+}
+
+function splitRangeLessBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+
+  if (max1.num <= min2.num) {
+    const exclusive1 = max1.exclusive
+    const exclusive2 = min2.exclusive
+    if (max1.num < min2.num || exclusive1 || exclusive2) {
+      return {
+        left: { fromLeft: true, range: range1 },
+        right: { fromLeft: false, range: range2 },
+      }
+    }
+  }
+  if (max1.num <= max2.num) {
+    let hasRight = true
+    let isLeftRangeOverride = false
+
+    if (max1.num === max2.num) {
+      const exclusive1 = max1.exclusive
+      const exclusive2 = max2.exclusive
+      hasRight = exclusive1 !== exclusive2
+      isLeftRangeOverride = !exclusive1 && exclusive2
+    }
+    if (!isLeftRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: false,
+          range: [reversalExclusive(max1), max2],
+        }
+      }
+      return {
+        left: {
+          fromLeft: true,
+          range: [min1, reversalExclusive(min2)],
+        },
+        center: [min2, max1],
+        right,
+      }
+    }
+  }
+  // if (max1.num > max2.num || (max1.num === max2.num && max1.exclusive === false && max2.exclusive === true))
+  {
+    return {
+      left: {
+        fromLeft: true,
+        range: [min1, reversalExclusive(min2)],
+      },
+      center: [min2, max2],
+      right: {
+        fromLeft: true,
+        range: [reversalExclusive(max2), max1],
+      },
+    }
+  }
+}
+
+function splitRangeGreaterBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+
+  if (min1.num >= max2.num) {
+    const exclusive1 = max2.exclusive
+    const exclusive2 = min1.exclusive
+    if (min1.num > max2.num || exclusive1 || exclusive2) {
+      return {
+        left: { fromLeft: false, range: range2 },
+        right: { fromLeft: true, range: range1 },
+      }
+    }
+  }
+  if (max2.num <= max1.num) {
+    let hasRight = true
+    let isRightRangeOverride = false
+
+    if (max1.num === max2.num) {
+      const exclusive1 = max2.exclusive
+      const exclusive2 = max1.exclusive
+      hasRight = exclusive1 !== exclusive2
+      isRightRangeOverride = !exclusive1 && exclusive2
+    }
+    if (!isRightRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: true,
+          range: [reversalExclusive(max2), max1],
+        }
+      }
+      return {
+        left: {
+          fromLeft: false,
+          range: [min2, reversalExclusive(min1)],
+        },
+        center: [min1, max2],
+        right,
+      }
+    }
+  }
+  // if (max2.num > max1.num || (max2.num === max1.num && max2.exclusive === false && max1.exclusive === true))
+  {
+    return {
+      left: {
+        fromLeft: false,
+        range: [min2, reversalExclusive(min1)],
+      },
+      center: [min1, max1],
+      right: {
+        fromLeft: false,
+        range: [reversalExclusive(max1), max2],
+      },
+    }
+  }
+}
+
+function splitRangeEqualsBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+  const exclusive1 = min1.exclusive
+  const exclusive2 = min2.exclusive
+
+  let left: SplitterSide | undefined
+  let centerBegin = min1
+
+  if (!exclusive1 && exclusive2) {
+    centerBegin = min2
+    left = {
+      fromLeft: true,
+      range: [min1, reversalExclusive(min2)],
+    }
+  } else if (exclusive1 && !exclusive2) {
+    left = {
+      fromLeft: false,
+      range: [min2, reversalExclusive(min1)],
+    }
+  }
+  if (max1.num <= max2.num) {
+    let hasRight = true
+    let isLeftRangeOverride = false
+    if (max1.num === max2.num) {
+      const maxExclusive1 = max1.exclusive
+      const maxExclusive2 = max2.exclusive
+      hasRight = maxExclusive1 !== maxExclusive2
+      isLeftRangeOverride = !maxExclusive1 && maxExclusive2
+    }
+    if (!isLeftRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: false,
+          range: [reversalExclusive(max1), max2],
+        }
+      }
+      return {
+        left,
+        center: [centerBegin, max1],
+        right,
+      }
+    }
+  }
+  // if (max1.num > max2.num || (max1.num === max2.num && max1.exclusive === false && max2.exclusive === true))
+  {
+    return {
+      left,
+      center: [centerBegin, max2],
+      right: {
+        fromLeft: true,
+        range: [reversalExclusive(max2), max1],
+      },
+    }
+  }
+}
+
+function reversalExclusive(point: Point): Point {
+  return {
+    num: point.num,
+    exclusive: !point.exclusive,
+  }
+}

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

@@ -0,0 +1,23 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+
+export const ValidResult = Object.freeze({
+  Valid: 0,
+  Invalid: 1,
+  Unknown: 2,
+})
+
+export type ValidResult = (typeof ValidResult)[keyof typeof ValidResult]
+
+export function valid<E>(compiledSchema: CompiledSchema<E>, value: unknown): ValidResult {
+  const isValid = compiledSchema.isValid
+  if (isValid) {
+    const result = isValid(value)
+    if (result === true) {
+      return ValidResult.Valid
+    } else {
+      return ValidResult.Invalid
+    }
+  } else {
+    return ValidResult.Unknown
+  }
+}

package/src/json-schema-subset/compiler/array.ts

@@ -0,0 +1,163 @@
+import type { JSONSchema7, JSONSchema7Definition } from 'json-schema'
+import type { JSONDelegate } from '../types.ts'
+import type { Schema } from '../types.ts'
+import type { Context } from './common.ts'
+import type { InputSchema } from './compiler.ts'
+import type { CompiledSchema } from './wrapper.ts'
+
+import { joinPath, recordWarn, unwrapJSONSchema7Definition } from './common.ts'
+import { compileSchema } from './compiler.ts'
+import { cleanEmptyValues } from './utils.ts'
+import { wrapCompiledSchema, CompiledKind, getKind, toNever, isCompiledSchema } from './wrapper.ts'
+
+export function compileArraySchema<E>(context: Context<E>, schema: InputSchema): CompiledSchema<E> | null {
+  let items = compileItems(context, schema)
+  let maxItems = getItemsLimit(context, 'maxItems', schema)
+  const minItems = getItemsLimit(context, 'minItems', schema)
+  const contains = compileContains(context, schema)
+  const uniqueItems = schema.uniqueItems
+
+  // Undefined means no value is required, while null represents a compilation error.
+  let additionalItems: Schema<E> | false | null | undefined
+
+  if (Array.isArray(items)) {
+    additionalItems = compileAdditionalItems(context, schema)
+  } else if (schema.additionalItems) {
+    // Additional items are ignored when items is not an array.
+    // See https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4.2.
+    recordWarn(context, 'it is needless when items is not array', 'additionalItems')
+  }
+  if (!items || !contains || additionalItems === null) {
+    return null
+  }
+  let isNever = false
+  let updateMaxItems = false
+
+  if (Array.isArray(items)) {
+    if (maxItems !== undefined && maxItems <= items.length) {
+      items = items.splice(maxItems)
+      additionalItems = variableToNever(additionalItems, context.delegate)
+    }
+    const firstNeverItemIndex = items.findIndex((item) => getKind(item) === CompiledKind.Never)
+
+    if (firstNeverItemIndex !== -1) {
+      items = items.splice(firstNeverItemIndex)
+      additionalItems = variableToNever(additionalItems, context.delegate)
+      if (maxItems === undefined) {
+        maxItems = items.length
+        updateMaxItems = true
+      }
+    }
+    if (minItems !== undefined && items.length < minItems) {
+      recordWarn(context, `length(${items.length}) of items if less than minItems(${minItems})`)
+      isNever = true
+    }
+    if (items.length === 0 && additionalItems && getKind(additionalItems) === CompiledKind.Never) {
+      isNever = true
+    }
+  } else if (getKind(items) === CompiledKind.Never) {
+    isNever = true
+  }
+  if (maxItems !== undefined && minItems !== undefined && maxItems < minItems) {
+    if (!updateMaxItems) {
+      recordWarn(context, `maxItems(${maxItems}) is less than minItems(${minItems})`)
+    }
+    isNever = true
+  }
+  const kind = isNever ? CompiledKind.Never : CompiledKind.Array
+  const mergedSchema = cleanEmptyValues({
+    type: 'array',
+    items,
+    contains,
+    uniqueItems,
+    maxItems,
+    minItems,
+    additionalItems: additionalItems!,
+  })
+  return wrapCompiledSchema(kind, mergedSchema as JSONSchema7, context.delegate, context.path)
+}
+
+function compileItems<E>(context: Context<E>, { items }: InputSchema): Schema<E> | Schema<E>[] | null {
+  if (!items) {
+    return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+  }
+  if (Array.isArray(items)) {
+    const schemas: Schema<E>[] = []
+    let hasAnyError = false
+    for (const [i, item] of items.entries()) {
+      const subContext = joinPath(context, 'items', i)
+      const schema = compileSchema(subContext, unwrapJSONSchema7Definition(item))
+      if (!schema) {
+        hasAnyError = true
+        continue
+      }
+      schemas.push(schema)
+    }
+    if (hasAnyError) {
+      return null
+    }
+    return schemas
+  } else {
+    const subContext = joinPath(context, 'items')
+    const itemsSchema = unwrapJSONSchema7Definition(items as JSONSchema7Definition)
+    const schema = compileSchema(subContext, itemsSchema)
+
+    return schema
+  }
+}
+
+function getItemsLimit<E>(context: Context<E>, name: 'maxItems' | 'minItems', schema: InputSchema): number | undefined {
+  const propertiesLimit = schema[name]
+  if (propertiesLimit === undefined) {
+    return undefined
+  }
+  if (Number.isNaN(propertiesLimit)) {
+    recordWarn(context, 'find NaN', name)
+    return undefined
+  }
+  if (propertiesLimit < 0) {
+    recordWarn(context, `find invalid number ${propertiesLimit}`, name)
+    return undefined
+  }
+  return propertiesLimit
+}
+
+function compileContains<E>(context: Context<E>, { contains }: InputSchema): Schema<E> | null {
+  if (!contains) {
+    return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+  }
+  const subContext = joinPath(context, 'contains')
+  const containsSchema = unwrapJSONSchema7Definition(contains)
+
+  return compileSchema(subContext, containsSchema)
+}
+
+function compileAdditionalItems<E>(context: Context<E>, { additionalItems }: InputSchema): Schema<E> | false | null {
+  switch (typeof additionalItems) {
+    case 'boolean': {
+      if (additionalItems) {
+        return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+      } else {
+        return false
+      }
+    }
+    case 'object': {
+      const subContext = joinPath(context, 'additionalItems')
+      const compiledSchema = compileSchema(subContext, additionalItems)
+      return compiledSchema
+    }
+    default: {
+      return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+    }
+  }
+}
+
+function variableToNever<T, E>(schema: Schema<E> | T | undefined, delegate?: JSONDelegate<E>): Schema<E> | T {
+  if (schema === undefined) {
+    return wrapCompiledSchema(CompiledKind.Never, { type: 'string', maxLength: 0, minLength: 1 }, delegate)
+  } else if (isCompiledSchema(schema)) {
+    return getKind(schema) === CompiledKind.Never ? schema : toNever(schema as CompiledSchema<E>)
+  } else {
+    return schema
+  }
+}

package/src/json-schema-subset/compiler/combination.ts

@@ -0,0 +1,109 @@
+import type { JSONSchema7Definition } from 'json-schema'
+import type { Schema } from '../types.ts'
+import type { JSONDelegate } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+import type { Context } from './common.ts'
+import type { CompiledSchema } from './wrapper.ts'
+
+import { joinPath, unwrapJSONSchema7Definition, recordError } from './common.ts'
+import { compileSchema } from './compiler.ts'
+import { getKind, CompiledKind, wrapCompiledSchema } from './wrapper.ts'
+
+export type CombinationKeys = 'allOf' | 'anyOf' | 'oneOf'
+export const COMBINATION_KEYS: readonly CombinationKeys[] = Object.freeze(['allOf', 'anyOf', 'oneOf'])
+
+export function compileCombinationSchema<E>(
+  context: Context<E>,
+  key: CombinationKeys,
+  combinationList: DeepReadonly<JSONSchema7Definition[]>,
+  delegate?: JSONDelegate<E>,
+): CompiledSchema<E> | null {
+  if (combinationList.length === 0) {
+    recordError(context, 'disable empty list', key)
+    return null
+  }
+  const compiledCombinationList: Schema<E>[] = []
+
+  for (const [i, element] of combinationList.entries()) {
+    const subContext = joinPath(context, key, i)
+    const schema = unwrapJSONSchema7Definition(element)
+    const compiledSchema = compileSchema(subContext, schema)
+    if (compiledSchema) {
+      compiledCombinationList.push(compiledSchema)
+    }
+  }
+  if (compiledCombinationList.length < combinationList.length) {
+    return null
+  }
+  let anyCount = 0
+  let neverCount = 0
+
+  for (const compiledSchema of compiledCombinationList) {
+    switch (getKind(compiledSchema)) {
+      case CompiledKind.Any: {
+        anyCount += 1
+        break
+      }
+      case CompiledKind.Never: {
+        neverCount += 1
+        break
+      }
+    }
+  }
+  let kind: CompiledKind = CompiledKind.Combination
+
+  switch (key) {
+    case 'allOf': {
+      if (neverCount > 0) {
+        kind = CompiledKind.Never
+      } else if (anyCount === compiledCombinationList.length) {
+        kind = CompiledKind.Any
+      } else if (!areAllTypesTheSame(compiledCombinationList)) {
+        kind = CompiledKind.Never
+      }
+      break
+    }
+    case 'anyOf': {
+      if (anyCount > 0) {
+        kind = CompiledKind.Any
+      } else if (neverCount === compiledCombinationList.length) {
+        kind = CompiledKind.Never
+      }
+      break
+    }
+    case 'oneOf': {
+      if (anyCount > 1) {
+        // More than one unconstrained branch violates oneOf because at least two branches will match.
+        kind = CompiledKind.Never
+      } else if (neverCount === compiledCombinationList.length) {
+        kind = CompiledKind.Never
+      } else if (anyCount === 1 && neverCount === compiledCombinationList.length - 1) {
+        kind = CompiledKind.Any
+      }
+      break
+    }
+  }
+  return wrapCompiledSchema(kind, { [key]: compiledCombinationList }, delegate, context.path)
+}
+
+function areAllTypesTheSame<E>(combinationList: Schema<E>[]): boolean {
+  let lastKind: CompiledKind | null = null
+  for (const schema of combinationList) {
+    const kind = getKind(schema)
+    switch (kind) {
+      case CompiledKind.Any:
+      case CompiledKind.Never: {
+        break
+      }
+      default: {
+        if (lastKind === null) {
+          lastKind = kind
+        } else if (lastKind !== kind) {
+          return false
+        }
+        break
+      }
+    }
+  }
+  return true
+}