Update to NPM version

ProjectSourceCode/node_modules/assert-options/dist/src/assert.d.ts

@@ -0,0 +1,10 @@
+import { IOptionsErrorHandler } from './handler';
+import { AssertFunc } from './types';
+/**
+ * Creates an options-assert function that uses specified error handler.
+ */
+export declare function createAssert(errHandler: IOptionsErrorHandler): AssertFunc;
+/**
+ * Default options-assert function.
+ */
+export declare const assertOptions: AssertFunc;

ProjectSourceCode/node_modules/assert-options/dist/src/assert.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertOptions = exports.createAssert = void 0;
+const handler_1 = require("./handler");
+const types_1 = require("./types");
+/**
+ * Creates an options-assert function that uses specified error handler.
+ */
+function createAssert(errHandler) {
+    return function (options, defaults) {
+        if (options !== null && options !== undefined && typeof options !== 'object') {
+            return errHandler.handle(types_1.OptionsError.invalidOptionsParam, { options, defaults });
+        }
+        const isArray = Array.isArray(defaults);
+        if (!isArray && (!defaults || typeof defaults !== 'object')) {
+            return errHandler.handle(types_1.OptionsError.invalidDefaultsParam, { options, defaults });
+        }
+        if (options) {
+            for (const key of Object.keys(options)) {
+                if ((isArray && defaults.indexOf(key) === -1) || (!isArray && !(key in defaults))) {
+                    return errHandler.handle(types_1.OptionsError.optionNotRecognized, { options, defaults, key });
+                }
+            }
+        }
+        else {
+            options = {};
+        }
+        if (!isArray) {
+            const defs = defaults;
+            for (const d of Object.keys(defs)) {
+                if (options[d] === undefined && defs[d] !== undefined) {
+                    options[d] = defs[d];
+                }
+            }
+        }
+        return options;
+    };
+}
+exports.createAssert = createAssert;
+/**
+ * Default options-assert function.
+ */
+exports.assertOptions = createAssert(new handler_1.DefaultErrorHandler());

ProjectSourceCode/node_modules/assert-options/dist/src/handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Protocol for handling options-related issues.
+ */
+import { IOptionsErrorContext, NamedValues, OptionsError } from './types';
+export interface IOptionsErrorHandler {
+    /**
+     * This method is normally expected to throw an error, based on "err"
+     */
+    handle(err: OptionsError, ctx: IOptionsErrorContext): NamedValues;
+}
+/**
+ * Default handler for options-related issues.
+ */
+export declare class DefaultErrorHandler implements IOptionsErrorHandler {
+    handle(err: OptionsError, ctx: IOptionsErrorContext): NamedValues;
+}

ProjectSourceCode/node_modules/assert-options/dist/src/handler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorHandler = void 0;
+/**
+ * Protocol for handling options-related issues.
+ */
+const types_1 = require("./types");
+/**
+ * Default handler for options-related issues.
+ */
+class DefaultErrorHandler {
+    handle(err, ctx) {
+        switch (err) {
+            case types_1.OptionsError.invalidOptionsParam:
+                throw new TypeError(`Invalid "options" parameter: ${JSON.stringify(ctx.options)}`);
+            case types_1.OptionsError.invalidDefaultsParam:
+                throw new TypeError(`Invalid "defaults" parameter: ${JSON.stringify(ctx.defaults)}`);
+            case types_1.OptionsError.optionNotRecognized:
+                throw new Error(`Option "${ctx.key}" is not recognized.`);
+            // istanbul ignore next:
+            default:
+                return ctx.options; // this will never happen
+        }
+    }
+}
+exports.DefaultErrorHandler = DefaultErrorHandler;

ProjectSourceCode/node_modules/assert-options/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { assertOptions, createAssert } from './assert';
+export { OptionsError, IOptionsErrorContext, NamedValues, AssertFunc } from './types';
+export { IOptionsErrorHandler, DefaultErrorHandler } from './handler';

ProjectSourceCode/node_modules/assert-options/dist/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorHandler = exports.OptionsError = exports.createAssert = exports.assertOptions = void 0;
+var assert_1 = require("./assert");
+Object.defineProperty(exports, "assertOptions", { enumerable: true, get: function () { return assert_1.assertOptions; } });
+Object.defineProperty(exports, "createAssert", { enumerable: true, get: function () { return assert_1.createAssert; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "OptionsError", { enumerable: true, get: function () { return types_1.OptionsError; } });
+var handler_1 = require("./handler");
+Object.defineProperty(exports, "DefaultErrorHandler", { enumerable: true, get: function () { return handler_1.DefaultErrorHandler; } });

ProjectSourceCode/node_modules/assert-options/dist/src/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * All errors that can occur inside an assert function.
+ */
+export declare enum OptionsError {
+    invalidOptionsParam = 0,
+    invalidDefaultsParam = 1,
+    optionNotRecognized = 2
+}
+/**
+ * Error-related context available for options-related issues.
+ */
+export interface IOptionsErrorContext {
+    options: any;
+    defaults: any;
+    key?: string;
+}
+/**
+ * Standard syntax for named values.
+ */
+export type NamedValues = {
+    [name: string]: any;
+};
+/**
+ * Assert function signature.
+ */
+export type AssertFunc = (options: NamedValues | null | undefined, defaults: NamedValues | string[]) => NamedValues;

ProjectSourceCode/node_modules/assert-options/dist/src/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionsError = void 0;
+/**
+ * All errors that can occur inside an assert function.
+ */
+var OptionsError;
+(function (OptionsError) {
+    OptionsError[OptionsError["invalidOptionsParam"] = 0] = "invalidOptionsParam";
+    OptionsError[OptionsError["invalidDefaultsParam"] = 1] = "invalidDefaultsParam";
+    OptionsError[OptionsError["optionNotRecognized"] = 2] = "optionNotRecognized";
+})(OptionsError = exports.OptionsError || (exports.OptionsError = {}));