@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/schema/types/link.js

@@ -0,0 +1,122 @@
+/**
+ * Derived from the upstream lib/types/link.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import * as Common from '../common.js';
+import * as Compile from '../compile.js';
+import * as Errors from '../errors.js';
+import Any from './any.js';
+const Link = 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 = 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) {
+        //The linked schema, of any type
+        return generate(schema, value, state, prefs);
+    },
+    rules: {
+        ref: {
+            method(ref) {
+                assert(!this.$_terms.link, 'Cannot reinitialize schema');
+                const compiled = Compile.ref(ref);
+                assert(compiled.type === 'value' || compiled.type === 'local', 'Invalid reference type:', compiled.type);
+                assert(compiled.type === 'local' || compiled.ancestor === 'root' || compiled.ancestor > 0, 'Link cannot reference itself');
+                const obj = this.clone();
+                obj.$_terms.link = [{ ref: compiled }];
+                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);
+        }
+    }
+});
+export default Link;
+//Helpers
+function generate(schema, value, state, prefs) {
+    const links = state.mainstay.links;
+    let linked = links.get(schema);
+    if (linked) {
+        return linked._generate(value, state, prefs).schema;
+    }
+    const ref = schema.$_terms.link[0].ref;
+    const { perspective, path } = perspectiveOf(ref, state);
+    assertLink(perspective, 'which is outside of schema boundaries', ref, schema, state, prefs);
+    try {
+        linked = path.length ? perspective.$_reach(path) : perspective;
+    }
+    catch {
+        assertLink(false, 'to non-existing schema', ref, schema, state, prefs);
+    }
+    assertLink(linked.type !== 'link', 'which is another link', ref, schema, state, prefs);
+    if (!schema._flags.relative) {
+        links.set(schema, linked);
+    }
+    return linked._generate(value, state, prefs).schema;
+}
+function perspectiveOf(ref, state) {
+    const schemas = state.schemas;
+    if (ref.type === 'local') {
+        //From parent to root
+        for (const { schema, key } of schemas) {
+            const entry = schema;
+            const id = entry._flags.id || key;
+            if (id === ref.path[0]) {
+                return { perspective: entry, path: ref.path.slice(1) };
+            }
+            if (entry.$_terms.shared) {
+                for (const shared of entry.$_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: schemas[schemas.length - 1].schema, path: ref.path };
+    }
+    return { perspective: schemas[ref.ancestor] && schemas[ref.ancestor].schema, path: ref.path };
+}
+function assertLink(condition, message, ref, schema, state, prefs) {
+    //Manual check to avoid generating error message on success
+    if (condition) {
+        return;
+    }
+    assert(false, `"${Errors.label(schema._flags, state, prefs, undefined)}" contains link reference "${ref.display}" ${message}`);
+}

package/dist/esm/lib/validation/engine/schema/types/number.js

@@ -0,0 +1,346 @@
+/**
+ * Derived from the upstream lib/types/number.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import Any from './any.js';
+import * as Common from '../common.js';
+/**
+ * The ranges of the integer types (the 64-bit types are limited to the safe integers of JavaScript)
+ */
+export const integerTypes = Object.freeze({
+    int8: [-128, 127],
+    uint8: [0, 255],
+    int16: [-32768, 32767],
+    uint16: [0, 65535],
+    int32: [-2147483648, 2147483647],
+    uint32: [0, 4294967295],
+    int64: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+    uint64: [0, Number.MAX_SAFE_INTEGER]
+});
+/**
+ * The largest finite 32-bit floating point number
+ */
+export const FLOAT_MAX = 3.4028234663852886e38;
+/**
+ * The rule of an integer type
+ * @param name
+ */
+function integerRule(name) {
+    const [min, max] = integerTypes[name];
+    return {
+        method() {
+            return this.$_addRule(name);
+        },
+        validate(value, helpers) {
+            if (!Number.isInteger(value))
+                return helpers.error('number.integer');
+            if (value < min || value > max)
+                return helpers.error(`number.${name}`, { min, max });
+            return value;
+        }
+    };
+}
+const numberRx = /^\s*[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:e([+-]?\d+))?\s*$/i;
+const precisionRx = /(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+const exponentialPartRegex = /[eE][+-]?\d+$/;
+const leadingSignAndZerosRegex = /^[+-]?(0*)?/;
+const dotRegex = /\./;
+const trailingZerosRegex = /0+$/;
+function 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)))));
+}
+const NumberType = Any.extend({
+    type: 'number',
+    flags: {
+        unsafe: { default: false }
+    },
+    coerce: {
+        from: 'string',
+        method(value, { schema, error }) {
+            let str = value;
+            const matches = str.match(numberRx);
+            if (!matches)
+                return;
+            str = str.trim();
+            const result = { value: parseFloat(str) };
+            //-0
+            if (result.value === 0)
+                result.value = 0;
+            if (!schema._flags.unsafe) {
+                if (str.match(/e/i)) {
+                    if (extractSignificantDigits(str) !== 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 !== normalizeDecimal(str)) {
+                        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) {
+                //This is conceptually equivalent to using toFixed but it should be much faster
+                const precision = Math.pow(10, rule.args.limit);
+                result.value = Math.round(result.value * precision) / precision;
+            }
+        }
+        //-0
+        if (result.value === 0)
+            result.value = 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'
+                }
+            ]
+        },
+        double: {
+            method() {
+                //Every finite number is a 64-bit floating point number: the rule declares the type, beyond the safe integers
+                return this.unsafe().$_addRule('double');
+            },
+            validate(value) {
+                return value;
+            }
+        },
+        float: {
+            method() {
+                //Floating point numbers are not limited to the safe integers
+                return this.unsafe().$_addRule('float');
+            },
+            validate(value, helpers) {
+                //The range of the 32-bit floating point numbers (the value is rounded to the nearest one when stored)
+                if (Math.abs(value) <= FLOAT_MAX)
+                    return value;
+                return helpers.error('number.float', { min: -FLOAT_MAX, max: FLOAT_MAX });
+            }
+        },
+        greater: {
+            method(limit) {
+                return this.$_addRule({ name: 'greater', method: 'compare', args: { limit }, operator: '>' });
+            }
+        },
+        int8: integerRule('int8'),
+        int16: integerRule('int16'),
+        int32: integerRule('int32'),
+        int64: integerRule('int64'),
+        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' ? decimalPlaces(base) : null;
+                //Math.pow(10, null) is 1, like upstream
+                const pfactor = Math.pow(10, baseDecimalPlace);
+                return this.$_addRule({
+                    name: 'multiple',
+                    args: {
+                        base,
+                        baseDecimalPlace,
+                        pfactor
+                    }
+                });
+            },
+            validate(value, helpers, { base, baseDecimalPlace, pfactor }, options) {
+                const valueDecimalPlace = 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(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}`);
+            }
+        },
+        uint8: integerRule('uint8'),
+        uint16: integerRule('uint16'),
+        uint32: integerRule('uint32'),
+        uint64: integerRule('uint64'),
+        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) {
+                return value.toString();
+            }
+        }
+    },
+    messages: {
+        'number.base': '{{#label}} must be a number',
+        'number.float': '{{#label}} must be a valid Float value (between {{#min}} and {{#max}})',
+        'number.greater': '{{#label}} must be greater than {{#limit}}',
+        'number.infinity': '{{#label}} cannot be infinity',
+        'number.int8': '{{#label}} must be a valid Int8 value (between -128 and 127)',
+        'number.int16': '{{#label}} must be a valid Int16 value (between -32768 and 32767)',
+        'number.int32': '{{#label}} must be a valid Int32 value (between -2147483648 and 2147483647)',
+        'number.int64': '{{#label}} must be a valid Int64 value (between -9007199254740991 and 9007199254740991, the safe integers of JavaScript)',
+        '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.uint8': '{{#label}} must be a valid UInt8 value (between 0 and 255)',
+        'number.uint16': '{{#label}} must be a valid UInt16 value (between 0 and 65535)',
+        'number.uint32': '{{#label}} must be a valid UInt32 value (between 0 and 4294967295)',
+        'number.uint64': '{{#label}} must be a valid UInt64 value (between 0 and 9007199254740991, the safe integers of JavaScript)',
+        'number.unsafe': '{{#label}} must be a safe number'
+    }
+});
+export default NumberType;
+//Helpers
+function extractSignificantDigits(value) {
+    return value
+        .replace(exponentialPartRegex, '')
+        .replace(dotRegex, '')
+        .replace(trailingZerosRegex, '')
+        .replace(leadingSignAndZerosRegex, '');
+}
+function normalizeDecimal(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/esm/lib/validation/engine/schema/types/object.js

@@ -0,0 +1,16 @@
+/**
+ * Derived from the upstream lib/types/object.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import Keys from './keys.js';
+const ObjectType = Keys.extend({
+    type: 'object',
+    cast: {
+        map: {
+            from: (value) => value && typeof value === 'object',
+            to(value) {
+                return new Map(Object.entries(value));
+            }
+        }
+    }
+});
+export default ObjectType;