@nocobase/plugin-flow-engine 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/node_modules/ajv/lib/vocabularies/applicator/additionalItems.ts

@@ -1,56 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, not, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util"
-
-export type AdditionalItemsError = ErrorObject<"additionalItems", {limit: number}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {len}}) => str`must NOT have more than ${len} items`,
-  params: ({params: {len}}) => _`{limit: ${len}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "additionalItems" as const,
-  type: "array",
-  schemaType: ["boolean", "object"],
-  before: "uniqueItems",
-  error,
-  code(cxt: KeywordCxt) {
-    const {parentSchema, it} = cxt
-    const {items} = parentSchema
-    if (!Array.isArray(items)) {
-      checkStrictMode(it, '"additionalItems" is ignored when "items" is not an array of schemas')
-      return
-    }
-    validateAdditionalItems(cxt, items)
-  },
-}
-
-export function validateAdditionalItems(cxt: KeywordCxt, items: AnySchema[]): void {
-  const {gen, schema, data, keyword, it} = cxt
-  it.items = true
-  const len = gen.const("len", _`${data}.length`)
-  if (schema === false) {
-    cxt.setParams({len: items.length})
-    cxt.pass(_`${len} <= ${items.length}`)
-  } else if (typeof schema == "object" && !alwaysValidSchema(it, schema)) {
-    const valid = gen.var("valid", _`${len} <= ${items.length}`) // TODO var
-    gen.if(not(valid), () => validateItems(valid))
-    cxt.ok(valid)
-  }
-
-  function validateItems(valid: Name): void {
-    gen.forRange("i", items.length, len, (i) => {
-      cxt.subschema({keyword, dataProp: i, dataPropType: Type.Num}, valid)
-      if (!it.allErrors) gen.if(not(valid), () => gen.break())
-    })
-  }
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/additionalProperties.ts

@@ -1,118 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  AddedKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import {allSchemaProperties, usePattern, isOwnProperty} from "../code"
-import {_, nil, or, not, Code, Name} from "../../compile/codegen"
-import N from "../../compile/names"
-import type {SubschemaArgs} from "../../compile/validate/subschema"
-import {alwaysValidSchema, schemaRefOrVal, Type} from "../../compile/util"
-
-export type AdditionalPropertiesError = ErrorObject<
-  "additionalProperties",
-  {additionalProperty: string},
-  AnySchema
->
-
-const error: KeywordErrorDefinition = {
-  message: "must NOT have additional properties",
-  params: ({params}) => _`{additionalProperty: ${params.additionalProperty}}`,
-}
-
-const def: CodeKeywordDefinition & AddedKeywordDefinition = {
-  keyword: "additionalProperties",
-  type: ["object"],
-  schemaType: ["boolean", "object"],
-  allowUndefined: true,
-  trackErrors: true,
-  error,
-  code(cxt) {
-    const {gen, schema, parentSchema, data, errsCount, it} = cxt
-    /* istanbul ignore if */
-    if (!errsCount) throw new Error("ajv implementation error")
-    const {allErrors, opts} = it
-    it.props = true
-    if (opts.removeAdditional !== "all" && alwaysValidSchema(it, schema)) return
-    const props = allSchemaProperties(parentSchema.properties)
-    const patProps = allSchemaProperties(parentSchema.patternProperties)
-    checkAdditionalProperties()
-    cxt.ok(_`${errsCount} === ${N.errors}`)
-
-    function checkAdditionalProperties(): void {
-      gen.forIn("key", data, (key: Name) => {
-        if (!props.length && !patProps.length) additionalPropertyCode(key)
-        else gen.if(isAdditional(key), () => additionalPropertyCode(key))
-      })
-    }
-
-    function isAdditional(key: Name): Code {
-      let definedProp: Code
-      if (props.length > 8) {
-        // TODO maybe an option instead of hard-coded 8?
-        const propsSchema = schemaRefOrVal(it, parentSchema.properties, "properties")
-        definedProp = isOwnProperty(gen, propsSchema as Code, key)
-      } else if (props.length) {
-        definedProp = or(...props.map((p) => _`${key} === ${p}`))
-      } else {
-        definedProp = nil
-      }
-      if (patProps.length) {
-        definedProp = or(definedProp, ...patProps.map((p) => _`${usePattern(cxt, p)}.test(${key})`))
-      }
-      return not(definedProp)
-    }
-
-    function deleteAdditional(key: Name): void {
-      gen.code(_`delete ${data}[${key}]`)
-    }
-
-    function additionalPropertyCode(key: Name): void {
-      if (opts.removeAdditional === "all" || (opts.removeAdditional && schema === false)) {
-        deleteAdditional(key)
-        return
-      }
-
-      if (schema === false) {
-        cxt.setParams({additionalProperty: key})
-        cxt.error()
-        if (!allErrors) gen.break()
-        return
-      }
-
-      if (typeof schema == "object" && !alwaysValidSchema(it, schema)) {
-        const valid = gen.name("valid")
-        if (opts.removeAdditional === "failing") {
-          applyAdditionalSchema(key, valid, false)
-          gen.if(not(valid), () => {
-            cxt.reset()
-            deleteAdditional(key)
-          })
-        } else {
-          applyAdditionalSchema(key, valid)
-          if (!allErrors) gen.if(not(valid), () => gen.break())
-        }
-      }
-    }
-
-    function applyAdditionalSchema(key: Name, valid: Name, errors?: false): void {
-      const subschema: SubschemaArgs = {
-        keyword: "additionalProperties",
-        dataProp: key,
-        dataPropType: Type.Str,
-      }
-      if (errors === false) {
-        Object.assign(subschema, {
-          compositeRule: true,
-          createErrors: false,
-          allErrors: false,
-        })
-      }
-      cxt.subschema(subschema, valid)
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/allOf.ts

@@ -1,22 +0,0 @@
-import type {CodeKeywordDefinition, AnySchema} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {alwaysValidSchema} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: "allOf",
-  schemaType: "array",
-  code(cxt: KeywordCxt) {
-    const {gen, schema, it} = cxt
-    /* istanbul ignore if */
-    if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-    const valid = gen.name("valid")
-    schema.forEach((sch: AnySchema, i: number) => {
-      if (alwaysValidSchema(it, sch)) return
-      const schCxt = cxt.subschema({keyword: "allOf", schemaProp: i}, valid)
-      cxt.ok(valid)
-      cxt.mergeEvaluated(schCxt)
-    })
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/anyOf.ts

@@ -1,14 +0,0 @@
-import type {CodeKeywordDefinition, ErrorNoParams, AnySchema} from "../../types"
-import {validateUnion} from "../code"
-
-export type AnyOfError = ErrorNoParams<"anyOf", AnySchema[]>
-
-const def: CodeKeywordDefinition = {
-  keyword: "anyOf",
-  schemaType: "array",
-  trackErrors: true,
-  code: validateUnion,
-  error: {message: "must match a schema in anyOf"},
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/contains.ts

@@ -1,109 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  KeywordErrorDefinition,
-  ErrorObject,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode, Type} from "../../compile/util"
-
-export type ContainsError = ErrorObject<
-  "contains",
-  {minContains: number; maxContains?: number},
-  AnySchema
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {min, max}}) =>
-    max === undefined
-      ? str`must contain at least ${min} valid item(s)`
-      : str`must contain at least ${min} and no more than ${max} valid item(s)`,
-  params: ({params: {min, max}}) =>
-    max === undefined ? _`{minContains: ${min}}` : _`{minContains: ${min}, maxContains: ${max}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "contains",
-  type: "array",
-  schemaType: ["object", "boolean"],
-  before: "uniqueItems",
-  trackErrors: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, parentSchema, data, it} = cxt
-    let min: number
-    let max: number | undefined
-    const {minContains, maxContains} = parentSchema
-    if (it.opts.next) {
-      min = minContains === undefined ? 1 : minContains
-      max = maxContains
-    } else {
-      min = 1
-    }
-    const len = gen.const("len", _`${data}.length`)
-    cxt.setParams({min, max})
-    if (max === undefined && min === 0) {
-      checkStrictMode(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`)
-      return
-    }
-    if (max !== undefined && min > max) {
-      checkStrictMode(it, `"minContains" > "maxContains" is always invalid`)
-      cxt.fail()
-      return
-    }
-    if (alwaysValidSchema(it, schema)) {
-      let cond = _`${len} >= ${min}`
-      if (max !== undefined) cond = _`${cond} && ${len} <= ${max}`
-      cxt.pass(cond)
-      return
-    }
-
-    it.items = true
-    const valid = gen.name("valid")
-    if (max === undefined && min === 1) {
-      validateItems(valid, () => gen.if(valid, () => gen.break()))
-    } else if (min === 0) {
-      gen.let(valid, true)
-      if (max !== undefined) gen.if(_`${data}.length > 0`, validateItemsWithCount)
-    } else {
-      gen.let(valid, false)
-      validateItemsWithCount()
-    }
-    cxt.result(valid, () => cxt.reset())
-
-    function validateItemsWithCount(): void {
-      const schValid = gen.name("_valid")
-      const count = gen.let("count", 0)
-      validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)))
-    }
-
-    function validateItems(_valid: Name, block: () => void): void {
-      gen.forRange("i", 0, len, (i) => {
-        cxt.subschema(
-          {
-            keyword: "contains",
-            dataProp: i,
-            dataPropType: Type.Num,
-            compositeRule: true,
-          },
-          _valid
-        )
-        block()
-      })
-    }
-
-    function checkLimits(count: Name): void {
-      gen.code(_`${count}++`)
-      if (max === undefined) {
-        gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true).break())
-      } else {
-        gen.if(_`${count} > ${max}`, () => gen.assign(valid, false).break())
-        if (min === 1) gen.assign(valid, true)
-        else gen.if(_`${count} >= ${min}`, () => gen.assign(valid, true))
-      }
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/dependencies.ts

@@ -1,112 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  SchemaMap,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str} from "../../compile/codegen"
-import {alwaysValidSchema} from "../../compile/util"
-import {checkReportMissingProp, checkMissingProp, reportMissingProp, propertyInData} from "../code"
-
-export type PropertyDependencies = {[K in string]?: string[]}
-
-export interface DependenciesErrorParams {
-  property: string
-  missingProperty: string
-  depsCount: number
-  deps: string // TODO change to string[]
-}
-
-type SchemaDependencies = SchemaMap
-
-export type DependenciesError = ErrorObject<
-  "dependencies",
-  DependenciesErrorParams,
-  {[K in string]?: string[] | AnySchema}
->
-
-export const error: KeywordErrorDefinition = {
-  message: ({params: {property, depsCount, deps}}) => {
-    const property_ies = depsCount === 1 ? "property" : "properties"
-    return str`must have ${property_ies} ${deps} when property ${property} is present`
-  },
-  params: ({params: {property, depsCount, deps, missingProperty}}) =>
-    _`{property: ${property},
-    missingProperty: ${missingProperty},
-    depsCount: ${depsCount},
-    deps: ${deps}}`, // TODO change to reference
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "dependencies",
-  type: "object",
-  schemaType: "object",
-  error,
-  code(cxt: KeywordCxt) {
-    const [propDeps, schDeps] = splitDependencies(cxt)
-    validatePropertyDeps(cxt, propDeps)
-    validateSchemaDeps(cxt, schDeps)
-  },
-}
-
-function splitDependencies({schema}: KeywordCxt): [PropertyDependencies, SchemaDependencies] {
-  const propertyDeps: PropertyDependencies = {}
-  const schemaDeps: SchemaDependencies = {}
-  for (const key in schema) {
-    if (key === "__proto__") continue
-    const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps
-    deps[key] = schema[key]
-  }
-  return [propertyDeps, schemaDeps]
-}
-
-export function validatePropertyDeps(
-  cxt: KeywordCxt,
-  propertyDeps: {[K in string]?: string[]} = cxt.schema
-): void {
-  const {gen, data, it} = cxt
-  if (Object.keys(propertyDeps).length === 0) return
-  const missing = gen.let("missing")
-  for (const prop in propertyDeps) {
-    const deps = propertyDeps[prop] as string[]
-    if (deps.length === 0) continue
-    const hasProperty = propertyInData(gen, data, prop, it.opts.ownProperties)
-    cxt.setParams({
-      property: prop,
-      depsCount: deps.length,
-      deps: deps.join(", "),
-    })
-    if (it.allErrors) {
-      gen.if(hasProperty, () => {
-        for (const depProp of deps) {
-          checkReportMissingProp(cxt, depProp)
-        }
-      })
-    } else {
-      gen.if(_`${hasProperty} && (${checkMissingProp(cxt, deps, missing)})`)
-      reportMissingProp(cxt, missing)
-      gen.else()
-    }
-  }
-}
-
-export function validateSchemaDeps(cxt: KeywordCxt, schemaDeps: SchemaMap = cxt.schema): void {
-  const {gen, data, keyword, it} = cxt
-  const valid = gen.name("valid")
-  for (const prop in schemaDeps) {
-    if (alwaysValidSchema(it, schemaDeps[prop] as AnySchema)) continue
-    gen.if(
-      propertyInData(gen, data, prop, it.opts.ownProperties),
-      () => {
-        const schCxt = cxt.subschema({keyword, schemaProp: prop}, valid)
-        cxt.mergeValidEvaluated(schCxt, valid)
-      },
-      () => gen.var(valid, true) // TODO var
-    )
-    cxt.ok(valid)
-  }
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/dependentSchemas.ts

@@ -1,11 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import {validateSchemaDeps} from "./dependencies"
-
-const def: CodeKeywordDefinition = {
-  keyword: "dependentSchemas",
-  type: "object",
-  schemaType: "object",
-  code: (cxt) => validateSchemaDeps(cxt),
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/if.ts

@@ -1,80 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  ErrorObject,
-  KeywordErrorDefinition,
-  AnySchema,
-} from "../../types"
-import type {SchemaObjCxt} from "../../compile"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, not, Name} from "../../compile/codegen"
-import {alwaysValidSchema, checkStrictMode} from "../../compile/util"
-
-export type IfKeywordError = ErrorObject<"if", {failingKeyword: string}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: ({params}) => str`must match "${params.ifClause}" schema`,
-  params: ({params}) => _`{failingKeyword: ${params.ifClause}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "if",
-  schemaType: ["object", "boolean"],
-  trackErrors: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, parentSchema, it} = cxt
-    if (parentSchema.then === undefined && parentSchema.else === undefined) {
-      checkStrictMode(it, '"if" without "then" and "else" is ignored')
-    }
-    const hasThen = hasSchema(it, "then")
-    const hasElse = hasSchema(it, "else")
-    if (!hasThen && !hasElse) return
-
-    const valid = gen.let("valid", true)
-    const schValid = gen.name("_valid")
-    validateIf()
-    cxt.reset()
-
-    if (hasThen && hasElse) {
-      const ifClause = gen.let("ifClause")
-      cxt.setParams({ifClause})
-      gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause))
-    } else if (hasThen) {
-      gen.if(schValid, validateClause("then"))
-    } else {
-      gen.if(not(schValid), validateClause("else"))
-    }
-
-    cxt.pass(valid, () => cxt.error(true))
-
-    function validateIf(): void {
-      const schCxt = cxt.subschema(
-        {
-          keyword: "if",
-          compositeRule: true,
-          createErrors: false,
-          allErrors: false,
-        },
-        schValid
-      )
-      cxt.mergeEvaluated(schCxt)
-    }
-
-    function validateClause(keyword: string, ifClause?: Name): () => void {
-      return () => {
-        const schCxt = cxt.subschema({keyword}, schValid)
-        gen.assign(valid, schValid)
-        cxt.mergeValidEvaluated(schCxt, valid)
-        if (ifClause) gen.assign(ifClause, _`${keyword}`)
-        else cxt.setParams({ifClause: keyword})
-      }
-    }
-  },
-}
-
-function hasSchema(it: SchemaObjCxt, keyword: string): boolean {
-  const schema = it.schema[keyword]
-  return schema !== undefined && !alwaysValidSchema(it, schema)
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/index.ts

@@ -1,53 +0,0 @@
-import type {ErrorNoParams, Vocabulary} from "../../types"
-import additionalItems, {AdditionalItemsError} from "./additionalItems"
-import prefixItems from "./prefixItems"
-import items from "./items"
-import items2020, {ItemsError} from "./items2020"
-import contains, {ContainsError} from "./contains"
-import dependencies, {DependenciesError} from "./dependencies"
-import propertyNames, {PropertyNamesError} from "./propertyNames"
-import additionalProperties, {AdditionalPropertiesError} from "./additionalProperties"
-import properties from "./properties"
-import patternProperties from "./patternProperties"
-import notKeyword, {NotKeywordError} from "./not"
-import anyOf, {AnyOfError} from "./anyOf"
-import oneOf, {OneOfError} from "./oneOf"
-import allOf from "./allOf"
-import ifKeyword, {IfKeywordError} from "./if"
-import thenElse from "./thenElse"
-
-export default function getApplicator(draft2020 = false): Vocabulary {
-  const applicator = [
-    // any
-    notKeyword,
-    anyOf,
-    oneOf,
-    allOf,
-    ifKeyword,
-    thenElse,
-    // object
-    propertyNames,
-    additionalProperties,
-    dependencies,
-    properties,
-    patternProperties,
-  ]
-  // array
-  if (draft2020) applicator.push(prefixItems, items2020)
-  else applicator.push(additionalItems, items)
-  applicator.push(contains)
-  return applicator
-}
-
-export type ApplicatorKeywordError =
-  | ErrorNoParams<"false schema">
-  | AdditionalItemsError
-  | ItemsError
-  | ContainsError
-  | AdditionalPropertiesError
-  | DependenciesError
-  | IfKeywordError
-  | AnyOfError
-  | OneOfError
-  | NotKeywordError
-  | PropertyNamesError

package/dist/node_modules/ajv/lib/vocabularies/applicator/items.ts

@@ -1,59 +0,0 @@
-import type {CodeKeywordDefinition, AnySchema, AnySchemaObject} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_} from "../../compile/codegen"
-import {alwaysValidSchema, mergeEvaluated, checkStrictMode} from "../../compile/util"
-import {validateArray} from "../code"
-
-const def: CodeKeywordDefinition = {
-  keyword: "items",
-  type: "array",
-  schemaType: ["object", "array", "boolean"],
-  before: "uniqueItems",
-  code(cxt: KeywordCxt) {
-    const {schema, it} = cxt
-    if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema)
-    it.items = true
-    if (alwaysValidSchema(it, schema)) return
-    cxt.ok(validateArray(cxt))
-  },
-}
-
-export function validateTuple(
-  cxt: KeywordCxt,
-  extraItems: string,
-  schArr: AnySchema[] = cxt.schema
-): void {
-  const {gen, parentSchema, data, keyword, it} = cxt
-  checkStrictTuple(parentSchema)
-  if (it.opts.unevaluated && schArr.length && it.items !== true) {
-    it.items = mergeEvaluated.items(gen, schArr.length, it.items)
-  }
-  const valid = gen.name("valid")
-  const len = gen.const("len", _`${data}.length`)
-  schArr.forEach((sch: AnySchema, i: number) => {
-    if (alwaysValidSchema(it, sch)) return
-    gen.if(_`${len} > ${i}`, () =>
-      cxt.subschema(
-        {
-          keyword,
-          schemaProp: i,
-          dataProp: i,
-        },
-        valid
-      )
-    )
-    cxt.ok(valid)
-  })
-
-  function checkStrictTuple(sch: AnySchemaObject): void {
-    const {opts, errSchemaPath} = it
-    const l = schArr.length
-    const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false)
-    if (opts.strictTuples && !fullTuple) {
-      const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`
-      checkStrictMode(it, msg, opts.strictTuples)
-    }
-  }
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/applicator/items2020.ts

@@ -1,36 +0,0 @@
-import type {
-  CodeKeywordDefinition,
-  KeywordErrorDefinition,
-  ErrorObject,
-  AnySchema,
-} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str} from "../../compile/codegen"
-import {alwaysValidSchema} from "../../compile/util"
-import {validateArray} from "../code"
-import {validateAdditionalItems} from "./additionalItems"
-
-export type ItemsError = ErrorObject<"items", {limit: number}, AnySchema>
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {len}}) => str`must NOT have more than ${len} items`,
-  params: ({params: {len}}) => _`{limit: ${len}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "items",
-  type: "array",
-  schemaType: ["object", "boolean"],
-  before: "uniqueItems",
-  error,
-  code(cxt: KeywordCxt) {
-    const {schema, parentSchema, it} = cxt
-    const {prefixItems} = parentSchema
-    it.items = true
-    if (alwaysValidSchema(it, schema)) return
-    if (prefixItems) validateAdditionalItems(cxt, prefixItems)
-    else cxt.ok(validateArray(cxt))
-  },
-}
-
-export default def