@integration-app/react 0.1.2 → 0.1.3

package/node_modules/@sinclair/typebox/typebox.js

@@ -0,0 +1,345 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+TypeBox: JSON Schema Type Builder with Static Type Resolution for TypeScript
+
+The MIT License (MIT)
+
+Copyright (c) 2021 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = exports.TypeBuilder = exports.VoidKind = exports.UndefinedKind = exports.PromiseKind = exports.FunctionKind = exports.ConstructorKind = exports.RefKind = exports.AnyKind = exports.UnknownKind = exports.NullKind = exports.BooleanKind = exports.IntegerKind = exports.NumberKind = exports.StringKind = exports.LiteralKind = exports.EnumKind = exports.ArrayKind = exports.RecordKind = exports.ObjectKind = exports.TupleKind = exports.UnionKind = exports.IntersectKind = exports.KeyOfKind = exports.NamespaceKind = exports.ReadonlyModifier = exports.OptionalModifier = exports.ReadonlyOptionalModifier = void 0;
+// --------------------------------------------------------------------------
+// Modifiers
+// --------------------------------------------------------------------------
+exports.ReadonlyOptionalModifier = Symbol('ReadonlyOptionalModifier');
+exports.OptionalModifier = Symbol('OptionalModifier');
+exports.ReadonlyModifier = Symbol('ReadonlyModifier');
+// --------------------------------------------------------------------------
+// Schema Standard
+// --------------------------------------------------------------------------
+exports.NamespaceKind = Symbol('NamespaceKind');
+exports.KeyOfKind = Symbol('KeyOfKind');
+exports.IntersectKind = Symbol('IntersectKind');
+exports.UnionKind = Symbol('UnionKind');
+exports.TupleKind = Symbol('TupleKind');
+exports.ObjectKind = Symbol('ObjectKind');
+exports.RecordKind = Symbol('RecordKind');
+exports.ArrayKind = Symbol('ArrayKind');
+exports.EnumKind = Symbol('EnumKind');
+exports.LiteralKind = Symbol('LiteralKind');
+exports.StringKind = Symbol('StringKind');
+exports.NumberKind = Symbol('NumberKind');
+exports.IntegerKind = Symbol('IntegerKind');
+exports.BooleanKind = Symbol('BooleanKind');
+exports.NullKind = Symbol('NullKind');
+exports.UnknownKind = Symbol('UnknownKind');
+exports.AnyKind = Symbol('AnyKind');
+exports.RefKind = Symbol('RefKind');
+// --------------------------------------------------------------------------
+// Extended Schema Types
+// --------------------------------------------------------------------------
+exports.ConstructorKind = Symbol('ConstructorKind');
+exports.FunctionKind = Symbol('FunctionKind');
+exports.PromiseKind = Symbol('PromiseKind');
+exports.UndefinedKind = Symbol('UndefinedKind');
+exports.VoidKind = Symbol('VoidKind');
+// --------------------------------------------------------------------------
+// Utility
+// --------------------------------------------------------------------------
+function isObject(object) {
+    return typeof object === 'object' && object !== null && !Array.isArray(object);
+}
+function isArray(object) {
+    return typeof object === 'object' && object !== null && Array.isArray(object);
+}
+function clone(object) {
+    if (isObject(object))
+        return Object.keys(object).reduce((acc, key) => ({ ...acc, [key]: clone(object[key]) }), {});
+    if (isArray(object))
+        return object.map((item) => clone(item));
+    return object;
+}
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+class TypeBuilder {
+    schemas;
+    constructor() {
+        this.schemas = new Map();
+    }
+    /** `Standard` Modifies an object property to be both readonly and optional */
+    ReadonlyOptional(item) {
+        return { ...item, modifier: exports.ReadonlyOptionalModifier };
+    }
+    /** `Standard` Modifies an object property to be readonly */
+    Readonly(item) {
+        return { ...item, modifier: exports.ReadonlyModifier };
+    }
+    /** `Standard` Modifies an object property to be optional */
+    Optional(item) {
+        return { ...item, modifier: exports.OptionalModifier };
+    }
+    /** `Standard` Creates a type type */
+    Tuple(items, options = {}) {
+        const additionalItems = false;
+        const minItems = items.length;
+        const maxItems = items.length;
+        const schema = ((items.length > 0)
+            ? { ...options, kind: exports.TupleKind, type: 'array', items, additionalItems, minItems, maxItems }
+            : { ...options, kind: exports.TupleKind, type: 'array', minItems, maxItems });
+        return this.Store(schema);
+    }
+    /** `Standard` Creates an object type with the given properties */
+    Object(properties, options = {}) {
+        const property_names = Object.keys(properties);
+        const optional = property_names.filter(name => {
+            const candidate = properties[name];
+            return (candidate.modifier &&
+                (candidate.modifier === exports.OptionalModifier ||
+                    candidate.modifier === exports.ReadonlyOptionalModifier));
+        });
+        const required_names = property_names.filter(name => !optional.includes(name));
+        const required = (required_names.length > 0) ? required_names : undefined;
+        return this.Store(((required)
+            ? { ...options, kind: exports.ObjectKind, type: 'object', properties, required }
+            : { ...options, kind: exports.ObjectKind, type: 'object', properties }));
+    }
+    /** `Standard` Creates an intersect type. */
+    Intersect(items, options = {}) {
+        return this.Store({ ...options, kind: exports.IntersectKind, type: 'object', allOf: items });
+    }
+    /** `Standard` Creates a union type */
+    Union(items, options = {}) {
+        return this.Store({ ...options, kind: exports.UnionKind, anyOf: items });
+    }
+    /** `Standard` Creates an array type */
+    Array(items, options = {}) {
+        return this.Store({ ...options, kind: exports.ArrayKind, type: 'array', items });
+    }
+    /** `Standard` Creates an enum type from a TypeScript enum */
+    Enum(item, options = {}) {
+        const values = Object.keys(item).filter(key => isNaN(key)).map(key => item[key]);
+        const anyOf = values.map(value => typeof value === 'string' ? { type: 'string', const: value } : { type: 'number', const: value });
+        return this.Store({ ...options, kind: exports.EnumKind, anyOf });
+    }
+    /** `Standard` Creates a literal type. Supports string, number and boolean values only */
+    Literal(value, options = {}) {
+        return this.Store({ ...options, kind: exports.LiteralKind, const: value, type: typeof value });
+    }
+    /** `Standard` Creates a string type */
+    String(options = {}) {
+        return this.Store({ ...options, kind: exports.StringKind, type: 'string' });
+    }
+    /** `Standard` Creates a string type from a regular expression */
+    RegEx(regex, options = {}) {
+        return this.String({ ...options, pattern: regex.source });
+    }
+    /** `Standard` Creates a number type */
+    Number(options = {}) {
+        return this.Store({ ...options, kind: exports.NumberKind, type: 'number' });
+    }
+    /** `Standard` Creates an integer type */
+    Integer(options = {}) {
+        return this.Store({ ...options, kind: exports.IntegerKind, type: 'integer' });
+    }
+    /** `Standard` Creates a boolean type */
+    Boolean(options = {}) {
+        return this.Store({ ...options, kind: exports.BooleanKind, type: 'boolean' });
+    }
+    /** `Standard` Creates a null type */
+    Null(options = {}) {
+        return this.Store({ ...options, kind: exports.NullKind, type: 'null' });
+    }
+    /** `Standard` Creates an unknown type */
+    Unknown(options = {}) {
+        return this.Store({ ...options, kind: exports.UnknownKind });
+    }
+    /** `Standard` Creates an any type */
+    Any(options = {}) {
+        return this.Store({ ...options, kind: exports.AnyKind });
+    }
+    /** `Standard` Creates a record type */
+    Record(key, value, options = {}) {
+        const pattern = (() => {
+            switch (key.kind) {
+                case exports.UnionKind: return `^${key.anyOf.map((literal) => literal.const).join('|')}$`;
+                case exports.KeyOfKind: return `^${key.enum.join('|')}$`;
+                case exports.NumberKind: return '^(0|[1-9][0-9]*)$';
+                case exports.StringKind: return key.pattern ? key.pattern : '^.*$';
+                default: throw Error('Invalid Record Key');
+            }
+        })();
+        return this.Store({ ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } });
+    }
+    /** `Standard` Creates a keyof type from the given object */
+    KeyOf(object, options = {}) {
+        const source = this.Deref(object);
+        const keys = Object.keys(source.properties);
+        return this.Store({ ...options, kind: exports.KeyOfKind, type: 'string', enum: keys });
+    }
+    /** `Standard` Makes all properties in the given object type required */
+    Required(object, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = Object.keys(schema.properties);
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
+            switch (property.modifier) {
+                case exports.ReadonlyOptionalModifier:
+                    property.modifier = exports.ReadonlyModifier;
+                    break;
+                case exports.ReadonlyModifier:
+                    property.modifier = exports.ReadonlyModifier;
+                    break;
+                case exports.OptionalModifier:
+                    delete property.modifier;
+                    break;
+                default:
+                    delete property.modifier;
+                    break;
+            }
+        }
+        return this.Store(schema);
+    }
+    /** `Standard` Makes all properties in the given object type optional */
+    Partial(object, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        delete schema.required;
+        for (const key of Object.keys(schema.properties)) {
+            const property = schema.properties[key];
+            switch (property.modifier) {
+                case exports.ReadonlyOptionalModifier:
+                    property.modifier = exports.ReadonlyOptionalModifier;
+                    break;
+                case exports.ReadonlyModifier:
+                    property.modifier = exports.ReadonlyOptionalModifier;
+                    break;
+                case exports.OptionalModifier:
+                    property.modifier = exports.OptionalModifier;
+                    break;
+                default:
+                    property.modifier = exports.OptionalModifier;
+                    break;
+            }
+        }
+        return this.Store(schema);
+    }
+    /** `Standard` Picks property keys from the given object type */
+    Pick(object, keys, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
+            if (!keys.includes(key))
+                delete schema.properties[key];
+        }
+        return this.Store(schema);
+    }
+    /** `Standard` Omits property keys from the given object type */
+    Omit(object, keys, options = {}) {
+        const source = this.Deref(object);
+        const schema = { ...clone(source), ...options };
+        schema.required = schema.required ? schema.required.filter((key) => !keys.includes(key)) : undefined;
+        for (const key of Object.keys(schema.properties)) {
+            if (keys.includes(key))
+                delete schema.properties[key];
+        }
+        return this.Store(schema);
+    }
+    /** `Standard` Omits the `kind` and `modifier` properties from the underlying schema */
+    Strict(schema, options = {}) {
+        return JSON.parse(JSON.stringify({ ...options, ...schema }));
+    }
+    /** `Extended` Creates a constructor type */
+    Constructor(args, returns, options = {}) {
+        return this.Store({ ...options, kind: exports.ConstructorKind, type: 'constructor', arguments: args, returns });
+    }
+    /** `Extended` Creates a function type */
+    Function(args, returns, options = {}) {
+        return this.Store({ ...options, kind: exports.FunctionKind, type: 'function', arguments: args, returns });
+    }
+    /** `Extended` Creates a promise type */
+    Promise(item, options = {}) {
+        return this.Store({ ...options, type: 'promise', kind: exports.PromiseKind, item });
+    }
+    /** `Extended` Creates a undefined type */
+    Undefined(options = {}) {
+        return this.Store({ ...options, type: 'undefined', kind: exports.UndefinedKind });
+    }
+    /** `Extended` Creates a void type */
+    Void(options = {}) {
+        return this.Store({ ...options, type: 'void', kind: exports.VoidKind });
+    }
+    /** `Standard` Creates a namespace for a set of related types */
+    Namespace($defs, options = {}) {
+        return this.Store({ ...options, kind: exports.NamespaceKind, $defs });
+    }
+    Ref(...args) {
+        if (args.length === 2) {
+            const namespace = args[0];
+            const targetKey = args[1];
+            if (namespace.$id === undefined)
+                throw new Error(`Referenced namespace has no $id`);
+            if (!this.schemas.has(namespace.$id))
+                throw new Error(`Unable to locate namespace with $id '${namespace.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: `${namespace.$id}#/$defs/${targetKey}` });
+        }
+        else if (args.length === 1) {
+            const target = args[0];
+            if (target.$id === undefined)
+                throw new Error(`Referenced schema has no $id`);
+            if (!this.schemas.has(target.$id))
+                throw new Error(`Unable to locate schema with $id '${target.$id}'`);
+            return this.Store({ kind: exports.RefKind, $ref: target.$id });
+        }
+        else {
+            throw new Error('Type.Ref: Invalid arguments');
+        }
+    }
+    /** `Experimental` Creates a recursive type */
+    Rec(callback, options = {}) {
+        const $id = options.$id || '';
+        const self = callback({ $ref: `${$id}#/$defs/self` });
+        return this.Store({ ...options, $ref: `${$id}#/$defs/self`, $defs: { self } });
+    }
+    /** Conditionally stores and schema if it contains an $id and returns  */
+    Store(schema) {
+        const $schema = schema;
+        if (!$schema['$id'])
+            return $schema;
+        this.schemas.set($schema['$id'], $schema);
+        return $schema;
+    }
+    /** Conditionally dereferences a schema if RefKind. Otherwise return argument */
+    Deref(schema) {
+        const $schema = schema;
+        if ($schema['kind'] !== exports.RefKind)
+            return schema;
+        if (!this.schemas.has($schema['$ref']))
+            throw Error(`Unable to locate schema with $id '${$schema['$ref']}'`);
+        return this.Deref(this.schemas.get($schema['$ref']));
+    }
+}
+exports.TypeBuilder = TypeBuilder;
+exports.Type = new TypeBuilder();

package/node_modules/@types/node/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v14.
+
+### Additional Details
+ * Last updated: Wed, 26 Oct 2022 20:33:01 GMT
+ * Dependencies: none
+ * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Hoàng Văn Khải](https://github.com/KSXGitHub), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Seth Westphal](https://github.com/westy92), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [Bond](https://github.com/bondz), and [Linus Unnebäck](https://github.com/LinusU).

package/node_modules/@types/node/assert.d.ts

@@ -0,0 +1,128 @@
+declare module 'assert' {
+    /** An alias of `assert.ok()`. */
+    function assert(value: any, message?: string | Error): asserts value;
+    namespace assert {
+        class AssertionError extends Error {
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+            code: 'ERR_ASSERTION';
+
+            constructor(options?: {
+                /** If provided, the error message is set to this value. */
+                message?: string | undefined;
+                /** The `actual` property on the error instance. */
+                actual?: any;
+                /** The `expected` property on the error instance. */
+                expected?: any;
+                /** The `operator` property on the error instance. */
+                operator?: string | undefined;
+                /** If provided, the generated stack trace omits frames before this function. */
+                // tslint:disable-next-line:ban-types
+                stackStartFn?: Function | undefined;
+            });
+        }
+
+        class CallTracker {
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            report(): CallTrackerReportInformation[];
+            verify(): void;
+        }
+        interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
+
+        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+
+        function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: any,
+            expected: any,
+            message?: string | Error,
+            operator?: string,
+            // tslint:disable-next-line:ban-types
+            stackStartFn?: Function,
+        ): never;
+        function ok(value: any, message?: string | Error): asserts value;
+        /** @deprecated since v9.9.0 - use strictEqual() instead. */
+        function equal(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
+        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
+        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
+        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
+        function strictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepStrictEqual<T>(actual: any, expected: T, message?: string | Error): asserts actual is T;
+        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+
+        function throws(block: () => any, message?: string | Error): void;
+        function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
+        function doesNotThrow(block: () => any, message?: string | Error): void;
+        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
+
+        function ifError(value: any): asserts value is null | undefined;
+
+        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(
+            block: (() => Promise<any>) | Promise<any>,
+            error: AssertPredicate,
+            message?: string | Error,
+        ): Promise<void>;
+
+        function match(value: string, regExp: RegExp, message?: string | Error): void;
+        function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
+
+        const strict: Omit<
+            typeof assert,
+            | 'equal'
+            | 'notEqual'
+            | 'deepEqual'
+            | 'notDeepEqual'
+            | 'ok'
+            | 'strictEqual'
+            | 'deepStrictEqual'
+            | 'ifError'
+            | 'strict'
+        > & {
+            (value: any, message?: string | Error): asserts value;
+            equal: typeof strictEqual;
+            notEqual: typeof notStrictEqual;
+            deepEqual: typeof deepStrictEqual;
+            notDeepEqual: typeof notDeepStrictEqual;
+
+            // Mapped types and assertion functions are incompatible?
+            // TS2775: Assertions require every name in the call target
+            // to be declared with an explicit type annotation.
+            ok: typeof ok;
+            strictEqual: typeof strictEqual;
+            deepStrictEqual: typeof deepStrictEqual;
+            ifError: typeof ifError;
+            strict: typeof strict;
+        };
+    }
+
+    export = assert;
+}
+declare module 'node:assert' {
+    import assert = require('assert');
+    export = assert;
+}