@nocobase/plugin-flow-engine 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/node_modules/ajv/dist/compile/validate/subschema.d.ts

@@ -0,0 +1,47 @@
+import type { AnySchema } from "../../types";
+import type { SchemaObjCxt } from "..";
+import { Code, Name } from "../codegen";
+import { Type } from "../util";
+import type { JSONType } from "../rules";
+export interface SubschemaContext {
+    schema: AnySchema;
+    schemaPath: Code;
+    errSchemaPath: string;
+    topSchemaRef?: Code;
+    errorPath?: Code;
+    dataLevel?: number;
+    dataTypes?: JSONType[];
+    data?: Name;
+    parentData?: Name;
+    parentDataProperty?: Code | number;
+    dataNames?: Name[];
+    dataPathArr?: (Code | number)[];
+    propertyName?: Name;
+    jtdDiscriminator?: string;
+    jtdMetadata?: boolean;
+    compositeRule?: true;
+    createErrors?: boolean;
+    allErrors?: boolean;
+}
+export type SubschemaArgs = Partial<{
+    keyword: string;
+    schemaProp: string | number;
+    schema: AnySchema;
+    schemaPath: Code;
+    errSchemaPath: string;
+    topSchemaRef: Code;
+    data: Name | Code;
+    dataProp: Code | string | number;
+    dataTypes: JSONType[];
+    definedProperties: Set<string>;
+    propertyName: Name;
+    dataPropType: Type;
+    jtdDiscriminator: string;
+    jtdMetadata: boolean;
+    compositeRule: true;
+    createErrors: boolean;
+    allErrors: boolean;
+}>;
+export declare function getSubschema(it: SchemaObjCxt, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }: SubschemaArgs): SubschemaContext;
+export declare function extendSubschemaData(subschema: SubschemaContext, it: SchemaObjCxt, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }: SubschemaArgs): void;
+export declare function extendSubschemaMode(subschema: SubschemaContext, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }: SubschemaArgs): void;

package/dist/node_modules/ajv/dist/compile/validate/subschema.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
+const codegen_1 = require("../codegen");
+const util_1 = require("../util");
+function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
+    if (keyword !== undefined && schema !== undefined) {
+        throw new Error('both "keyword" and "schema" passed, only one allowed');
+    }
+    if (keyword !== undefined) {
+        const sch = it.schema[keyword];
+        return schemaProp === undefined
+            ? {
+                schema: sch,
+                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
+                errSchemaPath: `${it.errSchemaPath}/${keyword}`,
+            }
+            : {
+                schema: sch[schemaProp],
+                schemaPath: (0, codegen_1._) `${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
+                errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`,
+            };
+    }
+    if (schema !== undefined) {
+        if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
+            throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
+        }
+        return {
+            schema,
+            schemaPath,
+            topSchemaRef,
+            errSchemaPath,
+        };
+    }
+    throw new Error('either "keyword" or "schema" must be passed');
+}
+exports.getSubschema = getSubschema;
+function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
+    if (data !== undefined && dataProp !== undefined) {
+        throw new Error('both "data" and "dataProp" passed, only one allowed');
+    }
+    const { gen } = it;
+    if (dataProp !== undefined) {
+        const { errorPath, dataPathArr, opts } = it;
+        const nextData = gen.let("data", (0, codegen_1._) `${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true);
+        dataContextProps(nextData);
+        subschema.errorPath = (0, codegen_1.str) `${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+        subschema.parentDataProperty = (0, codegen_1._) `${dataProp}`;
+        subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
+    }
+    if (data !== undefined) {
+        const nextData = data instanceof codegen_1.Name ? data : gen.let("data", data, true); // replaceable if used once?
+        dataContextProps(nextData);
+        if (propertyName !== undefined)
+            subschema.propertyName = propertyName;
+        // TODO something is possibly wrong here with not changing parentDataProperty and not appending dataPathArr
+    }
+    if (dataTypes)
+        subschema.dataTypes = dataTypes;
+    function dataContextProps(_nextData) {
+        subschema.data = _nextData;
+        subschema.dataLevel = it.dataLevel + 1;
+        subschema.dataTypes = [];
+        it.definedProperties = new Set();
+        subschema.parentData = it.data;
+        subschema.dataNames = [...it.dataNames, _nextData];
+    }
+}
+exports.extendSubschemaData = extendSubschemaData;
+function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
+    if (compositeRule !== undefined)
+        subschema.compositeRule = compositeRule;
+    if (createErrors !== undefined)
+        subschema.createErrors = createErrors;
+    if (allErrors !== undefined)
+        subschema.allErrors = allErrors;
+    subschema.jtdDiscriminator = jtdDiscriminator; // not inherited
+    subschema.jtdMetadata = jtdMetadata; // not inherited
+}
+exports.extendSubschemaMode = extendSubschemaMode;
+//# sourceMappingURL=subschema.js.map

package/dist/node_modules/ajv/dist/core.d.ts

@@ -0,0 +1,174 @@
+export { Format, FormatDefinition, AsyncFormatDefinition, KeywordDefinition, KeywordErrorDefinition, CodeKeywordDefinition, MacroKeywordDefinition, FuncKeywordDefinition, Vocabulary, Schema, SchemaObject, AnySchemaObject, AsyncSchema, AnySchema, ValidateFunction, AsyncValidateFunction, AnyValidateFunction, ErrorObject, ErrorNoParams, } from "./types";
+export { SchemaCxt, SchemaObjCxt } from "./compile";
+export interface Plugin<Opts> {
+    (ajv: Ajv, options?: Opts): Ajv;
+    [prop: string]: any;
+}
+export { KeywordCxt } from "./compile/validate";
+export { DefinedError } from "./vocabularies/errors";
+export { JSONType } from "./compile/rules";
+export { JSONSchemaType } from "./types/json-schema";
+export { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
+export { _, str, stringify, nil, Name, Code, CodeGen, CodeGenOptions } from "./compile/codegen";
+import type { Schema, AnySchema, AnySchemaObject, SchemaObject, AsyncSchema, Vocabulary, KeywordDefinition, AddedKeywordDefinition, AnyValidateFunction, ValidateFunction, AsyncValidateFunction, ErrorObject, Format, AddedFormat, RegExpEngine, UriResolver } from "./types";
+import type { JSONSchemaType } from "./types/json-schema";
+import type { JTDSchemaType, SomeJTDSchemaType, JTDDataType } from "./types/jtd-schema";
+import ValidationError from "./runtime/validation_error";
+import MissingRefError from "./compile/ref_error";
+import { ValidationRules } from "./compile/rules";
+import { SchemaEnv } from "./compile";
+import { Code, ValueScope } from "./compile/codegen";
+export type Options = CurrentOptions & DeprecatedOptions;
+export interface CurrentOptions {
+    strict?: boolean | "log";
+    strictSchema?: boolean | "log";
+    strictNumbers?: boolean | "log";
+    strictTypes?: boolean | "log";
+    strictTuples?: boolean | "log";
+    strictRequired?: boolean | "log";
+    allowMatchingProperties?: boolean;
+    allowUnionTypes?: boolean;
+    validateFormats?: boolean;
+    $data?: boolean;
+    allErrors?: boolean;
+    verbose?: boolean;
+    discriminator?: boolean;
+    unicodeRegExp?: boolean;
+    timestamp?: "string" | "date";
+    parseDate?: boolean;
+    allowDate?: boolean;
+    specialNumbers?: "fast" | "null";
+    $comment?: true | ((comment: string, schemaPath?: string, rootSchema?: AnySchemaObject) => unknown);
+    formats?: {
+        [Name in string]?: Format;
+    };
+    keywords?: Vocabulary;
+    schemas?: AnySchema[] | {
+        [Key in string]?: AnySchema;
+    };
+    logger?: Logger | false;
+    loadSchema?: (uri: string) => Promise<AnySchemaObject>;
+    removeAdditional?: boolean | "all" | "failing";
+    useDefaults?: boolean | "empty";
+    coerceTypes?: boolean | "array";
+    next?: boolean;
+    unevaluated?: boolean;
+    dynamicRef?: boolean;
+    schemaId?: "id" | "$id";
+    jtd?: boolean;
+    meta?: SchemaObject | boolean;
+    defaultMeta?: string | AnySchemaObject;
+    validateSchema?: boolean | "log";
+    addUsedSchema?: boolean;
+    inlineRefs?: boolean | number;
+    passContext?: boolean;
+    loopRequired?: number;
+    loopEnum?: number;
+    ownProperties?: boolean;
+    multipleOfPrecision?: number;
+    int32range?: boolean;
+    messages?: boolean;
+    code?: CodeOptions;
+    uriResolver?: UriResolver;
+}
+export interface CodeOptions {
+    es5?: boolean;
+    esm?: boolean;
+    lines?: boolean;
+    optimize?: boolean | number;
+    formats?: Code;
+    source?: boolean;
+    process?: (code: string, schema?: SchemaEnv) => string;
+    regExp?: RegExpEngine;
+}
+interface InstanceCodeOptions extends CodeOptions {
+    regExp: RegExpEngine;
+    optimize: number;
+}
+interface DeprecatedOptions {
+    /** @deprecated */
+    ignoreKeywordsWithRef?: boolean;
+    /** @deprecated */
+    jsPropertySyntax?: boolean;
+    /** @deprecated */
+    unicode?: boolean;
+}
+type RequiredInstanceOptions = {
+    [K in "strictSchema" | "strictNumbers" | "strictTypes" | "strictTuples" | "strictRequired" | "inlineRefs" | "loopRequired" | "loopEnum" | "meta" | "messages" | "schemaId" | "addUsedSchema" | "validateSchema" | "validateFormats" | "int32range" | "unicodeRegExp" | "uriResolver"]: NonNullable<Options[K]>;
+} & {
+    code: InstanceCodeOptions;
+};
+export type InstanceOptions = Options & RequiredInstanceOptions;
+export interface Logger {
+    log(...args: unknown[]): unknown;
+    warn(...args: unknown[]): unknown;
+    error(...args: unknown[]): unknown;
+}
+export default class Ajv {
+    opts: InstanceOptions;
+    errors?: ErrorObject[] | null;
+    logger: Logger;
+    readonly scope: ValueScope;
+    readonly schemas: {
+        [Key in string]?: SchemaEnv;
+    };
+    readonly refs: {
+        [Ref in string]?: SchemaEnv | string;
+    };
+    readonly formats: {
+        [Name in string]?: AddedFormat;
+    };
+    readonly RULES: ValidationRules;
+    readonly _compilations: Set<SchemaEnv>;
+    private readonly _loading;
+    private readonly _cache;
+    private readonly _metaOpts;
+    static ValidationError: typeof ValidationError;
+    static MissingRefError: typeof MissingRefError;
+    constructor(opts?: Options);
+    _addVocabularies(): void;
+    _addDefaultMetaSchema(): void;
+    defaultMeta(): string | AnySchemaObject | undefined;
+    validate(schema: Schema | string, data: unknown): boolean;
+    validate(schemaKeyRef: AnySchema | string, data: unknown): boolean | Promise<unknown>;
+    validate<T>(schema: Schema | JSONSchemaType<T> | string, data: unknown): data is T;
+    validate<T>(schema: JTDSchemaType<T>, data: unknown): data is T;
+    validate<N extends never, T extends SomeJTDSchemaType>(schema: T, data: unknown): data is JTDDataType<T>;
+    validate<T>(schema: AsyncSchema, data: unknown | T): Promise<T>;
+    validate<T>(schemaKeyRef: AnySchema | string, data: unknown): data is T | Promise<T>;
+    compile<T = unknown>(schema: Schema | JSONSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
+    compile<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): ValidateFunction<T>;
+    compile<N extends never, T extends SomeJTDSchemaType>(schema: T, _meta?: boolean): ValidateFunction<JTDDataType<T>>;
+    compile<T = unknown>(schema: AsyncSchema, _meta?: boolean): AsyncValidateFunction<T>;
+    compile<T = unknown>(schema: AnySchema, _meta?: boolean): AnyValidateFunction<T>;
+    compileAsync<T = unknown>(schema: SchemaObject | JSONSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
+    compileAsync<T = unknown>(schema: JTDSchemaType<T>, _meta?: boolean): Promise<ValidateFunction<T>>;
+    compileAsync<T = unknown>(schema: AsyncSchema, meta?: boolean): Promise<AsyncValidateFunction<T>>;
+    compileAsync<T = unknown>(schema: AnySchemaObject, meta?: boolean): Promise<AnyValidateFunction<T>>;
+    addSchema(schema: AnySchema | AnySchema[], // If array is passed, `key` will be ignored
+    key?: string, // Optional schema key. Can be passed to `validate` method instead of schema object or id/ref. One schema per instance can have empty `id` and `key`.
+    _meta?: boolean, // true if schema is a meta-schema. Used internally, addMetaSchema should be used instead.
+    _validateSchema?: boolean | "log"): Ajv;
+    addMetaSchema(schema: AnySchemaObject, key?: string, // schema key
+    _validateSchema?: boolean | "log"): Ajv;
+    validateSchema(schema: AnySchema, throwOrLogError?: boolean): boolean | Promise<unknown>;
+    getSchema<T = unknown>(keyRef: string): AnyValidateFunction<T> | undefined;
+    removeSchema(schemaKeyRef?: AnySchema | string | RegExp): Ajv;
+    addVocabulary(definitions: Vocabulary): Ajv;
+    addKeyword(kwdOrDef: string | KeywordDefinition, def?: KeywordDefinition): Ajv;
+    getKeyword(keyword: string): AddedKeywordDefinition | boolean;
+    removeKeyword(keyword: string): Ajv;
+    addFormat(name: string, format: Format): Ajv;
+    errorsText(errors?: ErrorObject[] | null | undefined, // optional array of validation errors
+    { separator, dataVar }?: ErrorsTextOptions): string;
+    $dataMetaSchema(metaSchema: AnySchemaObject, keywordsJsonPointers: string[]): AnySchemaObject;
+    private _removeAllSchemas;
+    _addSchema(schema: AnySchema, meta?: boolean, baseId?: string, validateSchema?: boolean | "log", addSchema?: boolean): SchemaEnv;
+    private _checkUnique;
+    private _compileSchemaEnv;
+    private _compileMetaSchema;
+}
+export interface ErrorsTextOptions {
+    separator?: string;
+    dataVar?: string;
+}