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

package/src/flow/common/workflowFile.ts

@@ -0,0 +1,97 @@
+import type { GraphNode, InputMapping, JsonValue, RevisionContent } from './change.ts'
+
+import { dequal } from 'dequal/lite'
+import { z } from 'zod'
+import { clearTriggerExternalConfig } from '../../trigger/common/config.ts'
+import { decodeRevisionContent } from './changeSchema.ts'
+import { clearConditionBindings } from './condition.ts'
+import { clearNodeConnections } from './connectionUsage.ts'
+import { checkJsonDepth } from './json.ts'
+
+export interface WorkflowFile {
+  readonly kind: 'open-flow-workflow'
+  readonly version: 1
+  readonly name?: string
+  readonly content: RevisionContent
+  readonly presentation?: Readonly<Record<string, JsonValue>>
+}
+
+export interface WorkflowCleanupSummary {
+  readonly changedNodeIds: readonly string[]
+  readonly removedBindings: number
+}
+
+const envelope = z.strictObject({
+  kind: z.literal('open-flow-workflow'),
+  version: z.literal(1),
+  name: z.string().optional(),
+  content: z.unknown(),
+  presentation: z.record(z.string(), z.json()).optional(),
+})
+
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+export function decodeWorkflowFile(value: unknown): WorkflowFile {
+  checkJsonDepth(value, -1)
+  const file = envelope.parse(value)
+  return { ...file, content: decodeRevisionContent(file.content) }
+}
+
+export function parseWorkflowFile(text: string): WorkflowFile {
+  return decodeWorkflowFile(JSON.parse(text))
+}
+
+function cleanInput(input: InputMapping): InputMapping {
+  if (input.kind != 'sources' || !input.sources.some((source) => source.kind == 'binding')) return input
+  const sources = input.sources.filter((source) => source.kind != 'binding')
+  return sources.length == 0 ? { kind: 'unset' } : { kind: 'sources', sources }
+}
+
+/** Clear only owned structured references, never strings in code or business values. */
+export function cleanWorkflowFile(value: unknown): { readonly file: WorkflowFile; readonly summary: WorkflowCleanupSummary } {
+  const file = decodeWorkflowFile(value)
+  const original = file.content.document.graph
+  const graph = clearNodeConnections(original)
+  const nodes = Object.fromEntries(
+    Object.entries(graph.nodes).map(([id, source]) => {
+      let node: GraphNode = source
+      if ('inputs' in node) node = { ...node, inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, input]) => [key, cleanInput(input)])) }
+      if (node.kind == 'outputs')
+        node = { ...node, outputMappings: Object.fromEntries(Object.entries(node.outputMappings).map(([key, input]) => [key, cleanInput(input)])) }
+      if (node.kind == 'condition') node = clearConditionBindings(node)
+      if (node.kind == 'error' && node.sourceFlowIds != null) node = { ...node, sourceFlowIds: [] }
+      if (node.kind == 'poll' || node.kind == 'integration') node = { ...node, config: clearTriggerExternalConfig(node.definition.key, node.config) }
+      return [id, node]
+    }),
+  )
+  return {
+    file: {
+      ...file,
+      content: {
+        ...file.content,
+        document: {
+          ...file.content.document,
+          bindings: {},
+          graph: { ...graph, nodes },
+        },
+      },
+    },
+    summary: {
+      changedNodeIds: Object.keys(nodes).filter((id) => !dequal(nodes[id], original.nodes[id])),
+      removedBindings: Object.keys(file.content.document.bindings).length,
+    },
+  }
+}
+
+export function encodeWorkflowFile(file: WorkflowFile): string {
+  return `${JSON.stringify(cleanWorkflowFile(file).file, null, 2)}\n`
+}
+
+export function workflowFileName(name: string): string {
+  // Control characters are forbidden in download filenames.
+  // oxlint-disable-next-line no-control-regex
+  return `${name.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').replace(/[. ]+$/g, '') || 'workflow'}.openflow.json`
+}
+
+export function workflowNameFromFile(name: string): string {
+  return name.replace(/(?:\.openflow)?\.json$/i, '')
+}

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

@@ -0,0 +1,142 @@
+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 { ANY } from '../compiler/index.ts'
+import {
+  ExpressionNone,
+  ExpressionContainedBy,
+  ExpressionContaining,
+  ExpressionEquals,
+  ExpressionIntersection,
+  ExpressionRejection,
+  ExpressionSingleResult,
+} from '../expression/index.ts'
+import { createRangeSplitter, toExpressionSingleResult } from './range.ts'
+import { makeQuantum } from './tools/index.ts'
+
+const splitRange = createRangeSplitter(0)
+const quantum = makeQuantum(['hasCommon', 'hasExtra1', 'hasExtra2', 'hasRejection', 'hasCommonBroken'])
+
+export function calculateArray<E>({ calculate }: Context<E>, schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const splitResult = splitRange(schema1.minItems, schema1.maxItems, schema2.minItems, schema2.maxItems)
+  const splitExpression = toExpressionSingleResult(splitResult)
+
+  if (splitExpression === ExpressionSingleResult.Rejection) {
+    return ExpressionRejection
+  }
+  const [items1, additionalItems1] = normalizeArray(schema1)
+  const [items2, additionalItems2] = normalizeArray(schema2)
+
+  // The final slot compares additionalItems without a tuple item.
+  const itemsLength = Math.max(items1.length, items2.length) + 1
+  const length = Math.min(itemsLength, splitResult.intersection!.max)
+  const quantumVariable = quantum.variable({})
+  const minItems = Math.min(schema1.minItems ?? 0, schema2.minItems ?? 0)
+
+  for (let i = 0; i < length; i++) {
+    const subSchema1 = items1[i] ?? additionalItems1
+    const subSchema2 = items2[i] ?? additionalItems2
+    const expression = calculate(subSchema1, subSchema2)
+
+    quantumVariable.push(expression, (singleExpression, variable) => {
+      switch (singleExpression) {
+        case ExpressionSingleResult.Equals: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra1 = true
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra2 = true
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          if (!variable.hasRejection) {
+            variable.hasCommon = true
+          }
+          variable.hasExtra1 = true
+          variable.hasExtra2 = true
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          if (i < minItems) {
+            variable.hasCommonBroken = true
+          }
+          variable.hasRejection = true
+          variable.hasExtra1 = true
+          variable.hasExtra2 = true
+          break
+        }
+      }
+    })
+  }
+  quantumVariable.update((variable) => {
+    switch (splitExpression) {
+      case ExpressionSingleResult.Containing: {
+        variable.hasExtra1 = true
+        break
+      }
+      case ExpressionSingleResult.ContainedBy: {
+        variable.hasExtra2 = true
+        break
+      }
+      case ExpressionSingleResult.Intersection: {
+        variable.hasExtra1 = true
+        variable.hasExtra2 = true
+        break
+      }
+    }
+    if (schema1.uniqueItems && !schema2.uniqueItems && (schema2.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra2 = true
+    else if (!schema1.uniqueItems && schema2.uniqueItems && (schema1.maxItems ?? Number.POSITIVE_INFINITY) > 1) variable.hasExtra1 = true
+    if (schema1.maxItems === 0 || schema2.maxItems === 0) {
+      // An unconstrained empty array can match any array schema.
+      variable.hasCommon = true
+      if (schema1.maxItems !== 0) {
+        variable.hasExtra1 = true
+      }
+      if (schema2.maxItems !== 0) {
+        variable.hasExtra2 = true
+      }
+    }
+  })
+  let expression = ExpressionNone
+
+  for (const { hasExtra1, hasExtra2, hasCommon, hasCommonBroken } of quantumVariable) {
+    let finalHasCommon = hasCommon
+    if (hasCommonBroken) {
+      finalHasCommon = false
+    }
+    if (!finalHasCommon) {
+      expression |= ExpressionRejection
+    } else if (hasExtra1 && hasExtra2) {
+      expression |= ExpressionIntersection
+    } else if (hasExtra1) {
+      expression |= ExpressionContaining
+    } else if (hasExtra2) {
+      expression |= ExpressionContainedBy
+    } else {
+      expression |= ExpressionEquals
+    }
+  }
+  return expression
+}
+
+function normalizeArray<E>({ items, additionalItems }: CompiledSchema<E>): [readonly Schema<E>[], Schema<E>] {
+  if (Array.isArray(items)) {
+    return [items as readonly Schema<E>[], (additionalItems ?? ANY) as Schema<E>]
+  } else {
+    return [[], (items ?? ANY) as Schema<E>]
+  }
+}

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

@@ -0,0 +1,57 @@
+import type { CompiledObject, CompiledSchema, CompiledValue } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { ExtendsSchema } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+
+import { getId, isCompiledObject } from '../compiler/index.ts'
+
+export type Context<E> = {
+  readonly isEquals: EqualsChecker
+  readonly calculate: SchemaCalculator<E>
+}
+
+export type EqualsChecker = (value1: CompiledValue, value2: CompiledValue) => boolean
+export type SchemaCalculator<E> = (superSchema: Schema<E>, subSchema: Schema<E>) => ExpressionResult
+
+export function wrapEqualsCheckerWithCache(check: (object1: CompiledObject, object2: CompiledObject) => boolean): EqualsChecker {
+  const map = new Map<string, boolean>()
+
+  return (value1, value2) => {
+    const isObject1 = isCompiledObject(value1)
+    const isObject2 = isCompiledObject(value2)
+
+    if (isObject1 !== isObject2) {
+      return false
+    }
+    if (!isObject1) {
+      return value1 === value2
+    }
+    const object1 = value1 as CompiledObject
+    const object2 = value2 as CompiledObject
+
+    return getWithCache(map, object1, object2, check)
+  }
+}
+
+export function wrapSchemaCalculatorWithCache<E>(check: SchemaCalculator<E>): SchemaCalculator<E> {
+  const map = new Map<string, ExpressionResult>()
+  return (schema1, schema2) => getWithCache(map, schema1, schema2, check)
+}
+
+function getWithCache<R, E, N extends ExtendsSchema | DeepReadonly<CompiledSchema<E>> | DeepReadonly<CompiledObject>>(
+  map: Map<string, R>,
+  node1: N,
+  node2: N,
+  check: (n1: N, n2: N) => R,
+): R {
+  const id1 = getId(node1)
+  const id2 = getId(node2)
+  const key = `${id1}/${id2}`
+
+  let result = map.get(key)
+  if (result === undefined) {
+    map.set(key, (result = check(node1, node2)))
+  }
+  return result
+}

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

@@ -0,0 +1,230 @@
+import type { JSONSchema7Definition } from 'json-schema'
+import type { CompiledSchema, SchemaPath } from '../compiler/index.ts'
+import type { Calculator, Describer, ExpressionDescription, ExpressionResult } from '../expression/index.ts'
+import type { ExtendsContext } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+import type { Context } from './cache.ts'
+
+import { CompiledKind, getKind, getPath } from '../compiler/index.ts'
+import {
+  swap,
+  expression,
+  ExpressionKind,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionRejection,
+  hasContainedBy,
+  hasEquals,
+  hasContaining,
+  hasIntersection,
+  hasRejection,
+} from '../expression/index.ts'
+import { isDeepEquals } from '../utils.ts'
+import { calculateArray } from './array.ts'
+import { wrapEqualsCheckerWithCache, wrapSchemaCalculatorWithCache } from './cache.ts'
+import { calculateEnumAndEnum, calculateEnumAndSchema } from './enumAndConst.ts'
+import { schemaEqualsChecker } from './equals.ts'
+import { calculateNumeric } from './numeric/index.ts'
+import { calculateObject } from './object.ts'
+import { calculateString } from './string.ts'
+
+export type Options = {
+  readonly printWarnLog?: boolean
+}
+
+export interface CheckResult {
+  readonly errorPath?: SchemaPath | undefined
+  readonly expression: ExpressionResult
+}
+
+type WritableContext<E> = { -readonly [K in keyof Context<E>]?: Context<E>[K] }
+
+export function checkWithResult<E>(extendsContext: ExtendsContext, schema1: Schema<E>, schema2: Schema<E>): CheckResult {
+  const context: WritableContext<E> = {}
+  const errorPaths: SchemaPath[] = []
+  const calculate = wrapSchemaCalculatorWithCache(calculator(extendsContext, context as Context<E>))
+  const describe = describer<E>()
+  const equals = schemaEqualsChecker<E>(extendsContext)
+  context.isEquals = wrapEqualsCheckerWithCache(isDeepEquals)
+  context.calculate = expression({
+    describe,
+    equals,
+    calculate,
+    observeCalculation: (left, right, result, swapped) => {
+      const comparisonResult = swapped ? swap(result) : result
+      if (!isDecisiveMismatch(comparisonResult)) return
+      const errorPath = swapped ? findMismatchPath(right, left) : findMismatchPath(left, right)
+      if (errorPath) errorPaths.push(errorPath)
+    },
+  })
+  Object.freeze(context)
+  const comparisonExpression = context.calculate(schema1, schema2)
+  return { errorPath: errorPaths[0], expression: comparisonExpression }
+}
+
+const describer =
+  <E>(): Describer<Schema<E>> =>
+  (schema: Schema<E>) => {
+    let description: ExpressionDescription<Schema<E>>
+    switch (getKind(schema)) {
+      case CompiledKind.Not: {
+        description = {
+          kind: ExpressionKind.Not,
+          expression: (schema as CompiledSchema<E>).not as Schema<E>,
+        }
+        break
+      }
+      case CompiledKind.Combination: {
+        if ('allOf' in schema) {
+          description = {
+            kind: ExpressionKind.AllOf,
+            expressions: rejectInSchemaList(schema.allOf, CompiledKind.Any),
+          }
+        } else if ('anyOf' in schema) {
+          description = {
+            kind: ExpressionKind.AnyOf,
+            expressions: rejectInSchemaList(schema.anyOf, CompiledKind.Never),
+          }
+        } else if ('oneOf' in schema) {
+          description = {
+            kind: ExpressionKind.OneOf,
+            expressions: rejectInSchemaList(schema.oneOf, CompiledKind.Never),
+          }
+        } else {
+          throw new Error(`invalid combination JSON Schema: ${JSON.stringify(schema)}`)
+        }
+        break
+      }
+      default: {
+        description = { kind: ExpressionKind.Leaf }
+        break
+      }
+    }
+    return description
+  }
+
+const calculator =
+  <E>(extendsContext: ExtendsContext, context: Context<E>): Calculator<Schema<E>> =>
+  (schema1, schema2) => {
+    const kind1 = getKind(schema1)
+    const kind2 = getKind(schema2)
+
+    if (kind1 === CompiledKind.Extends || kind2 === CompiledKind.Extends) {
+      return extendsContext.calculate(schema1, schema2)
+    }
+    switch (kind1) {
+      case CompiledKind.Any: {
+        return kind2 === CompiledKind.Any ? ExpressionEquals : ExpressionContaining
+      }
+      case CompiledKind.Never: {
+        return kind2 === CompiledKind.Never ? ExpressionEquals : ExpressionContainedBy
+      }
+    }
+    switch (kind2) {
+      case CompiledKind.Any: {
+        return ExpressionContainedBy
+      }
+      case CompiledKind.Never: {
+        return ExpressionContaining
+      }
+    }
+    if (kind1 === CompiledKind.EnumOrConst && kind2 === CompiledKind.EnumOrConst) {
+      return calculateEnumAndEnum(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+    }
+    if (kind1 === CompiledKind.EnumOrConst) {
+      return calculateEnumAndSchema(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+    }
+    if (kind2 === CompiledKind.EnumOrConst) {
+      return swap(calculateEnumAndSchema(schema2 as CompiledSchema<E>, schema1 as CompiledSchema<E>))
+    }
+    if (kind1 !== kind2) {
+      return ExpressionRejection
+    }
+    switch (kind1) {
+      case CompiledKind.Null: {
+        return ExpressionEquals
+      }
+      case CompiledKind.Numeric: {
+        return calculateNumeric(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.String: {
+        return calculateString(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.Boolean: {
+        return ExpressionEquals
+      }
+      case CompiledKind.Object: {
+        return calculateObject(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.Array: {
+        return calculateArray(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      default: {
+        throw new Error(`invalid kind ${kind1}`)
+      }
+    }
+  }
+
+function rejectInSchemaList<E>(schemaList: DeepReadonly<JSONSchema7Definition[]> | undefined, kind: CompiledKind): CompiledSchema<E>[] {
+  return (schemaList as CompiledSchema<E>[]).filter((e) => getKind(e) !== kind)
+}
+
+function isDecisiveMismatch(result: ExpressionResult): boolean {
+  return !hasEquals(result) && !hasContainedBy(result) && (hasContaining(result) || hasIntersection(result) || hasRejection(result))
+}
+
+function findMismatchPath<E>(source: Schema<E>, target: Schema<E>): SchemaPath | undefined {
+  const targetPath = getPath(target)
+  if (!targetPath) return undefined
+  const sourceKind = getKind(source)
+  const targetKind = getKind(target)
+  if (sourceKind !== targetKind) return [...targetPath, 'type']
+
+  const sourceSchema = source as CompiledSchema<E>
+  const targetSchema = target as CompiledSchema<E>
+  switch (targetKind) {
+    case CompiledKind.String: {
+      if ((sourceSchema.minLength ?? 0) < (targetSchema.minLength ?? 0)) return [...targetPath, 'minLength']
+      if ((sourceSchema.maxLength ?? Number.POSITIVE_INFINITY) > (targetSchema.maxLength ?? Number.POSITIVE_INFINITY)) return [...targetPath, 'maxLength']
+      if (sourceSchema.pattern !== targetSchema.pattern && targetSchema.pattern) return [...targetPath, 'pattern']
+      if (sourceSchema.format !== targetSchema.format && targetSchema.format) return [...targetPath, 'format']
+      break
+    }
+    case CompiledKind.Numeric: {
+      if (
+        (sourceSchema.minimum ?? sourceSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) <
+        (targetSchema.minimum ?? targetSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY)
+      ) {
+        return [...targetPath, targetSchema.exclusiveMinimum == null ? 'minimum' : 'exclusiveMinimum']
+      }
+      if (
+        (sourceSchema.maximum ?? sourceSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY) >
+        (targetSchema.maximum ?? targetSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY)
+      ) {
+        return [...targetPath, targetSchema.exclusiveMaximum == null ? 'maximum' : 'exclusiveMaximum']
+      }
+      if (sourceSchema.multipleOf !== targetSchema.multipleOf && targetSchema.multipleOf != null) return [...targetPath, 'multipleOf']
+      break
+    }
+    case CompiledKind.Array: {
+      if ((sourceSchema.minItems ?? 0) < (targetSchema.minItems ?? 0)) return [...targetPath, 'minItems']
+      if ((sourceSchema.maxItems ?? Number.POSITIVE_INFINITY) > (targetSchema.maxItems ?? Number.POSITIVE_INFINITY)) return [...targetPath, 'maxItems']
+      if (!sourceSchema.uniqueItems && targetSchema.uniqueItems) return [...targetPath, 'uniqueItems']
+      break
+    }
+    case CompiledKind.Object: {
+      const sourceRequired = new Set(sourceSchema.required ?? [])
+      if ((targetSchema.required ?? []).some((key) => !sourceRequired.has(key))) return [...targetPath, 'required']
+      if ((sourceSchema.minProperties ?? 0) < (targetSchema.minProperties ?? 0)) return [...targetPath, 'minProperties']
+      if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY))
+        return [...targetPath, 'maxProperties']
+      break
+    }
+    case CompiledKind.EnumOrConst: {
+      return [...targetPath, targetSchema.const === undefined ? 'enum' : 'const']
+    }
+  }
+  return targetPath
+}

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

@@ -0,0 +1,113 @@
+import type { CompiledSchema, CompiledValue } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Context } from './cache.ts'
+
+import { getKind, CompiledKind } from '../compiler/index.ts'
+import {
+  ExpressionAny,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionIntersection,
+  ExpressionRejection,
+} from '../expression/index.ts'
+import { valid, ValidResult } from './validator.ts'
+
+export function calculateEnumAndEnum<E>(context: Context<E>, schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const enumList1 = normalizeEnumList(schema1)
+  const enumList2 = normalizeEnumList(schema2)
+
+  let foundExtra1 = false
+  let foundExtra2 = false
+  let foundIntersection = false
+
+  for (const enum1 of enumList1) {
+    if (hasEqualsEnum(context, enumList2, enum1)) {
+      foundIntersection = true
+    } else {
+      foundExtra1 = true
+    }
+    if (foundExtra1 && foundIntersection) {
+      break
+    }
+  }
+  for (const enum2 of enumList2) {
+    if (hasEqualsEnum(context, enumList1, enum2)) {
+      foundIntersection = true
+    } else {
+      foundExtra2 = true
+    }
+    if (foundExtra2 && foundIntersection) {
+      break
+    }
+  }
+  if (!foundIntersection) {
+    return ExpressionRejection
+  }
+  if (foundExtra1 && foundExtra2) {
+    return ExpressionIntersection
+  }
+  if (foundExtra1) {
+    return ExpressionContaining
+  }
+  if (foundExtra2) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function calculateEnumAndSchema<E>(enumSchema: CompiledSchema<E>, schema: CompiledSchema<E>): ExpressionResult {
+  let hasValid = false
+  let hasInvalid = false
+
+  for (const enumValue of normalizeEnumList(enumSchema)) {
+    switch (valid(schema, enumValue)) {
+      case ValidResult.Valid: {
+        hasValid = true
+        break
+      }
+      case ValidResult.Invalid: {
+        hasInvalid = true
+        break
+      }
+      case ValidResult.Unknown: {
+        return ExpressionAny
+      }
+    }
+    if (hasValid && hasInvalid) {
+      break
+    }
+  }
+  if (hasValid && hasInvalid) {
+    return ExpressionIntersection
+  }
+  if (hasValid) {
+    return ExpressionEquals | ExpressionContainedBy
+  }
+  if (hasInvalid) {
+    return ExpressionRejection
+  }
+  if (getKind(schema) === CompiledKind.Never) {
+    return ExpressionEquals
+  }
+  return ExpressionContainedBy
+}
+
+function normalizeEnumList<E>({ const: constValue, enum: enumList }: CompiledSchema<E>): CompiledValue[] {
+  if (constValue !== undefined) {
+    return [constValue as CompiledValue]
+  }
+  if (enumList) {
+    return enumList as CompiledValue[]
+  }
+  throw new Error('invalid branch')
+}
+
+function hasEqualsEnum<E>({ isEquals }: Context<E>, enumList: CompiledValue[], checkedEnum: CompiledValue): boolean {
+  for (const searchedEnum of enumList) {
+    if (isEquals(searchedEnum, checkedEnum)) {
+      return true
+    }
+  }
+  return false
+}