@nocobase/plugin-workflow-javascript 2.1.0-alpha.12 → 2.1.0-alpha.14

package/dist/node_modules/joi/lib/types/link.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+
+const Any = require('./any');
+const Common = require('../common');
+const Compile = require('../compile');
+const Errors = require('../errors');
+
+
+const internals = {};
+
+
+module.exports = Any.extend({
+
+    type: 'link',
+
+    properties: {
+        schemaChain: true
+    },
+
+    terms: {
+
+        link: { init: null, manifest: 'single', register: false }
+    },
+
+    args(schema, ref) {
+
+        return schema.ref(ref);
+    },
+
+    validate(value, { schema, state, prefs }) {
+
+        Assert(schema.$_terms.link, 'Uninitialized link schema');
+
+        const linked = internals.generate(schema, value, state, prefs);
+        const ref = schema.$_terms.link[0].ref;
+        return linked.$_validate(value, state.nest(linked, `link:${ref.display}:${linked.type}`), prefs);
+    },
+
+    generate(schema, value, state, prefs) {
+
+        return internals.generate(schema, value, state, prefs);
+    },
+
+    rules: {
+
+        ref: {
+            method(ref) {
+
+                Assert(!this.$_terms.link, 'Cannot reinitialize schema');
+
+                ref = Compile.ref(ref);
+
+                Assert(ref.type === 'value' || ref.type === 'local', 'Invalid reference type:', ref.type);
+                Assert(ref.type === 'local' || ref.ancestor === 'root' || ref.ancestor > 0, 'Link cannot reference itself');
+
+                const obj = this.clone();
+                obj.$_terms.link = [{ ref }];
+                return obj;
+            }
+        },
+
+        relative: {
+            method(enabled = true) {
+
+                return this.$_setFlag('relative', enabled);
+            }
+        }
+    },
+
+    overrides: {
+
+        concat(source) {
+
+            Assert(this.$_terms.link, 'Uninitialized link schema');
+            Assert(Common.isSchema(source), 'Invalid schema object');
+            Assert(source.type !== 'link', 'Cannot merge type link with another link');
+
+            const obj = this.clone();
+
+            if (!obj.$_terms.whens) {
+                obj.$_terms.whens = [];
+            }
+
+            obj.$_terms.whens.push({ concat: source });
+            return obj.$_mutateRebuild();
+        }
+    },
+
+    manifest: {
+
+        build(obj, desc) {
+
+            Assert(desc.link, 'Invalid link description missing link');
+            return obj.ref(desc.link);
+        }
+    }
+});
+
+
+// Helpers
+
+internals.generate = function (schema, value, state, prefs) {
+
+    let linked = state.mainstay.links.get(schema);
+    if (linked) {
+        return linked._generate(value, state, prefs).schema;
+    }
+
+    const ref = schema.$_terms.link[0].ref;
+    const { perspective, path } = internals.perspective(ref, state);
+    internals.assert(perspective, 'which is outside of schema boundaries', ref, schema, state, prefs);
+
+    try {
+        linked = path.length ? perspective.$_reach(path) : perspective;
+    }
+    catch (ignoreErr) {
+        internals.assert(false, 'to non-existing schema', ref, schema, state, prefs);
+    }
+
+    internals.assert(linked.type !== 'link', 'which is another link', ref, schema, state, prefs);
+
+    if (!schema._flags.relative) {
+        state.mainstay.links.set(schema, linked);
+    }
+
+    return linked._generate(value, state, prefs).schema;
+};
+
+
+internals.perspective = function (ref, state) {
+
+    if (ref.type === 'local') {
+        for (const { schema, key } of state.schemas) {                              // From parent to root
+            const id = schema._flags.id || key;
+            if (id === ref.path[0]) {
+                return { perspective: schema, path: ref.path.slice(1) };
+            }
+
+            if (schema.$_terms.shared) {
+                for (const shared of schema.$_terms.shared) {
+                    if (shared._flags.id === ref.path[0]) {
+                        return { perspective: shared, path: ref.path.slice(1) };
+                    }
+                }
+            }
+        }
+
+        return { perspective: null, path: null };
+    }
+
+    if (ref.ancestor === 'root') {
+        return { perspective: state.schemas[state.schemas.length - 1].schema, path: ref.path };
+    }
+
+    return { perspective: state.schemas[ref.ancestor] && state.schemas[ref.ancestor].schema, path: ref.path };
+};
+
+
+internals.assert = function (condition, message, ref, schema, state, prefs) {
+
+    if (condition) {                // Manual check to avoid generating error message on success
+        return;
+    }
+
+    Assert(false, `"${Errors.label(schema._flags, state, prefs)}" contains link reference "${ref.display}" ${message}`);
+};

package/dist/node_modules/joi/lib/types/number.js

@@ -0,0 +1,363 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+
+const Any = require('./any');
+const Common = require('../common');
+
+
+const internals = {
+    numberRx: /^\s*[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:e([+-]?\d+))?\s*$/i,
+    precisionRx: /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/,
+    exponentialPartRegex: /[eE][+-]?\d+$/,
+    leadingSignAndZerosRegex: /^[+-]?(0*)?/,
+    dotRegex: /\./,
+    trailingZerosRegex: /0+$/,
+    decimalPlaces(value) {
+
+        const str = value.toString();
+        const dindex = str.indexOf('.');
+        const eindex = str.indexOf('e');
+        return (
+            (dindex < 0 ? 0 : (eindex < 0 ? str.length : eindex) - dindex - 1) +
+            (eindex < 0 ? 0 : Math.max(0, -parseInt(str.slice(eindex + 1))))
+        );
+    }
+};
+
+
+module.exports = Any.extend({
+
+    type: 'number',
+
+    flags: {
+
+        unsafe: { default: false }
+    },
+
+    coerce: {
+        from: 'string',
+        method(value, { schema, error }) {
+
+            const matches = value.match(internals.numberRx);
+            if (!matches) {
+                return;
+            }
+
+            value = value.trim();
+            const result = { value: parseFloat(value) };
+
+            if (result.value === 0) {
+                result.value = 0;           // -0
+            }
+
+            if (!schema._flags.unsafe) {
+                if (value.match(/e/i)) {
+                    if (internals.extractSignificantDigits(value) !== internals.extractSignificantDigits(String(result.value))) {
+                        result.errors = error('number.unsafe');
+                        return result;
+                    }
+                }
+                else {
+                    const string = result.value.toString();
+                    if (string.match(/e/i)) {
+                        return result;
+                    }
+
+                    if (string !== internals.normalizeDecimal(value)) {
+                        result.errors = error('number.unsafe');
+                        return result;
+                    }
+                }
+            }
+
+            return result;
+        }
+    },
+
+    validate(value, { schema, error, prefs }) {
+
+        if (value === Infinity ||
+            value === -Infinity) {
+
+            return { value, errors: error('number.infinity') };
+        }
+
+        if (!Common.isNumber(value)) {
+            return { value, errors: error('number.base') };
+        }
+
+        const result = { value };
+
+        if (prefs.convert) {
+            const rule = schema.$_getRule('precision');
+            if (rule) {
+                const precision = Math.pow(10, rule.args.limit);                    // This is conceptually equivalent to using toFixed but it should be much faster
+                result.value = Math.round(result.value * precision) / precision;
+            }
+        }
+
+        if (result.value === 0) {
+            result.value = 0;           // -0
+        }
+
+        if (!schema._flags.unsafe &&
+            (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER)) {
+
+            result.errors = error('number.unsafe');
+        }
+
+        return result;
+    },
+
+    rules: {
+
+        compare: {
+            method: false,
+            validate(value, helpers, { limit }, { name, operator, args }) {
+
+                if (Common.compare(value, limit, operator)) {
+                    return value;
+                }
+
+                return helpers.error('number.' + name, { limit: args.limit, value });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: Common.isNumber,
+                    message: 'must be a number'
+                }
+            ]
+        },
+
+        greater: {
+            method(limit) {
+
+                return this.$_addRule({ name: 'greater', method: 'compare', args: { limit }, operator: '>' });
+            }
+        },
+
+        integer: {
+            method() {
+
+                return this.$_addRule('integer');
+            },
+            validate(value, helpers) {
+
+                if (Math.trunc(value) - value === 0) {
+                    return value;
+                }
+
+                return helpers.error('number.integer');
+            }
+        },
+
+        less: {
+            method(limit) {
+
+                return this.$_addRule({ name: 'less', method: 'compare', args: { limit }, operator: '<' });
+            }
+        },
+
+        max: {
+            method(limit) {
+
+                return this.$_addRule({ name: 'max', method: 'compare', args: { limit }, operator: '<=' });
+            }
+        },
+
+        min: {
+            method(limit) {
+
+                return this.$_addRule({ name: 'min', method: 'compare', args: { limit }, operator: '>=' });
+            }
+        },
+
+        multiple: {
+            method(base) {
+
+                const baseDecimalPlace = typeof base === 'number' ? internals.decimalPlaces(base) : null;
+                const pfactor = Math.pow(10, baseDecimalPlace);
+
+                return this.$_addRule({
+                    name: 'multiple',
+                    args: {
+                        base,
+                        baseDecimalPlace,
+                        pfactor
+                    }
+                });
+            },
+            validate(value, helpers, { base, baseDecimalPlace, pfactor }, options) {
+
+                const valueDecimalPlace = internals.decimalPlaces(value);
+
+                if (valueDecimalPlace > baseDecimalPlace) {
+                    // Value with higher precision than base can never be a multiple
+                    return helpers.error('number.multiple', { multiple: options.args.base, value });
+                }
+
+                return Math.round(pfactor * value) % Math.round(pfactor * base) === 0 ?
+                    value :
+                    helpers.error('number.multiple', { multiple: options.args.base, value });
+            },
+            args: [
+                {
+                    name: 'base',
+                    ref: true,
+                    assert: (value) => typeof value === 'number' && isFinite(value) && value > 0,
+                    message: 'must be a positive number'
+                },
+                'baseDecimalPlace',
+                'pfactor'
+            ],
+            multi: true
+        },
+
+        negative: {
+            method() {
+
+                return this.sign('negative');
+            }
+        },
+
+        port: {
+            method() {
+
+                return this.$_addRule('port');
+            },
+            validate(value, helpers) {
+
+                if (Number.isSafeInteger(value) &&
+                    value >= 0 &&
+                    value <= 65535) {
+
+                    return value;
+                }
+
+                return helpers.error('number.port');
+            }
+        },
+
+        positive: {
+            method() {
+
+                return this.sign('positive');
+            }
+        },
+
+        precision: {
+            method(limit) {
+
+                Assert(Number.isSafeInteger(limit), 'limit must be an integer');
+
+                return this.$_addRule({ name: 'precision', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+
+                const places = value.toString().match(internals.precisionRx);
+                const decimals = Math.max((places[1] ? places[1].length : 0) - (places[2] ? parseInt(places[2], 10) : 0), 0);
+                if (decimals <= limit) {
+                    return value;
+                }
+
+                return helpers.error('number.precision', { limit, value });
+            },
+            convert: true
+        },
+
+        sign: {
+            method(sign) {
+
+                Assert(['negative', 'positive'].includes(sign), 'Invalid sign', sign);
+
+                return this.$_addRule({ name: 'sign', args: { sign } });
+            },
+            validate(value, helpers, { sign }) {
+
+                if (sign === 'negative' && value < 0 ||
+                    sign === 'positive' && value > 0) {
+
+                    return value;
+                }
+
+                return helpers.error(`number.${sign}`);
+            }
+        },
+
+        unsafe: {
+            method(enabled = true) {
+
+                Assert(typeof enabled === 'boolean', 'enabled must be a boolean');
+
+                return this.$_setFlag('unsafe', enabled);
+            }
+        }
+    },
+
+    cast: {
+        string: {
+            from: (value) => typeof value === 'number',
+            to(value, helpers) {
+
+                return value.toString();
+            }
+        }
+    },
+
+    messages: {
+        'number.base': '{{#label}} must be a number',
+        'number.greater': '{{#label}} must be greater than {{#limit}}',
+        'number.infinity': '{{#label}} cannot be infinity',
+        'number.integer': '{{#label}} must be an integer',
+        'number.less': '{{#label}} must be less than {{#limit}}',
+        'number.max': '{{#label}} must be less than or equal to {{#limit}}',
+        'number.min': '{{#label}} must be greater than or equal to {{#limit}}',
+        'number.multiple': '{{#label}} must be a multiple of {{#multiple}}',
+        'number.negative': '{{#label}} must be a negative number',
+        'number.port': '{{#label}} must be a valid port',
+        'number.positive': '{{#label}} must be a positive number',
+        'number.precision': '{{#label}} must have no more than {{#limit}} decimal places',
+        'number.unsafe': '{{#label}} must be a safe number'
+    }
+});
+
+
+// Helpers
+
+internals.extractSignificantDigits = function (value) {
+
+    return value
+        .replace(internals.exponentialPartRegex, '')
+        .replace(internals.dotRegex, '')
+        .replace(internals.trailingZerosRegex, '')
+        .replace(internals.leadingSignAndZerosRegex, '');
+};
+
+
+internals.normalizeDecimal = function (str) {
+
+    str = str
+        // Remove leading plus signs
+        .replace(/^\+/, '')
+        // Remove trailing zeros if there is a decimal point and unecessary decimal points
+        .replace(/\.0*$/, '')
+        // Add a integer 0 if the numbers starts with a decimal point
+        .replace(/^(-?)\.([^\.]*)$/, '$10.$2')
+        // Remove leading zeros
+        .replace(/^(-?)0+([0-9])/, '$1$2');
+
+    if (str.includes('.') &&
+        str.endsWith('0')) {
+
+        str = str.replace(/0+$/, '');
+    }
+
+    if (str === '-0') {
+        return '0';
+    }
+
+    return str;
+};

package/dist/node_modules/joi/lib/types/object.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const Keys = require('./keys');
+
+
+const internals = {};
+
+
+module.exports = Keys.extend({
+
+    type: 'object',
+
+    cast: {
+        map: {
+            from: (value) => value && typeof value === 'object',
+            to(value, helpers) {
+
+                return new Map(Object.entries(value));
+            }
+        }
+    }
+});