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

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

@@ -0,0 +1,49 @@
+import type { ExpressionResult, ExpressionSingleResult } from './result.ts'
+
+import { ExpressionAny, ExpressionMaskList, ExpressionNone } from './result.ts'
+
+export type SingleCalculator = (e1: ExpressionSingleResult, e2: ExpressionSingleResult) => ExpressionResult
+export interface Combination {
+  readonly result: ExpressionResult
+  readonly count: number
+  push(expression: ExpressionResult): ExpressionResult
+}
+
+export function makeCombination(calculator: SingleCalculator): Combination {
+  let expression: ExpressionResult = ExpressionNone
+  let count = 0
+
+  const quantum = {
+    push: (newExpression: ExpressionResult): ExpressionResult => {
+      if (count === 0) {
+        expression = newExpression
+      } else {
+        expression = forEach(expression, newExpression, calculator)
+      }
+      count += 1
+      return expression
+    },
+  }
+  Object.defineProperties(quantum, {
+    result: { get: () => expression },
+    count: { get: () => count },
+  })
+  return quantum as Combination
+}
+
+function forEach(e1: ExpressionResult, e2: ExpressionResult, calculator: SingleCalculator): ExpressionResult {
+  let expression: ExpressionResult = ExpressionNone
+  for (const [singleResult1, mask1] of ExpressionMaskList) {
+    if (mask1 & e1) {
+      for (const [singleResult2, mask2] of ExpressionMaskList) {
+        if (mask2 & e2) {
+          expression |= calculator(singleResult1, singleResult2)
+          if (expression === ExpressionAny) {
+            return expression
+          }
+        }
+      }
+    }
+  }
+  return expression
+}

package/src/json-schema-subset/expression/expression.ts

@@ -0,0 +1,191 @@
+import type { ExpressionResult } from './result.ts'
+import type { Calculator, ExpressionDelegate, ExpressionDescription } from './types.ts'
+
+import { calculate, swap, CalculatorOperator } from './calculator.ts'
+import { ExpressionContainedBy, ExpressionEquals, ExpressionNone } from './result.ts'
+import { ExpressionKind } from './types.ts'
+
+type Parent<E extends object> = {
+  readonly node: Node<E>
+  readonly index: number
+}
+
+type Node<E extends object> = {
+  readonly parent: Parent<E> | null
+  readonly swapped: boolean
+  expressions: [E, E] | null
+  calculation: Calculation | null
+}
+
+type Calculation = {
+  readonly operator: CalculatorOperator
+  readonly results: ExpressionResult[]
+  readonly willSwap: boolean
+  count: number
+}
+
+export const expression =
+  <E extends object>(delegate: ExpressionDelegate<E>): Calculator<E> =>
+  (e1, e2) => {
+    const rootNode: Node<E> = {
+      parent: null,
+      swapped: false,
+      expressions: null,
+      calculation: {
+        operator: CalculatorOperator.Save,
+        results: [ExpressionNone],
+        willSwap: false,
+        count: 0,
+      },
+    }
+    // Nodes awaiting expansion.
+    const extendQueue: Node<E>[] = [
+      {
+        parent: { node: rootNode, index: 0 },
+        swapped: false,
+        expressions: [e1, e2],
+        calculation: null,
+      },
+    ]
+    // Nodes whose leaf results are ready to calculate.
+    const calculateQueue: Node<E>[] = []
+
+    while (extendQueue.length > 0 || calculateQueue.length > 0) {
+      while (extendQueue.length > 0) {
+        const node = extendQueue.pop()!
+        extendNode(node)
+      }
+      while (calculateQueue.length > 0) {
+        const node = calculateQueue.pop()!
+        calculateNode(node)
+      }
+    }
+
+    function extendNode(node: Node<E>): void {
+      let result: ExpressionResult = ExpressionEquals
+      const [leftExpression, rightExpression] = node.expressions!
+
+      if (!delegate.equals(leftExpression, rightExpression)) {
+        const expression1 = delegate.describe(leftExpression)
+
+        if (expression1.kind !== ExpressionKind.Leaf) {
+          const willSwap = false
+          const [calculation, expressions] = expendExpression(expression1, willSwap)
+          node.expressions = null
+          node.calculation = calculation
+
+          for (const [index, childExpression] of expressions.entries()) {
+            extendQueue.push({
+              parent: { node, index },
+              swapped: node.swapped,
+              expressions: [childExpression, rightExpression],
+              calculation: null,
+            })
+          }
+          return
+        }
+        const expression2 = delegate.describe(rightExpression)
+
+        if (expression2.kind !== ExpressionKind.Leaf) {
+          const willSwap = true
+          const [calculation, expressions] = expendExpression(expression2, willSwap)
+          node.expressions = null
+          node.calculation = calculation
+
+          for (const [index, childExpression] of expressions.entries()) {
+            extendQueue.push({
+              parent: { node, index },
+              swapped: !node.swapped,
+              expressions: [childExpression, leftExpression],
+              calculation: null,
+            })
+          }
+          return
+        }
+        result = delegate.calculate(leftExpression, rightExpression)
+        delegate.observeCalculation?.(leftExpression, rightExpression, result, node.swapped)
+
+        if (result === ExpressionNone) {
+          throw new Error('cannot response expression as none')
+        }
+      }
+      node.expressions = null
+      node.calculation = {
+        operator: CalculatorOperator.Save,
+        results: [result],
+        willSwap: false,
+        count: 0,
+      }
+      calculateQueue.push(node)
+    }
+
+    function expendExpression(description: ExpressionDescription<E>, willSwap: boolean): [Calculation, E[]] {
+      let operator: CalculatorOperator = CalculatorOperator.Save
+      let expressions: E[]
+
+      switch (description.kind) {
+        case ExpressionKind.Not: {
+          operator = CalculatorOperator.Not
+          expressions = [description.expression]
+          break
+        }
+        case ExpressionKind.AllOf: {
+          operator = CalculatorOperator.AllOf
+          expressions = [...description.expressions]
+          break
+        }
+        case ExpressionKind.AnyOf: {
+          operator = CalculatorOperator.AnyOf
+          expressions = [...description.expressions]
+          break
+        }
+        case ExpressionKind.OneOf: {
+          operator = CalculatorOperator.OneOf
+          expressions = [...description.expressions]
+          break
+        }
+        default: {
+          throw new Error(`invalid kind ${description.kind}`)
+        }
+      }
+      const calculation: Calculation = {
+        operator,
+        willSwap,
+        count: 0,
+        results: Array(expressions.length).fill(-1),
+      }
+      return [calculation, expressions]
+    }
+
+    function calculateNode(node: Node<E>): void {
+      const calculation = node.calculation!
+      const parent = node.parent
+      let result = calculate(calculation.operator, calculation.results)
+
+      if (result === ExpressionNone) {
+        // AllOf assumes the left intersection is not empty, but this defensive fallback still handles an empty result.
+        // A forced None result therefore makes the left side equivalent to never.
+        result = ExpressionContainedBy
+      }
+      if (calculation.willSwap) {
+        result = swap(result)
+      }
+      if (parent) {
+        const parentCalculation = parent.node.calculation!
+        const parentResults = parentCalculation.results
+
+        parentResults[parent.index] = result
+        parentCalculation.count += 1
+
+        if (parentCalculation.count >= parentResults.length) {
+          calculateQueue.push(parent.node)
+        }
+      }
+    }
+
+    const result = rootNode.calculation!.results[0]
+    if (result === 0) {
+      throw new Error('cannot find result of root')
+    }
+    return result
+  }

package/src/json-schema-subset/expression/index.ts

@@ -0,0 +1,25 @@
+export type { ExpressionResult } from './result.ts'
+export type { Calculator, Describer, Equaler, ExpressionDelegate, ExpressionDescription } from './types.ts'
+
+export { expression } from './expression.ts'
+export { ExpressionKind } from './types.ts'
+export { swap } from './calculator.ts'
+export {
+  toString,
+  hasEquals,
+  hasContaining,
+  hasContainedBy,
+  hasIntersection,
+  hasRejection,
+  toExpression,
+  toSingleExpression,
+  ExpressionNone,
+  ExpressionAny,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionIntersection,
+  ExpressionRejection,
+  ExpressionMaskList,
+  ExpressionSingleResult,
+} from './result.ts'

package/src/json-schema-subset/expression/result.ts

@@ -0,0 +1,88 @@
+import type { DeepReadonly } from '../utils.ts'
+
+import { deepFreeze } from '../utils.ts'
+
+export type ExpressionResult = number
+
+export const ExpressionSingleResult = Object.freeze({
+  Equals: 0,
+  Containing: 1,
+  ContainedBy: 2,
+  Rejection: 3,
+  Intersection: 4,
+})
+
+export type ExpressionSingleResult = (typeof ExpressionSingleResult)[keyof typeof ExpressionSingleResult]
+
+export const ExpressionEquals = toExpression(ExpressionSingleResult.Equals)
+export const ExpressionContaining = toExpression(ExpressionSingleResult.Containing)
+export const ExpressionContainedBy = toExpression(ExpressionSingleResult.ContainedBy)
+export const ExpressionRejection = toExpression(ExpressionSingleResult.Rejection)
+export const ExpressionIntersection = toExpression(ExpressionSingleResult.Intersection)
+
+export const ExpressionMaskList: DeepReadonly<[ExpressionSingleResult, ExpressionResult][]> = deepFreeze([
+  [ExpressionSingleResult.Equals, ExpressionEquals],
+  [ExpressionSingleResult.Containing, ExpressionContaining],
+  [ExpressionSingleResult.ContainedBy, ExpressionContainedBy],
+  [ExpressionSingleResult.Rejection, ExpressionRejection],
+  [ExpressionSingleResult.Intersection, ExpressionIntersection],
+])
+
+export const ExpressionNone = 0
+export const ExpressionAny = ((): ExpressionResult => {
+  let expression = ExpressionNone
+  for (const [_, mask] of ExpressionMaskList) {
+    expression |= mask
+  }
+  return expression
+})()
+
+export function toString(expression: ExpressionResult): string {
+  const strList: string[] = [
+    hasEquals(expression) ? 'E' : '_',
+    hasContaining(expression) ? 'C' : '_',
+    hasContainedBy(expression) ? 'B' : '_',
+    hasRejection(expression) ? 'R' : '_',
+    hasIntersection(expression) ? 'I' : '_',
+  ]
+  return strList.join('')
+}
+
+export function hasEquals(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionEquals)
+}
+
+export function hasContaining(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionContaining)
+}
+
+export function hasContainedBy(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionContainedBy)
+}
+
+export function hasRejection(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionRejection)
+}
+
+export function hasIntersection(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionIntersection)
+}
+
+export function toExpression(expression: ExpressionSingleResult): ExpressionResult {
+  return 1 << expression
+}
+
+export function toSingleExpression(expression: ExpressionResult): ExpressionSingleResult | -1 {
+  let result: ExpressionSingleResult | -1 = -1
+  for (const [singleResult, mask] of ExpressionMaskList) {
+    if (mask & expression) {
+      if (result !== -1) {
+        // A second single result means that the expression is not singular.
+        result = -1
+        break
+      }
+      result = singleResult
+    }
+  }
+  return result
+}

package/src/json-schema-subset/expression/types.ts

@@ -0,0 +1,36 @@
+import type { ExpressionResult } from './result.ts'
+
+export type ExpressionDescription<E> =
+  | {
+      readonly kind: typeof ExpressionKind.Leaf
+    }
+  | {
+      readonly kind: typeof ExpressionKind.Not
+      readonly expression: E
+    }
+  | {
+      readonly kind: typeof ExpressionKind.AllOf | typeof ExpressionKind.AnyOf | typeof ExpressionKind.OneOf
+      readonly expressions: Iterable<E>
+    }
+
+export const ExpressionKind = Object.freeze({
+  Leaf: 0,
+  Not: 1,
+  AllOf: 2,
+  AnyOf: 3,
+  OneOf: 4,
+})
+
+export type ExpressionKind = (typeof ExpressionKind)[keyof typeof ExpressionKind]
+
+export type Calculator<E> = (e1: E, e2: E) => ExpressionResult
+export type Equaler<E> = (e1: E, e2: E) => boolean
+export type Describer<E> = (e: E) => ExpressionDescription<E>
+export type CalculationObserver<E> = (e1: E, e2: E, result: ExpressionResult, swapped: boolean) => void
+
+export type ExpressionDelegate<E> = {
+  readonly describe: Describer<E>
+  readonly equals: Equaler<E>
+  readonly calculate: Calculator<E>
+  readonly observeCalculation?: CalculationObserver<E> | undefined
+}

package/src/json-schema-subset/extends/extendsContext.ts

@@ -0,0 +1,89 @@
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Schema } from '../types.ts'
+import type { ExtendsSchema, ExtendsSchemaClass } from './types.ts'
+
+import { toExpression, ExpressionNone, ExpressionSingleResult } from '../expression/index.ts'
+import { createId } from '../utils.ts'
+
+export class ExtendsContext {
+  private readonly extendsSchemaClasses: readonly ExtendsSchemaClass[]
+
+  public constructor(extendsSchemaClasses: readonly ExtendsSchemaClass[] = []) {
+    this.extendsSchemaClasses = Object.freeze([...extendsSchemaClasses])
+  }
+
+  public tryCompiledExtendsSchema(target: object, payload?: unknown): ExtendsSchema | null {
+    for (const extendsSchemaClass of this.extendsSchemaClasses) {
+      if (extendsSchemaClass.isMatch(target)) {
+        return new extendsSchemaClass(createId(), target, payload)
+      }
+    }
+    return null
+  }
+
+  public isExtendsSchema(target: object): target is ExtendsSchema {
+    for (const extendsSchemaClass of this.extendsSchemaClasses) {
+      if (target instanceof extendsSchemaClass) {
+        return true
+      }
+    }
+    return false
+  }
+
+  public calculate(schema1: Schema<unknown>, schema2: Schema<unknown>): ExpressionResult {
+    const schemaClass = this.findMatchedClass(schema1, schema2)
+    const shouldSwap = !(schema1 instanceof schemaClass)
+
+    let expressionResult: ExpressionResult = ExpressionNone
+    let result: readonly ExpressionSingleResult[]
+
+    if (shouldSwap) {
+      result = (schema2 as ExtendsSchema).compare(schema1)
+    } else {
+      result = schema1.compare(schema2)
+    }
+    for (let expression of result) {
+      if (shouldSwap) {
+        expression = ExtendsContext.swap(expression)
+      }
+      expressionResult |= toExpression(expression)
+    }
+    return expressionResult
+  }
+
+  public equals(schema1: Schema<unknown>, schema2: Schema<unknown>): boolean {
+    const schemaClass = this.findMatchedClass(schema1, schema2)
+    const shouldSwap = !(schema1 instanceof schemaClass)
+    if (shouldSwap) {
+      return (schema2 as ExtendsSchema).equals(schema1)
+    } else {
+      return schema1.equals(schema2)
+    }
+  }
+
+  private findMatchedClass(schema1: Schema<unknown>, schema2: Schema<unknown>): ExtendsSchemaClass {
+    for (const schemaClass of this.extendsSchemaClasses) {
+      if (schema1 instanceof schemaClass) {
+        return schemaClass
+      }
+      if (schema2 instanceof schemaClass) {
+        return schemaClass
+      }
+    }
+    throw new Error('Invalid schema')
+  }
+
+  private static swap(expression: ExpressionSingleResult): ExpressionSingleResult {
+    switch (expression) {
+      case ExpressionSingleResult.Containing: {
+        return ExpressionSingleResult.ContainedBy
+      }
+      case ExpressionSingleResult.ContainedBy: {
+        return ExpressionSingleResult.Containing
+      }
+      default: {
+        return expression
+      }
+    }
+  }
+}

package/src/json-schema-subset/extends/index.ts

@@ -0,0 +1,2 @@
+export type { ExtendsSchemaClass, ExtendsSchema } from './types.ts'
+export { ExtendsContext } from './extendsContext.ts'

package/src/json-schema-subset/extends/types.ts

@@ -0,0 +1,12 @@
+import type { ExpressionSingleResult } from '../expression/index.ts'
+
+export interface ExtendsSchemaClass {
+  new (id: number, value: unknown, payload?: unknown): ExtendsSchema
+  isMatch(value: unknown): boolean
+}
+
+export interface ExtendsSchema {
+  readonly id: number
+  compare(other: unknown): readonly ExpressionSingleResult[]
+  equals(other: unknown): boolean
+}

package/src/json-schema-subset/global.ts

@@ -0,0 +1,60 @@
+import type { CompilableSchema, InputSchema } from './compiler/index.ts'
+import type { ExtendsSchemaClass } from './extends/index.ts'
+import type { Compiler } from './preprocessing.ts'
+import type { Schema } from './types.ts'
+import type { JSONDelegate } from './types.ts'
+
+import { checkWithResult } from './checker/checker.ts'
+import { compile } from './compiler/index.ts'
+import { hasContainedBy, hasContaining, hasEquals, hasIntersection, hasRejection } from './expression/index.ts'
+import { ExtendsContext } from './extends/index.ts'
+import { preprocessSchema, preprocessSchemasPair } from './preprocessing.ts'
+
+export type MakingParams<E> = {
+  readonly extendsSchemaClasses?: readonly ExtendsSchemaClass[]
+  readonly delegate?: JSONDelegate<E>
+}
+
+export interface SubsetCompare<E> {
+  compile(schema: InputSchema, payload?: unknown, printWarnLog?: boolean): Schema<E>
+  isSubset(superSchema: CompilableSchema<E>, subSchema: CompilableSchema<E>, printWarnLog?: boolean): SubsetComparison
+}
+
+export interface SubsetComparison {
+  readonly errorPath?: readonly (string | number)[] | undefined
+  readonly result: SubsetCompareResult
+}
+
+export const SubsetCompareResult = Object.freeze({
+  True: 0,
+  False: 1,
+  Unknown: 2,
+})
+
+export type SubsetCompareResult = (typeof SubsetCompareResult)[keyof typeof SubsetCompareResult]
+
+export function makeSubsetCompare<E = unknown>({ extendsSchemaClasses, delegate }: MakingParams<E> = {}): SubsetCompare<E> {
+  const extendsContext = new ExtendsContext(extendsSchemaClasses)
+  const comparer: SubsetCompare<E> = Object.freeze({
+    compile: (schema: InputSchema, payload?: unknown, printWarnLog?: boolean): Schema<E> => {
+      const compiler: Compiler<E> = (candidate) => compile(candidate, extendsContext, payload, delegate)
+      return preprocessSchema(schema, compiler, printWarnLog)
+    },
+    isSubset: (superSchema: CompilableSchema<E>, subSchema: CompilableSchema<E>, printWarnLog = false): SubsetComparison => {
+      const compiler: Compiler<E> = (candidate) => compile(candidate, extendsContext, undefined, delegate)
+      const [schema1, schema2] = preprocessSchemasPair(superSchema, subSchema, compiler, printWarnLog)
+      const { errorPath, expression } = checkWithResult(extendsContext, schema1, schema2)
+      const foundTrueExpression = hasEquals(expression) || hasContainedBy(expression)
+      const foundFalseExpression = hasContaining(expression) || hasIntersection(expression) || hasRejection(expression)
+
+      if (foundTrueExpression && !foundFalseExpression) {
+        return { result: SubsetCompareResult.True }
+      }
+      if (!foundTrueExpression && foundFalseExpression) {
+        return { errorPath, result: SubsetCompareResult.False }
+      }
+      return { result: SubsetCompareResult.Unknown }
+    },
+  })
+  return comparer
+}

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

@@ -0,0 +1,8 @@
+export type { SubsetCompare, SubsetComparison } from './global.ts'
+export type { Schema, JSONDelegate } from './types.ts'
+export type { ExtendsSchema, ExtendsSchemaClass } from './extends/index.ts'
+export type { InputSchema, CompiledSchema } from './compiler/index.ts'
+export type { SchemaError } from './error.ts'
+
+export { ExpressionSingleResult } from './expression/index.ts'
+export { makeSubsetCompare, SubsetCompareResult } from './global.ts'

package/src/json-schema-subset/preprocessing.ts

@@ -0,0 +1,74 @@
+import type { CompilableSchema, CompileResult } from './compiler/index.ts'
+import type { CompiledSchemaErrorItem, SchemaErrorItem } from './error.ts'
+import type { Schema } from './types.ts'
+
+import { SchemaError, stringifySchemaError } from './error.ts'
+
+export type Compiler<E> = (schema: CompilableSchema<E>) => CompileResult<E> | readonly SchemaErrorItem<E>[]
+
+export function preprocessSchema<E>(schema: CompilableSchema<E>, compile: Compiler<E>, printWarnLog = false): Schema<E> {
+  const schemaResult = compile(schema)
+  if (Array.isArray(schemaResult)) {
+    const errorItems: SchemaErrorItem[] = []
+    collectWithPathPrefix(errorItems, schemaResult, '$')
+    throw new SchemaError(errorItems)
+  }
+  const { schema: compiledSchema, warns } = schemaResult as CompileResult<E>
+  if (printWarnLog && warns.length > 0) {
+    console.warn(`found ${warns.length} warns after compile schema`)
+    for (const warn of warns) {
+      console.warn(stringifySchemaError(warn))
+    }
+  }
+  return compiledSchema
+}
+
+export function preprocessSchemasPair<E>(
+  schema1: CompilableSchema<E>,
+  schema2: CompilableSchema<E>,
+  compile: Compiler<E>,
+  printWarnLog = false,
+): [Schema<E>, Schema<E>] {
+  const schemaResult1 = compile(schema1)
+  const schemaResult2 = compile(schema2)
+
+  if (Array.isArray(schemaResult1) || Array.isArray(schemaResult2)) {
+    const errorItems: SchemaErrorItem[] = []
+
+    if (Array.isArray(schemaResult1)) {
+      collectWithPathPrefix(errorItems, schemaResult1, '$1')
+    }
+    if (Array.isArray(schemaResult2)) {
+      collectWithPathPrefix(errorItems, schemaResult2, '$2')
+    }
+    throw new SchemaError(errorItems)
+  }
+  const { schema: compiledSchema1, warns: superWarns } = schemaResult1 as CompileResult<E>
+  const { schema: compiledSchema2, warns: subWarns } = schemaResult2 as CompileResult<E>
+
+  if (printWarnLog) {
+    if (superWarns.length > 0) {
+      console.warn(`found ${superWarns.length} warns after compile superSchema`)
+    }
+    for (const warn of superWarns) {
+      console.warn(stringifySchemaError(warn))
+    }
+    if (subWarns.length > 0) {
+      console.warn(`found ${subWarns.length} warns after compile subSchema`)
+    }
+    for (const warn of subWarns) {
+      console.warn(stringifySchemaError(warn))
+    }
+  }
+  return [compiledSchema1, compiledSchema2]
+}
+
+function collectWithPathPrefix(errorItems: SchemaErrorItem[], compiledItems: readonly CompiledSchemaErrorItem[], prefix: number | string): void {
+  for (const compiledItem of compiledItems) {
+    const replacedItem: SchemaErrorItem = {
+      ...compiledItem,
+      path: [prefix, ...compiledItem.path],
+    }
+    errorItems.push(replacedItem)
+  }
+}

package/src/json-schema-subset/types.ts

@@ -0,0 +1,8 @@
+import type { CompiledSchema } from './compiler/index.ts'
+import type { ExtendsSchema } from './extends/index.ts'
+
+export type Schema<E> = ExtendsSchema | CompiledSchema<E>
+export interface JSONDelegate<E = unknown> {
+  isSchema(schema: object): boolean | readonly E[]
+  compile(schema: object): (value: unknown) => boolean | readonly E[]
+}