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

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

@@ -0,0 +1,442 @@
+import type { Combination } from './combination.ts'
+import type { ExpressionResult } from './result.ts'
+
+import { makeCombination } from './combination.ts'
+import {
+  ExpressionNone,
+  ExpressionSingleResult,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionRejection,
+  ExpressionIntersection,
+  ExpressionMaskList,
+} from './result.ts'
+
+export const CalculatorOperator = Object.freeze({
+  Save: 0,
+  OneOf: 1,
+  AllOf: 2,
+  AnyOf: 3,
+  Not: 4,
+  Swap: 5,
+})
+
+export type CalculatorOperator = (typeof CalculatorOperator)[keyof typeof CalculatorOperator]
+
+export function calculate(operator: CalculatorOperator, expressions: readonly ExpressionResult[]): ExpressionResult {
+  switch (operator) {
+    case CalculatorOperator.Save: {
+      return expressions[0]
+    }
+    case CalculatorOperator.OneOf: {
+      return calculateOneOf(expressions)
+    }
+    case CalculatorOperator.AllOf:
+    case CalculatorOperator.AnyOf: {
+      return calculateCombination(operator, expressions)
+    }
+    case CalculatorOperator.Not:
+    case CalculatorOperator.Swap: {
+      return calculateUnary(operator, expressions[0])
+    }
+  }
+}
+
+export function swap(expression: ExpressionResult): ExpressionResult {
+  return calculateUnary(CalculatorOperator.Swap, expression)
+}
+
+/**
+ * The oneOf operator is indivisible, so `a + b + c` must be evaluated as one expression.
+ * ![](../../doc/images/all_of_expression.png)
+ */
+function calculateOneOf(expressions: readonly ExpressionResult[]): ExpressionResult {
+  // A single remaining branch makes oneOf equivalent to that branch.
+  if (expressions.length === 1) {
+    return expressions[0]
+  }
+  const unionSet = calculateCombination(CalculatorOperator.AnyOf, expressions)
+  const intersectionList: ExpressionResult[] = []
+
+  for (let i = 0; i < expressions.length; ++i) {
+    for (let j = i + 1; j < expressions.length; ++j) {
+      const left = expressions[i]
+      const right = expressions[j]
+      const intersection = calculateCombination(CalculatorOperator.AllOf, [left, right])
+      intersectionList.push(intersection)
+    }
+  }
+  const banZone = calculateCombination(CalculatorOperator.AnyOf, intersectionList)
+  const enableZone = calculateUnary(CalculatorOperator.Not, banZone)
+
+  return calculateCombination(CalculatorOperator.AllOf, [unionSet, enableZone])
+}
+
+function calculateCombination(operator: CalculatorOperator, expressions: readonly ExpressionResult[]): ExpressionResult {
+  if (expressions.length < 0) {
+    throw new Error('invalid expressions: empty array')
+  }
+  let combination: Combination
+
+  switch (operator) {
+    case CalculatorOperator.AllOf: {
+      combination = makeCombination(calculateAllOf)
+      break
+    }
+    case CalculatorOperator.AnyOf: {
+      combination = makeCombination(calculateAnyOf)
+      break
+    }
+    default: {
+      throw new Error(`invalid operator ${operator}`)
+    }
+  }
+  for (const expression of expressions) {
+    combination.push(expression)
+  }
+  return combination.result
+}
+
+function calculateUnary(operator: CalculatorOperator, expression: ExpressionResult): ExpressionResult {
+  let calculator: (expression: ExpressionSingleResult) => ExpressionResult
+  let result: ExpressionResult = ExpressionNone
+
+  switch (operator) {
+    case CalculatorOperator.Not: {
+      calculator = calculateNot
+      break
+    }
+    case CalculatorOperator.Swap: {
+      calculator = calculateSwap
+      break
+    }
+    default: {
+      throw new Error(`invalid operator ${operator}`)
+    }
+  }
+  for (const [singleExpression, maskExpression] of ExpressionMaskList) {
+    if (maskExpression & expression) {
+      result |= calculator(singleExpression)
+    }
+  }
+  return result
+}
+
+function calculateAllOf(e1: ExpressionSingleResult, e2: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (e1) {
+    case ExpressionSingleResult.Equals: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionEquals | ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionIntersection | ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionRejection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionIntersection | ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy | ExpressionRejection | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+  }
+  return result
+}
+
+function calculateAnyOf(e1: ExpressionSingleResult, e2: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (e1) {
+    case ExpressionSingleResult.Equals: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionEquals | ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+  }
+  return result
+}
+
+function calculateNot(expression: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (expression) {
+    case ExpressionSingleResult.Equals: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      result = ExpressionIntersection
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      result = ExpressionEquals | ExpressionContaining
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      result = ExpressionContainedBy | ExpressionIntersection
+      break
+    }
+  }
+  return result
+}
+
+function calculateSwap(expression: ExpressionResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (expression) {
+    case ExpressionSingleResult.Equals: {
+      result = ExpressionEquals
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      result = ExpressionContainedBy
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      result = ExpressionContaining
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      result = ExpressionIntersection
+      break
+    }
+  }
+  return result
+}

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'