@nocobase/plugin-workflow-javascript 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/node_modules/joi/lib/cache.js

@@ -0,0 +1,143 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const Clone = require('@hapi/hoek/lib/clone');
+
+const Common = require('./common');
+
+
+const internals = {
+    max: 1000,
+    supported: new Set(['undefined', 'boolean', 'number', 'string'])
+};
+
+
+exports.provider = {
+
+    provision(options) {
+
+        return new internals.Cache(options);
+    }
+};
+
+
+// Least Recently Used (LRU) Cache
+
+internals.Cache = class {
+
+    constructor(options = {}) {
+
+        Common.assertOptions(options, ['max']);
+        Assert(options.max === undefined || options.max && options.max > 0 && isFinite(options.max), 'Invalid max cache size');
+
+        this._max = options.max || internals.max;
+
+        this._map = new Map();                          // Map of nodes by key
+        this._list = new internals.List();              // List of nodes (most recently used in head)
+    }
+
+    get length() {
+
+        return this._map.size;
+    }
+
+    set(key, value) {
+
+        if (key !== null &&
+            !internals.supported.has(typeof key)) {
+
+            return;
+        }
+
+        let node = this._map.get(key);
+        if (node) {
+            node.value = value;
+            this._list.first(node);
+            return;
+        }
+
+        node = this._list.unshift({ key, value });
+        this._map.set(key, node);
+        this._compact();
+    }
+
+    get(key) {
+
+        const node = this._map.get(key);
+        if (node) {
+            this._list.first(node);
+            return Clone(node.value);
+        }
+    }
+
+    _compact() {
+
+        if (this._map.size > this._max) {
+            const node = this._list.pop();
+            this._map.delete(node.key);
+        }
+    }
+};
+
+
+internals.List = class {
+
+    constructor() {
+
+        this.tail = null;
+        this.head = null;
+    }
+
+    unshift(node) {
+
+        node.next = null;
+        node.prev = this.head;
+
+        if (this.head) {
+            this.head.next = node;
+        }
+
+        this.head = node;
+
+        if (!this.tail) {
+            this.tail = node;
+        }
+
+        return node;
+    }
+
+    first(node) {
+
+        if (node === this.head) {
+            return;
+        }
+
+        this._remove(node);
+        this.unshift(node);
+    }
+
+    pop() {
+
+        return this._remove(this.tail);
+    }
+
+    _remove(node) {
+
+        const { next, prev } = node;
+
+        next.prev = prev;
+
+        if (prev) {
+            prev.next = next;
+        }
+
+        if (node === this.tail) {
+            this.tail = next;
+        }
+
+        node.prev = null;
+        node.next = null;
+
+        return node;
+    }
+};

package/dist/node_modules/joi/lib/common.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const AssertError = require('@hapi/hoek/lib/error');
+
+const Pkg = require('../package.json');
+
+let Messages;
+let Schemas;
+
+
+const internals = {
+    isoDate: /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/
+};
+
+
+exports.version = Pkg.version;
+
+
+exports.defaults = {
+    abortEarly: true,
+    allowUnknown: false,
+    artifacts: false,
+    cache: true,
+    context: null,
+    convert: true,
+    dateFormat: 'iso',
+    errors: {
+        escapeHtml: false,
+        label: 'path',
+        language: null,
+        render: true,
+        stack: false,
+        wrap: {
+            label: '"',
+            array: '[]'
+        }
+    },
+    externals: true,
+    messages: {},
+    nonEnumerables: false,
+    noDefaults: false,
+    presence: 'optional',
+    skipFunctions: false,
+    stripUnknown: false,
+    warnings: false
+};
+
+
+exports.symbols = {
+    any: Symbol.for('@hapi/joi/schema'),            // Used to internally identify any-based types (shared with other joi versions)
+    arraySingle: Symbol('arraySingle'),
+    deepDefault: Symbol('deepDefault'),
+    errors: Symbol('errors'),
+    literal: Symbol('literal'),
+    override: Symbol('override'),
+    parent: Symbol('parent'),
+    prefs: Symbol('prefs'),
+    ref: Symbol('ref'),
+    template: Symbol('template'),
+    values: Symbol('values')
+};
+
+
+exports.assertOptions = function (options, keys, name = 'Options') {
+
+    Assert(options && typeof options === 'object' && !Array.isArray(options), 'Options must be of type object');
+    const unknownKeys = Object.keys(options).filter((k) => !keys.includes(k));
+    Assert(unknownKeys.length === 0, `${name} contain unknown keys: ${unknownKeys}`);
+};
+
+
+exports.checkPreferences = function (prefs) {
+
+    Schemas = Schemas || require('./schemas');
+
+    const result = Schemas.preferences.validate(prefs);
+
+    if (result.error) {
+        throw new AssertError([result.error.details[0].message]);
+    }
+};
+
+
+exports.compare = function (a, b, operator) {
+
+    switch (operator) {
+        case '=': return a === b;
+        case '>': return a > b;
+        case '<': return a < b;
+        case '>=': return a >= b;
+        case '<=': return a <= b;
+    }
+};
+
+
+exports.default = function (value, defaultValue) {
+
+    return value === undefined ? defaultValue : value;
+};
+
+
+exports.isIsoDate = function (date) {
+
+    return internals.isoDate.test(date);
+};
+
+
+exports.isNumber = function (value) {
+
+    return typeof value === 'number' && !isNaN(value);
+};
+
+
+exports.isResolvable = function (obj) {
+
+    if (!obj) {
+        return false;
+    }
+
+    return obj[exports.symbols.ref] || obj[exports.symbols.template];
+};
+
+
+exports.isSchema = function (schema, options = {}) {
+
+    const any = schema && schema[exports.symbols.any];
+    if (!any) {
+        return false;
+    }
+
+    Assert(options.legacy || any.version === exports.version, 'Cannot mix different versions of joi schemas');
+    return true;
+};
+
+
+exports.isValues = function (obj) {
+
+    return obj[exports.symbols.values];
+};
+
+
+exports.limit = function (value) {
+
+    return Number.isSafeInteger(value) && value >= 0;
+};
+
+
+exports.preferences = function (target, source) {
+
+    Messages = Messages || require('./messages');
+
+    target = target || {};
+    source = source || {};
+
+    const merged = Object.assign({}, target, source);
+    if (source.errors &&
+        target.errors) {
+
+        merged.errors = Object.assign({}, target.errors, source.errors);
+        merged.errors.wrap = Object.assign({}, target.errors.wrap, source.errors.wrap);
+    }
+
+    if (source.messages) {
+        merged.messages = Messages.compile(source.messages, target.messages);
+    }
+
+    delete merged[exports.symbols.prefs];
+    return merged;
+};
+
+
+exports.tryWithPath = function (fn, key, options = {}) {
+
+    try {
+        return fn();
+    }
+    catch (err) {
+        if (err.path !== undefined) {
+            err.path = key + '.' + err.path;
+        }
+        else {
+            err.path = key;
+        }
+
+        if (options.append) {
+            err.message = `${err.message} (${err.path})`;
+        }
+
+        throw err;
+    }
+};
+
+
+exports.validateArg = function (value, label, { assert, message }) {
+
+    if (exports.isSchema(assert)) {
+        const result = assert.validate(value);
+        if (!result.error) {
+            return;
+        }
+
+        return result.error.message;
+    }
+    else if (!assert(value)) {
+        return label ? `${label} ${message}` : message;
+    }
+};
+
+
+exports.verifyFlat = function (args, method) {
+
+    for (const arg of args) {
+        Assert(!Array.isArray(arg), 'Method no longer accepts array arguments:', method);
+    }
+};

package/dist/node_modules/joi/lib/compile.js

@@ -0,0 +1,283 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+
+const Common = require('./common');
+const Ref = require('./ref');
+
+
+const internals = {};
+
+
+exports.schema = function (Joi, config, options = {}) {
+
+    Common.assertOptions(options, ['appendPath', 'override']);
+
+    try {
+        return internals.schema(Joi, config, options);
+    }
+    catch (err) {
+        if (options.appendPath &&
+            err.path !== undefined) {
+
+            err.message = `${err.message} (${err.path})`;
+        }
+
+        throw err;
+    }
+};
+
+
+internals.schema = function (Joi, config, options) {
+
+    Assert(config !== undefined, 'Invalid undefined schema');
+
+    if (Array.isArray(config)) {
+        Assert(config.length, 'Invalid empty array schema');
+
+        if (config.length === 1) {
+            config = config[0];
+        }
+    }
+
+    const valid = (base, ...values) => {
+
+        if (options.override !== false) {
+            return base.valid(Joi.override, ...values);
+        }
+
+        return base.valid(...values);
+    };
+
+    if (internals.simple(config)) {
+        return valid(Joi, config);
+    }
+
+    if (typeof config === 'function') {
+        return Joi.custom(config);
+    }
+
+    Assert(typeof config === 'object', 'Invalid schema content:', typeof config);
+
+    if (Common.isResolvable(config)) {
+        return valid(Joi, config);
+    }
+
+    if (Common.isSchema(config)) {
+        return config;
+    }
+
+    if (Array.isArray(config)) {
+        for (const item of config) {
+            if (!internals.simple(item)) {
+                return Joi.alternatives().try(...config);
+            }
+        }
+
+        return valid(Joi, ...config);
+    }
+
+    if (config instanceof RegExp) {
+        return Joi.string().regex(config);
+    }
+
+    if (config instanceof Date) {
+        return valid(Joi.date(), config);
+    }
+
+    Assert(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+
+    return Joi.object().keys(config);
+};
+
+
+exports.ref = function (id, options) {
+
+    return Ref.isRef(id) ? id : Ref.create(id, options);
+};
+
+
+exports.compile = function (root, schema, options = {}) {
+
+    Common.assertOptions(options, ['legacy']);
+
+    // Compiled by any supported version
+
+    const any = schema && schema[Common.symbols.any];
+    if (any) {
+        Assert(options.legacy || any.version === Common.version, 'Cannot mix different versions of joi schemas:', any.version, Common.version);
+        return schema;
+    }
+
+    // Uncompiled root
+
+    if (typeof schema !== 'object' ||
+        !options.legacy) {
+
+        return exports.schema(root, schema, { appendPath: true });          // Will error if schema contains other versions
+    }
+
+    // Scan schema for compiled parts
+
+    const compiler = internals.walk(schema);
+    if (!compiler) {
+        return exports.schema(root, schema, { appendPath: true });
+    }
+
+    return compiler.compile(compiler.root, schema);
+};
+
+
+internals.walk = function (schema) {
+
+    if (typeof schema !== 'object') {
+        return null;
+    }
+
+    if (Array.isArray(schema)) {
+        for (const item of schema) {
+            const compiler = internals.walk(item);
+            if (compiler) {
+                return compiler;
+            }
+        }
+
+        return null;
+    }
+
+    const any = schema[Common.symbols.any];
+    if (any) {
+        return { root: schema[any.root], compile: any.compile };
+    }
+
+    Assert(Object.getPrototypeOf(schema) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+
+    for (const key in schema) {
+        const compiler = internals.walk(schema[key]);
+        if (compiler) {
+            return compiler;
+        }
+    }
+
+    return null;
+};
+
+
+internals.simple = function (value) {
+
+    return value === null || ['boolean', 'string', 'number'].includes(typeof value);
+};
+
+
+exports.when = function (schema, condition, options) {
+
+    if (options === undefined) {
+        Assert(condition && typeof condition === 'object', 'Missing options');
+
+        options = condition;
+        condition = Ref.create('.');
+    }
+
+    if (Array.isArray(options)) {
+        options = { switch: options };
+    }
+
+    Common.assertOptions(options, ['is', 'not', 'then', 'otherwise', 'switch', 'break']);
+
+    // Schema condition
+
+    if (Common.isSchema(condition)) {
+        Assert(options.is === undefined, '"is" can not be used with a schema condition');
+        Assert(options.not === undefined, '"not" can not be used with a schema condition');
+        Assert(options.switch === undefined, '"switch" can not be used with a schema condition');
+
+        return internals.condition(schema, { is: condition, then: options.then, otherwise: options.otherwise, break: options.break });
+    }
+
+    // Single condition
+
+    Assert(Ref.isRef(condition) || typeof condition === 'string', 'Invalid condition:', condition);
+    Assert(options.not === undefined || options.is === undefined, 'Cannot combine "is" with "not"');
+
+    if (options.switch === undefined) {
+        let rule = options;
+        if (options.not !== undefined) {
+            rule = { is: options.not, then: options.otherwise, otherwise: options.then, break: options.break };
+        }
+
+        let is = rule.is !== undefined ? schema.$_compile(rule.is) : schema.$_root.invalid(null, false, 0, '').required();
+        Assert(rule.then !== undefined || rule.otherwise !== undefined, 'options must have at least one of "then", "otherwise", or "switch"');
+        Assert(rule.break === undefined || rule.then === undefined || rule.otherwise === undefined, 'Cannot specify then, otherwise, and break all together');
+
+        if (options.is !== undefined &&
+            !Ref.isRef(options.is) &&
+            !Common.isSchema(options.is)) {
+
+            is = is.required();                     // Only apply required if this wasn't already a schema or a ref
+        }
+
+        return internals.condition(schema, { ref: exports.ref(condition), is, then: rule.then, otherwise: rule.otherwise, break: rule.break });
+    }
+
+    // Switch statement
+
+    Assert(Array.isArray(options.switch), '"switch" must be an array');
+    Assert(options.is === undefined, 'Cannot combine "switch" with "is"');
+    Assert(options.not === undefined, 'Cannot combine "switch" with "not"');
+    Assert(options.then === undefined, 'Cannot combine "switch" with "then"');
+
+    const rule = {
+        ref: exports.ref(condition),
+        switch: [],
+        break: options.break
+    };
+
+    for (let i = 0; i < options.switch.length; ++i) {
+        const test = options.switch[i];
+        const last = i === options.switch.length - 1;
+
+        Common.assertOptions(test, last ? ['is', 'then', 'otherwise'] : ['is', 'then']);
+
+        Assert(test.is !== undefined, 'Switch statement missing "is"');
+        Assert(test.then !== undefined, 'Switch statement missing "then"');
+
+        const item = {
+            is: schema.$_compile(test.is),
+            then: schema.$_compile(test.then)
+        };
+
+        if (!Ref.isRef(test.is) &&
+            !Common.isSchema(test.is)) {
+
+            item.is = item.is.required();           // Only apply required if this wasn't already a schema or a ref
+        }
+
+        if (last) {
+            Assert(options.otherwise === undefined || test.otherwise === undefined, 'Cannot specify "otherwise" inside and outside a "switch"');
+            const otherwise = options.otherwise !== undefined ? options.otherwise : test.otherwise;
+            if (otherwise !== undefined) {
+                Assert(rule.break === undefined, 'Cannot specify both otherwise and break');
+                item.otherwise = schema.$_compile(otherwise);
+            }
+        }
+
+        rule.switch.push(item);
+    }
+
+    return rule;
+};
+
+
+internals.condition = function (schema, condition) {
+
+    for (const key of ['then', 'otherwise']) {
+        if (condition[key] === undefined) {
+            delete condition[key];
+        }
+        else {
+            condition[key] = schema.$_compile(condition[key]);
+        }
+    }
+
+    return condition;
+};