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

package/dist/node_modules/ajv/lib/vocabularies/validation/dependentRequired.ts

@@ -1,23 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject} from "../../types"
-import {
-  validatePropertyDeps,
-  error,
-  DependenciesErrorParams,
-  PropertyDependencies,
-} from "../applicator/dependencies"
-
-export type DependentRequiredError = ErrorObject<
-  "dependentRequired",
-  DependenciesErrorParams,
-  PropertyDependencies
->
-
-const def: CodeKeywordDefinition = {
-  keyword: "dependentRequired",
-  type: "object",
-  schemaType: "object",
-  error,
-  code: (cxt) => validatePropertyDeps(cxt),
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/enum.ts

@@ -1,54 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, or, Name, Code} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import equal from "../../runtime/equal"
-
-export type EnumError = ErrorObject<"enum", {allowedValues: any[]}, any[] | {$data: string}>
-
-const error: KeywordErrorDefinition = {
-  message: "must be equal to one of the allowed values",
-  params: ({schemaCode}) => _`{allowedValues: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "enum",
-  schemaType: "array",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, schemaCode, it} = cxt
-    if (!$data && schema.length === 0) throw new Error("enum must have non-empty array")
-    const useLoop = schema.length >= it.opts.loopEnum
-    let eql: Name | undefined
-    const getEql = (): Name => (eql ??= useFunc(gen, equal))
-
-    let valid: Code
-    if (useLoop || $data) {
-      valid = gen.let("valid")
-      cxt.block$data(valid, loopEnum)
-    } else {
-      /* istanbul ignore if */
-      if (!Array.isArray(schema)) throw new Error("ajv implementation error")
-      const vSchema = gen.const("vSchema", schemaCode)
-      valid = or(...schema.map((_x: unknown, i: number) => equalCode(vSchema, i)))
-    }
-    cxt.pass(valid)
-
-    function loopEnum(): void {
-      gen.assign(valid, false)
-      gen.forOf("v", schemaCode as Code, (v) =>
-        gen.if(_`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break())
-      )
-    }
-
-    function equalCode(vSchema: Name, i: number): Code {
-      const sch = schema[i]
-      return typeof sch === "object" && sch !== null
-        ? _`${getEql()}(${data}, ${vSchema}[${i}])`
-        : _`${data} === ${sch}`
-    }
-  },
-}
-
-export default def

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

@@ -1,49 +0,0 @@
-import type {ErrorObject, Vocabulary} from "../../types"
-import limitNumber, {LimitNumberError} from "./limitNumber"
-import multipleOf, {MultipleOfError} from "./multipleOf"
-import limitLength from "./limitLength"
-import pattern, {PatternError} from "./pattern"
-import limitProperties from "./limitProperties"
-import required, {RequiredError} from "./required"
-import limitItems from "./limitItems"
-import uniqueItems, {UniqueItemsError} from "./uniqueItems"
-import constKeyword, {ConstError} from "./const"
-import enumKeyword, {EnumError} from "./enum"
-
-const validation: Vocabulary = [
-  // number
-  limitNumber,
-  multipleOf,
-  // string
-  limitLength,
-  pattern,
-  // object
-  limitProperties,
-  required,
-  // array
-  limitItems,
-  uniqueItems,
-  // any
-  {keyword: "type", schemaType: ["string", "array"]},
-  {keyword: "nullable", schemaType: "boolean"},
-  constKeyword,
-  enumKeyword,
-]
-
-export default validation
-
-type LimitError = ErrorObject<
-  "maxItems" | "minItems" | "minProperties" | "maxProperties" | "minLength" | "maxLength",
-  {limit: number},
-  number | {$data: string}
->
-
-export type ValidationKeywordError =
-  | LimitError
-  | LimitNumberError
-  | MultipleOfError
-  | PatternError
-  | RequiredError
-  | UniqueItemsError
-  | ConstError
-  | EnumError

package/dist/node_modules/ajv/lib/vocabularies/validation/limitContains.ts

@@ -1,16 +0,0 @@
-import type {CodeKeywordDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {checkStrictMode} from "../../compile/util"
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxContains", "minContains"],
-  type: "array",
-  schemaType: "number",
-  code({keyword, parentSchema, it}: KeywordCxt) {
-    if (parentSchema.contains === undefined) {
-      checkStrictMode(it, `"${keyword}" without "contains" is ignored`)
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/limitItems.ts

@@ -1,26 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxItems" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} items`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxItems", "minItems"],
-  type: "array",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    const op = keyword === "maxItems" ? operators.GT : operators.LT
-    cxt.fail$data(_`${data}.length ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/limitLength.ts

@@ -1,30 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import ucs2length from "../../runtime/ucs2length"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxLength" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} characters`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxLength", "minLength"],
-  type: "string",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode, it} = cxt
-    const op = keyword === "maxLength" ? operators.GT : operators.LT
-    const len =
-      it.opts.unicode === false ? _`${data}.length` : _`${useFunc(cxt.gen, ucs2length)}(${data})`
-    cxt.fail$data(_`${len} ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/limitNumber.ts

@@ -1,42 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators, Code} from "../../compile/codegen"
-
-const ops = operators
-
-type Kwd = "maximum" | "minimum" | "exclusiveMaximum" | "exclusiveMinimum"
-
-type Comparison = "<=" | ">=" | "<" | ">"
-
-const KWDs: {[K in Kwd]: {okStr: Comparison; ok: Code; fail: Code}} = {
-  maximum: {okStr: "<=", ok: ops.LTE, fail: ops.GT},
-  minimum: {okStr: ">=", ok: ops.GTE, fail: ops.LT},
-  exclusiveMaximum: {okStr: "<", ok: ops.LT, fail: ops.GTE},
-  exclusiveMinimum: {okStr: ">", ok: ops.GT, fail: ops.LTE},
-}
-
-export type LimitNumberError = ErrorObject<
-  Kwd,
-  {limit: number; comparison: Comparison},
-  number | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({keyword, schemaCode}) => str`must be ${KWDs[keyword as Kwd].okStr} ${schemaCode}`,
-  params: ({keyword, schemaCode}) =>
-    _`{comparison: ${KWDs[keyword as Kwd].okStr}, limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: Object.keys(KWDs),
-  type: "number",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    cxt.fail$data(_`${data} ${KWDs[keyword as Kwd].fail} ${schemaCode} || isNaN(${data})`)
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/limitProperties.ts

@@ -1,26 +0,0 @@
-import type {CodeKeywordDefinition, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str, operators} from "../../compile/codegen"
-
-const error: KeywordErrorDefinition = {
-  message({keyword, schemaCode}) {
-    const comp = keyword === "maxProperties" ? "more" : "fewer"
-    return str`must NOT have ${comp} than ${schemaCode} properties`
-  },
-  params: ({schemaCode}) => _`{limit: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: ["maxProperties", "minProperties"],
-  type: "object",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {keyword, data, schemaCode} = cxt
-    const op = keyword === "maxProperties" ? operators.GT : operators.LT
-    cxt.fail$data(_`Object.keys(${data}).length ${op} ${schemaCode}`)
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/multipleOf.ts

@@ -1,34 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {_, str} from "../../compile/codegen"
-
-export type MultipleOfError = ErrorObject<
-  "multipleOf",
-  {multipleOf: number},
-  number | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({schemaCode}) => str`must be multiple of ${schemaCode}`,
-  params: ({schemaCode}) => _`{multipleOf: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "multipleOf",
-  type: "number",
-  schemaType: "number",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, schemaCode, it} = cxt
-    // const bdt = bad$DataType(schemaCode, <string>def.schemaType, $data)
-    const prec = it.opts.multipleOfPrecision
-    const res = gen.let("res")
-    const invalid = prec
-      ? _`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}`
-      : _`${res} !== parseInt(${res})`
-    cxt.fail$data(_`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`)
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/pattern.ts

@@ -1,39 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {usePattern} from "../code"
-import {useFunc} from "../../compile/util"
-import {_, str} from "../../compile/codegen"
-
-export type PatternError = ErrorObject<"pattern", {pattern: string}, string | {$data: string}>
-
-const error: KeywordErrorDefinition = {
-  message: ({schemaCode}) => str`must match pattern "${schemaCode}"`,
-  params: ({schemaCode}) => _`{pattern: ${schemaCode}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "pattern",
-  type: "string",
-  schemaType: "string",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, schemaCode, it} = cxt
-    const u = it.opts.unicodeRegExp ? "u" : ""
-    if ($data) {
-      const {regExp} = it.opts.code
-      const regExpCode = regExp.code === "new RegExp" ? _`new RegExp` : useFunc(gen, regExp)
-      const valid = gen.let("valid")
-      gen.try(
-        () => gen.assign(valid, _`${regExpCode}(${schemaCode}, ${u}).test(${data})`),
-        () => gen.assign(valid, false)
-      )
-      cxt.fail$data(_`!${valid}`)
-    } else {
-      const regExp = usePattern(cxt, schema)
-      cxt.fail$data(_`!${regExp}.test(${data})`)
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/required.ts

@@ -1,98 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {
-  checkReportMissingProp,
-  checkMissingProp,
-  reportMissingProp,
-  propertyInData,
-  noPropertyInData,
-} from "../code"
-import {_, str, nil, not, Name, Code} from "../../compile/codegen"
-import {checkStrictMode} from "../../compile/util"
-
-export type RequiredError = ErrorObject<
-  "required",
-  {missingProperty: string},
-  string[] | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {missingProperty}}) => str`must have required property '${missingProperty}'`,
-  params: ({params: {missingProperty}}) => _`{missingProperty: ${missingProperty}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "required",
-  type: "object",
-  schemaType: "array",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, schema, schemaCode, data, $data, it} = cxt
-    const {opts} = it
-    if (!$data && schema.length === 0) return
-    const useLoop = schema.length >= opts.loopRequired
-    if (it.allErrors) allErrorsMode()
-    else exitOnErrorMode()
-
-    if (opts.strictRequired) {
-      const props = cxt.parentSchema.properties
-      const {definedProperties} = cxt.it
-      for (const requiredKey of schema) {
-        if (props?.[requiredKey] === undefined && !definedProperties.has(requiredKey)) {
-          const schemaPath = it.schemaEnv.baseId + it.errSchemaPath
-          const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`
-          checkStrictMode(it, msg, it.opts.strictRequired)
-        }
-      }
-    }
-
-    function allErrorsMode(): void {
-      if (useLoop || $data) {
-        cxt.block$data(nil, loopAllRequired)
-      } else {
-        for (const prop of schema) {
-          checkReportMissingProp(cxt, prop)
-        }
-      }
-    }
-
-    function exitOnErrorMode(): void {
-      const missing = gen.let("missing")
-      if (useLoop || $data) {
-        const valid = gen.let("valid", true)
-        cxt.block$data(valid, () => loopUntilMissing(missing, valid))
-        cxt.ok(valid)
-      } else {
-        gen.if(checkMissingProp(cxt, schema, missing))
-        reportMissingProp(cxt, missing)
-        gen.else()
-      }
-    }
-
-    function loopAllRequired(): void {
-      gen.forOf("prop", schemaCode as Code, (prop) => {
-        cxt.setParams({missingProperty: prop})
-        gen.if(noPropertyInData(gen, data, prop, opts.ownProperties), () => cxt.error())
-      })
-    }
-
-    function loopUntilMissing(missing: Name, valid: Name): void {
-      cxt.setParams({missingProperty: missing})
-      gen.forOf(
-        missing,
-        schemaCode as Code,
-        () => {
-          gen.assign(valid, propertyInData(gen, data, missing, opts.ownProperties))
-          gen.if(not(valid), () => {
-            cxt.error()
-            gen.break()
-          })
-        },
-        nil
-      )
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/lib/vocabularies/validation/uniqueItems.ts

@@ -1,79 +0,0 @@
-import type {CodeKeywordDefinition, ErrorObject, KeywordErrorDefinition} from "../../types"
-import type {KeywordCxt} from "../../compile/validate"
-import {checkDataTypes, getSchemaTypes, DataType} from "../../compile/validate/dataType"
-import {_, str, Name} from "../../compile/codegen"
-import {useFunc} from "../../compile/util"
-import equal from "../../runtime/equal"
-
-export type UniqueItemsError = ErrorObject<
-  "uniqueItems",
-  {i: number; j: number},
-  boolean | {$data: string}
->
-
-const error: KeywordErrorDefinition = {
-  message: ({params: {i, j}}) =>
-    str`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
-  params: ({params: {i, j}}) => _`{i: ${i}, j: ${j}}`,
-}
-
-const def: CodeKeywordDefinition = {
-  keyword: "uniqueItems",
-  type: "array",
-  schemaType: "boolean",
-  $data: true,
-  error,
-  code(cxt: KeywordCxt) {
-    const {gen, data, $data, schema, parentSchema, schemaCode, it} = cxt
-    if (!$data && !schema) return
-    const valid = gen.let("valid")
-    const itemTypes = parentSchema.items ? getSchemaTypes(parentSchema.items) : []
-    cxt.block$data(valid, validateUniqueItems, _`${schemaCode} === false`)
-    cxt.ok(valid)
-
-    function validateUniqueItems(): void {
-      const i = gen.let("i", _`${data}.length`)
-      const j = gen.let("j")
-      cxt.setParams({i, j})
-      gen.assign(valid, true)
-      gen.if(_`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j))
-    }
-
-    function canOptimize(): boolean {
-      return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array")
-    }
-
-    function loopN(i: Name, j: Name): void {
-      const item = gen.name("item")
-      const wrongType = checkDataTypes(itemTypes, item, it.opts.strictNumbers, DataType.Wrong)
-      const indices = gen.const("indices", _`{}`)
-      gen.for(_`;${i}--;`, () => {
-        gen.let(item, _`${data}[${i}]`)
-        gen.if(wrongType, _`continue`)
-        if (itemTypes.length > 1) gen.if(_`typeof ${item} == "string"`, _`${item} += "_"`)
-        gen
-          .if(_`typeof ${indices}[${item}] == "number"`, () => {
-            gen.assign(j, _`${indices}[${item}]`)
-            cxt.error()
-            gen.assign(valid, false).break()
-          })
-          .code(_`${indices}[${item}] = ${i}`)
-      })
-    }
-
-    function loopN2(i: Name, j: Name): void {
-      const eql = useFunc(gen, equal)
-      const outer = gen.name("outer")
-      gen.label(outer).for(_`;${i}--;`, () =>
-        gen.for(_`${j} = ${i}; ${j}--;`, () =>
-          gen.if(_`${eql}(${data}[${i}], ${data}[${j}])`, () => {
-            cxt.error()
-            gen.assign(valid, false).break(outer)
-          })
-        )
-      )
-    }
-  },
-}
-
-export default def

package/dist/node_modules/ajv/package.json

@@ -1 +0,0 @@
-{"name":"ajv","version":"8.18.0","description":"Another JSON Schema Validator","main":"dist/ajv.js","types":"dist/ajv.d.ts","files":["lib/","dist/",".runkit_example.js"],"sideEffects":false,"scripts":{"eslint":"eslint \"lib/**/*.ts\" \"spec/**/*.*s\" --ignore-pattern spec/JSON-Schema-Test-Suite","prettier:write":"prettier --write \"./**/*.{json,yaml,js,ts}\"","prettier:check":"prettier --list-different \"./**/*.{json,yaml,js,ts}\"","test-spec":"cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register \"spec/**/*.spec.{ts,js}\" -R dot","test-codegen":"nyc cross-env TS_NODE_PROJECT=spec/tsconfig.json mocha -r ts-node/register 'spec/codegen.spec.ts' -R spec","test-debug":"npm run test-spec -- --inspect-brk","test-cov":"nyc npm run test-spec","rollup":"rm -rf bundle && rollup -c","bundle":"rm -rf bundle && node ./scripts/bundle.js ajv ajv7 ajv7 && node ./scripts/bundle.js 2019 ajv2019 ajv2019 && node ./scripts/bundle.js 2020 ajv2020 ajv2020 && node ./scripts/bundle.js jtd ajvJTD ajvJTD","build":"rm -rf dist && tsc && cp -r lib/refs dist && rm dist/refs/json-schema-2019-09/index.ts && rm dist/refs/json-schema-2020-12/index.ts && rm dist/refs/jtd-schema.ts","json-tests":"rm -rf spec/_json/*.js && node scripts/jsontests","test-karma":"karma start","test-browser":"rm -rf .browser && npm run bundle && scripts/prepare-tests && karma start","test-all":"npm run test-cov && if-node-version 12 npm run test-browser","test":"npm run json-tests && npm run prettier:check && npm run eslint && npm link && npm link --legacy-peer-deps ajv && npm run test-cov","test-ci":"AJV_FULL_TEST=true npm test","prepublish":"npm run build","benchmark":"npm i && npm run build && npm link && cd ./benchmark && npm link --legacy-peer-deps ajv && npm i && node ./jtd","docs:dev":"./scripts/prepare-site && vuepress dev docs","docs:build":"./scripts/prepare-site && vuepress build docs"},"nyc":{"exclude":["**/spec/**","node_modules"],"reporter":["lcov","text-summary"]},"repository":"ajv-validator/ajv","keywords":["JSON","schema","validator","validation","jsonschema","json-schema","json-schema-validator","json-schema-validation"],"author":"Evgeny Poberezkin","license":"MIT","bugs":"https://github.com/ajv-validator/ajv/issues","homepage":"https://ajv.js.org","runkitExampleFilename":".runkit_example.js","dependencies":{"fast-deep-equal":"^3.1.3","fast-uri":"^3.0.1","json-schema-traverse":"^1.0.0","require-from-string":"^2.0.2"},"devDependencies":{"@ajv-validator/config":"^0.5.0","@rollup/plugin-commonjs":"^25.0.7","@rollup/plugin-json":"^6.1.0","@rollup/plugin-node-resolve":"^15.2.3","@rollup/plugin-typescript":"^11.1.6","@types/chai":"^4.3.11","@types/mocha":"^10.0.6","@types/node":"^20.11.30","@types/require-from-string":"^1.2.3","@typescript-eslint/eslint-plugin":"^7.3.1","@typescript-eslint/parser":"^7.3.1","ajv-formats":"^3.0.1","browserify":"^17.0.0","chai":"^4.4.1","cross-env":"^7.0.3","dayjs":"^1.11.10","dayjs-plugin-utc":"^0.1.2","eslint":"^8.57.0","eslint-config-prettier":"^9.1.0","glob":"^10.3.10","husky":"^9.0.11","if-node-version":"^1.1.1","jimp":"^0.22.10","js-beautify":"^1.15.1","json-schema-test":"^2.0.0","karma":"^6.4.2","karma-chrome-launcher":"^3.2.0","karma-mocha":"^2.0.1","lint-staged":"^15.2.2","mocha":"^10.3.0","module-from-string":"^3.3.0","node-fetch":"^3.3.2","nyc":"^15.1.0","prettier":"3.0.3","re2":"^1.20.9","rollup":"^2.79.1","rollup-plugin-terser":"^7.0.2","ts-node":"^10.9.2","tsify":"^5.0.4","typescript":"5.3.3","uri-js":"^4.4.1"},"collective":{"type":"opencollective","url":"https://opencollective.com/ajv"},"funding":{"type":"github","url":"https://github.com/sponsors/epoberezkin"},"prettier":"@ajv-validator/config/prettierrc.json","husky":{"hooks":{"pre-commit":"lint-staged && npm test"}},"lint-staged":{"*.{json,yaml,js,ts}":"prettier --write"},"_lastModified":"2026-03-27T05:51:32.191Z"}

package/dist/server/flow-models/action-handlers.d.ts

@@ -1,26 +0,0 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-import { FlowSchemaService } from '../flow-schema-service';
-import { FlowModelValidationFacade } from './validation-facade';
-export declare function createFlowModelActions(options: {
-    flowSchemaService: FlowSchemaService;
-    validationFacade: FlowModelValidationFacade;
-}): {
-    findOne: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    duplicate: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    schema: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    schemas: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    schemaBundle: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    attach: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    move: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    save: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    ensure: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    mutate: (ctx: any, next: () => Promise<void>) => Promise<void>;
-    destroy: (ctx: any, next: () => Promise<void>) => Promise<void>;
-};