@dineroregnskab/eslint-plugin-custom-rules 2.0.6 → 2.1.0

package/node_modules/@humanwhocodes/object-schema/src/object-schema.js

@@ -1,301 +0,0 @@
-/**
- * @filedescription Object Schema
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const { MergeStrategy } = require("./merge-strategy");
-const { ValidationStrategy } = require("./validation-strategy");
-
-//-----------------------------------------------------------------------------
-// Private
-//-----------------------------------------------------------------------------
-
-const strategies = Symbol("strategies");
-const requiredKeys = Symbol("requiredKeys");
-
-/**
- * Validates a schema strategy.
- * @param {string} name The name of the key this strategy is for.
- * @param {Object} strategy The strategy for the object key.
- * @param {boolean} [strategy.required=true] Whether the key is required.
- * @param {string[]} [strategy.requires] Other keys that are required when
- *      this key is present.
- * @param {Function} strategy.merge A method to call when merging two objects
- *      with the same key.
- * @param {Function} strategy.validate A method to call when validating an
- *      object with the key.
- * @returns {void}
- * @throws {Error} When the strategy is missing a name.
- * @throws {Error} When the strategy is missing a merge() method.
- * @throws {Error} When the strategy is missing a validate() method.
- */
-function validateDefinition(name, strategy) {
-
-    let hasSchema = false;
-    if (strategy.schema) {
-        if (typeof strategy.schema === "object") {
-            hasSchema = true;
-        } else {
-            throw new TypeError("Schema must be an object.");
-        }
-    }
-
-    if (typeof strategy.merge === "string") {
-        if (!(strategy.merge in MergeStrategy)) {
-            throw new TypeError(`Definition for key "${name}" missing valid merge strategy.`);
-        }
-    } else if (!hasSchema && typeof strategy.merge !== "function") {
-        throw new TypeError(`Definition for key "${name}" must have a merge property.`);
-    }
-
-    if (typeof strategy.validate === "string") {
-        if (!(strategy.validate in ValidationStrategy)) {
-            throw new TypeError(`Definition for key "${name}" missing valid validation strategy.`);
-        }
-    } else if (!hasSchema && typeof strategy.validate !== "function") {
-        throw new TypeError(`Definition for key "${name}" must have a validate() method.`);
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Errors
-//-----------------------------------------------------------------------------
-
-/**
- * Error when an unexpected key is found.
- */
-class UnexpectedKeyError extends Error {
-
-    /**
-     * Creates a new instance.
-     * @param {string} key The key that was unexpected. 
-     */
-    constructor(key) {
-        super(`Unexpected key "${key}" found.`);
-    }
-}
-
-/**
- * Error when a required key is missing.
- */
-class MissingKeyError extends Error {
-
-    /**
-     * Creates a new instance.
-     * @param {string} key The key that was missing. 
-     */
-    constructor(key) {
-        super(`Missing required key "${key}".`);
-    }
-}
-
-/**
- * Error when a key requires other keys that are missing.
- */
-class MissingDependentKeysError extends Error {
-
-    /**
-     * Creates a new instance.
-     * @param {string} key The key that was unexpected.
-     * @param {Array<string>} requiredKeys The keys that are required.
-     */
-    constructor(key, requiredKeys) {
-        super(`Key "${key}" requires keys "${requiredKeys.join("\", \"")}".`);
-    }
-}
-
-/**
- * Wrapper error for errors occuring during a merge or validate operation.
- */
-class WrapperError {
-
-    /**
-     * Creates a new instance.
-     * @param {string} key The object key causing the error. 
-     * @param {Error} source The source error. 
-     */
-    constructor(key, source) {
-        return Object.create(source, {
-            message: {
-                value: `Key "${key}": ` + source.message,
-                configurable: true,
-                writable: true,
-                enumerable: true
-            }
-        });
-    }
-}
-
-//-----------------------------------------------------------------------------
-// Main
-//-----------------------------------------------------------------------------
-
-/**
- * Represents an object validation/merging schema.
- */
-class ObjectSchema {
-
-    /**
-     * Creates a new instance.
-     */
-    constructor(definitions) {
-
-        if (!definitions) {
-            throw new Error("Schema definitions missing.");
-        }
-
-        /**
-         * Track all strategies in the schema by key.
-         * @type {Map}
-         * @property strategies
-         */
-        this[strategies] = new Map();
-
-        /**
-         * Separately track any keys that are required for faster validation.
-         * @type {Map}
-         * @property requiredKeys
-         */
-        this[requiredKeys] = new Map();
-
-        // add in all strategies
-        for (const key of Object.keys(definitions)) {
-            validateDefinition(key, definitions[key]);
-
-            // normalize merge and validate methods if subschema is present
-            if (typeof definitions[key].schema === "object") {
-                const schema = new ObjectSchema(definitions[key].schema);
-                definitions[key] = {
-                    ...definitions[key],
-                    merge(first = {}, second = {}) {
-                        return schema.merge(first, second);
-                    },
-                    validate(value) {
-                        ValidationStrategy.object(value);
-                        schema.validate(value);
-                    }
-                };
-            }
-
-            // normalize the merge method in case there's a string
-            if (typeof definitions[key].merge === "string") {
-                definitions[key] = {
-                    ...definitions[key],
-                    merge: MergeStrategy[definitions[key].merge]
-                };
-            };
-
-            // normalize the validate method in case there's a string
-            if (typeof definitions[key].validate === "string") {
-                definitions[key] = {
-                    ...definitions[key],
-                    validate: ValidationStrategy[definitions[key].validate]
-                };
-            };
-
-            this[strategies].set(key, definitions[key]);
-
-            if (definitions[key].required) {
-                this[requiredKeys].set(key, definitions[key]);
-            }
-        }
-    }
-
-    /**
-     * Determines if a strategy has been registered for the given object key.
-     * @param {string} key The object key to find a strategy for.
-     * @returns {boolean} True if the key has a strategy registered, false if not. 
-     */
-    hasKey(key) {
-        return this[strategies].has(key);
-    }
-
-    /**
-     * Merges objects together to create a new object comprised of the keys
-     * of the all objects. Keys are merged based on the each key's merge
-     * strategy.
-     * @param {...Object} objects The objects to merge.
-     * @returns {Object} A new object with a mix of all objects' keys.
-     * @throws {Error} If any object is invalid.
-     */
-    merge(...objects) {
-
-        // double check arguments
-        if (objects.length < 2) {
-            throw new TypeError("merge() requires at least two arguments.");
-        }
-
-        if (objects.some(object => (object == null || typeof object !== "object"))) {
-            throw new TypeError("All arguments must be objects.");
-        }
-
-        return objects.reduce((result, object) => {
-            
-            this.validate(object);
-            
-            for (const [key, strategy] of this[strategies]) {
-                try {
-                    if (key in result || key in object) {
-                        const value = strategy.merge.call(this, result[key], object[key]);
-                        if (value !== undefined) {
-                            result[key] = value;
-                        }
-                    }
-                } catch (ex) {
-                    throw new WrapperError(key, ex);
-                }
-            }
-            return result;
-        }, {});
-    }
-
-    /**
-     * Validates an object's keys based on the validate strategy for each key.
-     * @param {Object} object The object to validate.
-     * @returns {void}
-     * @throws {Error} When the object is invalid. 
-     */
-    validate(object) {
-
-        // check existing keys first
-        for (const key of Object.keys(object)) {
-
-            // check to see if the key is defined
-            if (!this.hasKey(key)) {
-                throw new UnexpectedKeyError(key);
-            }
-
-            // validate existing keys
-            const strategy = this[strategies].get(key);
-
-            // first check to see if any other keys are required
-            if (Array.isArray(strategy.requires)) {
-                if (!strategy.requires.every(otherKey => otherKey in object)) {
-                    throw new MissingDependentKeysError(key, strategy.requires);
-                }
-            }
-
-            // now apply remaining validation strategy
-            try {
-                strategy.validate.call(strategy, object[key]);
-            } catch (ex) {
-                throw new WrapperError(key, ex);
-            }
-        }
-
-        // ensure required keys aren't missing
-        for (const [key] of this[requiredKeys]) {
-            if (!(key in object)) {
-                throw new MissingKeyError(key);
-            }
-        }
-
-    }
-}
-
-exports.ObjectSchema = ObjectSchema;

package/node_modules/@humanwhocodes/object-schema/src/validation-strategy.js

@@ -1,102 +0,0 @@
-/**
- * @filedescription Validation Strategy
- */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Class
-//-----------------------------------------------------------------------------
-
-/**
- * Container class for several different validation strategies.
- */
-class ValidationStrategy {
-
-    /**
-     * Validates that a value is an array.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static array(value) {
-        if (!Array.isArray(value)) {
-            throw new TypeError("Expected an array.");
-        }
-    }
-
-    /**
-     * Validates that a value is a boolean.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static boolean(value) {
-        if (typeof value !== "boolean") {
-            throw new TypeError("Expected a Boolean.");
-        }
-    }
-
-    /**
-     * Validates that a value is a number.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static number(value) {
-        if (typeof value !== "number") {
-            throw new TypeError("Expected a number.");
-        }
-    }
-
-    /**
-     * Validates that a value is a object.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static object(value) {
-        if (!value || typeof value !== "object") {
-            throw new TypeError("Expected an object.");
-        }
-    }
-
-    /**
-     * Validates that a value is a object or null.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static "object?"(value) {
-        if (typeof value !== "object") {
-            throw new TypeError("Expected an object or null.");
-        }
-    }
-
-    /**
-     * Validates that a value is a string.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static string(value) {
-        if (typeof value !== "string") {
-            throw new TypeError("Expected a string.");
-        }
-    }
-
-    /**
-     * Validates that a value is a non-empty string.
-     * @param {*} value The value to validate.
-     * @returns {void}
-     * @throws {TypeError} If the value is invalid. 
-     */
-    static "string!"(value) {
-        if (typeof value !== "string" || value.length === 0) {
-            throw new TypeError("Expected a non-empty string.");
-        }
-    }
-
-}
-
-exports.ValidationStrategy = ValidationStrategy;

package/node_modules/@humanwhocodes/object-schema/tests/merge-strategy.js

@@ -1,66 +0,0 @@
-/**
- * @filedescription Merge Strategy Tests
- */
-/* global it, describe, beforeEach */
-
-"use strict";
-
-//-----------------------------------------------------------------------------
-// Requirements
-//-----------------------------------------------------------------------------
-
-const assert = require("chai").assert;
-const { MergeStrategy } = require("../src/");
-
-//-----------------------------------------------------------------------------
-// Class
-//-----------------------------------------------------------------------------
-
-describe("MergeStrategy", () => {
-
-
-    describe("overwrite()", () => {
-
-        it("should overwrite the first value with the second when the second is defined", () => {
-            const result = MergeStrategy.overwrite(1, 2);
-            assert.strictEqual(result, 2);
-        });
-
-        it("should overwrite the first value with the second when the second is undefined", () => {
-            const result = MergeStrategy.overwrite(1, undefined);
-            assert.strictEqual(result, undefined);
-        });
-
-    });
-
-    describe("replace()", () => {
-
-        it("should overwrite the first value with the second when the second is defined", () => {
-            const result = MergeStrategy.replace(1, 2);
-            assert.strictEqual(result, 2);
-        });
-
-        it("should return the first value when the second is undefined", () => {
-            const result = MergeStrategy.replace(1, undefined);
-            assert.strictEqual(result, 1);
-        });
-
-    });
-
-    describe("assign()", () => {
-
-        it("should merge properties from two objects when called", () => {
-
-            const object1 = { foo: 1, bar: 3 };
-            const object2 = { foo: 2 };            
-            
-            const result = MergeStrategy.assign(object1, object2);
-            assert.deepStrictEqual(result, {
-                foo: 2,
-                bar: 3
-            });
-        });
-
-    });
-
-});