@integration-app/react 0.1.1 → 0.1.3

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

@@ -0,0 +1,56 @@
+declare module 'module' {
+    import { URL } from 'url';
+    namespace Module {
+        /**
+         * Updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports.
+         * It does not add or remove exported names from the ES Modules.
+         */
+        function syncBuiltinESMExports(): void;
+
+        function findSourceMap(path: string, error?: Error): SourceMap;
+        interface SourceMapPayload {
+            file: string;
+            version: number;
+            sources: string[];
+            sourcesContent: string[];
+            names: string[];
+            mappings: string;
+            sourceRoot: string;
+        }
+
+        interface SourceMapping {
+            generatedLine: number;
+            generatedColumn: number;
+            originalSource: string;
+            originalLine: number;
+            originalColumn: number;
+        }
+
+        class SourceMap {
+            readonly payload: SourceMapPayload;
+            constructor(payload: SourceMapPayload);
+            findEntry(line: number, column: number): SourceMapping;
+        }
+    }
+    interface Module extends NodeModule {}
+    class Module {
+        static runMain(): void;
+        static wrap(code: string): string;
+
+        /**
+         * @deprecated Deprecated since: v12.2.0. Please use createRequire() instead.
+         */
+        static createRequireFromPath(path: string): NodeRequire;
+        static createRequire(path: string | URL): NodeRequire;
+        static builtinModules: string[];
+
+        static Module: typeof Module;
+
+        constructor(id: string, parent?: Module);
+    }
+    export = Module;
+}
+declare module 'node:module' {
+    import module = require('module');
+    export = module;
+}

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

@@ -0,0 +1,308 @@
+declare module 'net' {
+    import * as stream from 'stream';
+    import EventEmitter = require('events');
+    import * as dns from 'dns';
+
+    type LookupFunction = (
+        hostname: string,
+        options: dns.LookupOneOptions,
+        callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void,
+    ) => void;
+
+    interface AddressInfo {
+        address: string;
+        family: string;
+        port: number;
+    }
+
+    interface SocketConstructorOpts {
+        fd?: number | undefined;
+        allowHalfOpen?: boolean | undefined;
+        readable?: boolean | undefined;
+        writable?: boolean | undefined;
+    }
+
+    interface OnReadOpts {
+        buffer: Uint8Array | (() => Uint8Array);
+        /**
+         * This function is called for every chunk of incoming data.
+         * Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer.
+         * Return false from this function to implicitly pause() the socket.
+         */
+        callback(bytesWritten: number, buf: Uint8Array): boolean;
+    }
+
+    interface ConnectOpts {
+        /**
+         * If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.
+         * Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will
+         * still be emitted as normal and methods like pause() and resume() will also behave as expected.
+         */
+        onread?: OnReadOpts | undefined;
+    }
+
+    interface TcpSocketConnectOpts extends ConnectOpts {
+        port: number;
+        host?: string | undefined;
+        localAddress?: string | undefined;
+        localPort?: number | undefined;
+        hints?: number | undefined;
+        family?: number | undefined;
+        lookup?: LookupFunction | undefined;
+    }
+
+    interface IpcSocketConnectOpts extends ConnectOpts {
+        path: string;
+    }
+
+    type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
+    type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
+
+    class Socket extends stream.Duplex {
+        constructor(options?: SocketConstructorOpts);
+
+        // Extended base methods
+        write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+        write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
+
+        connect(options: SocketConnectOpts, connectionListener?: () => void): this;
+        connect(port: number, host: string, connectionListener?: () => void): this;
+        connect(port: number, connectionListener?: () => void): this;
+        connect(path: string, connectionListener?: () => void): this;
+
+        setEncoding(encoding?: BufferEncoding): this;
+        pause(): this;
+        resume(): this;
+        setTimeout(timeout: number, callback?: () => void): this;
+        setNoDelay(noDelay?: boolean): this;
+        setKeepAlive(enable?: boolean, initialDelay?: number): this;
+        address(): AddressInfo | {};
+        unref(): this;
+        ref(): this;
+
+        /** @deprecated since v14.6.0 - Use `writableLength` instead. */
+        readonly bufferSize: number;
+        readonly bytesRead: number;
+        readonly bytesWritten: number;
+        readonly connecting: boolean;
+        readonly destroyed: boolean;
+        readonly localAddress: string;
+        readonly localPort: number;
+        /**
+         * This property represents the state of the connection as a string.
+         * @see {https://nodejs.org/api/net.html#socketreadystate}
+         * @since v0.5.0
+         */
+        readonly readyState: SocketReadyState;
+        readonly remoteAddress?: string | undefined;
+        readonly remoteFamily?: string | undefined;
+        readonly remotePort?: number | undefined;
+        /**
+         * The socket timeout in milliseconds as set by socket.setTimeout(). It is undefined if a timeout has not been set.
+         * @since v10.7.0
+         */
+        readonly timeout?: number | undefined;
+
+        // Extended base methods
+        end(cb?: () => void): this;
+        end(buffer: Uint8Array | string, cb?: () => void): this;
+        end(str: Uint8Array | string, encoding?: BufferEncoding, cb?: () => void): this;
+
+        /**
+         * events.EventEmitter
+         *   1. close
+         *   2. connect
+         *   3. data
+         *   4. drain
+         *   5. end
+         *   6. error
+         *   7. lookup
+         *   8. timeout
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: (had_error: boolean) => void): this;
+        addListener(event: "connect", listener: () => void): this;
+        addListener(event: "data", listener: (data: Buffer) => void): this;
+        addListener(event: "drain", listener: () => void): this;
+        addListener(event: "end", listener: () => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        addListener(event: "ready", listener: () => void): this;
+        addListener(event: "timeout", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close", had_error: boolean): boolean;
+        emit(event: "connect"): boolean;
+        emit(event: "data", data: Buffer): boolean;
+        emit(event: "drain"): boolean;
+        emit(event: "end"): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
+        emit(event: "ready"): boolean;
+        emit(event: "timeout"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: (had_error: boolean) => void): this;
+        on(event: "connect", listener: () => void): this;
+        on(event: "data", listener: (data: Buffer) => void): this;
+        on(event: "drain", listener: () => void): this;
+        on(event: "end", listener: () => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        on(event: "ready", listener: () => void): this;
+        on(event: "timeout", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: (had_error: boolean) => void): this;
+        once(event: "connect", listener: () => void): this;
+        once(event: "data", listener: (data: Buffer) => void): this;
+        once(event: "drain", listener: () => void): this;
+        once(event: "end", listener: () => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        once(event: "ready", listener: () => void): this;
+        once(event: "timeout", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: (had_error: boolean) => void): this;
+        prependListener(event: "connect", listener: () => void): this;
+        prependListener(event: "data", listener: (data: Buffer) => void): this;
+        prependListener(event: "drain", listener: () => void): this;
+        prependListener(event: "end", listener: () => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependListener(event: "ready", listener: () => void): this;
+        prependListener(event: "timeout", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: (had_error: boolean) => void): this;
+        prependOnceListener(event: "connect", listener: () => void): this;
+        prependOnceListener(event: "data", listener: (data: Buffer) => void): this;
+        prependOnceListener(event: "drain", listener: () => void): this;
+        prependOnceListener(event: "end", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
+        prependOnceListener(event: "ready", listener: () => void): this;
+        prependOnceListener(event: "timeout", listener: () => void): this;
+    }
+
+    interface ListenOptions {
+        port?: number | undefined;
+        host?: string | undefined;
+        backlog?: number | undefined;
+        path?: string | undefined;
+        exclusive?: boolean | undefined;
+        readableAll?: boolean | undefined;
+        writableAll?: boolean | undefined;
+        /**
+         * @default false
+         */
+        ipv6Only?: boolean | undefined;
+    }
+
+    interface ServerOpts {
+        /**
+         * Indicates whether half-opened TCP connections are allowed.
+         * @default false
+         */
+        allowHalfOpen?: boolean | undefined;
+
+        /**
+         * Indicates whether the socket should be paused on incoming connections.
+         * @default false
+         */
+        pauseOnConnect?: boolean | undefined;
+    }
+
+    // https://github.com/nodejs/node/blob/master/lib/net.js
+    class Server extends EventEmitter {
+        constructor(connectionListener?: (socket: Socket) => void);
+        constructor(options?: ServerOpts, connectionListener?: (socket: Socket) => void);
+
+        listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, hostname?: string, listeningListener?: () => void): this;
+        listen(port?: number, backlog?: number, listeningListener?: () => void): this;
+        listen(port?: number, listeningListener?: () => void): this;
+        listen(path: string, backlog?: number, listeningListener?: () => void): this;
+        listen(path: string, listeningListener?: () => void): this;
+        listen(options: ListenOptions, listeningListener?: () => void): this;
+        listen(handle: any, backlog?: number, listeningListener?: () => void): this;
+        listen(handle: any, listeningListener?: () => void): this;
+        close(callback?: (err?: Error) => void): this;
+        address(): AddressInfo | string | null;
+        getConnections(cb: (error: Error | null, count: number) => void): void;
+        ref(): this;
+        unref(): this;
+        maxConnections: number;
+        connections: number;
+        listening: boolean;
+
+        /**
+         * events.EventEmitter
+         *   1. close
+         *   2. connection
+         *   3. error
+         *   4. listening
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "connection", listener: (socket: Socket) => void): this;
+        addListener(event: "error", listener: (err: Error) => void): this;
+        addListener(event: "listening", listener: () => void): this;
+
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "connection", socket: Socket): boolean;
+        emit(event: "error", err: Error): boolean;
+        emit(event: "listening"): boolean;
+
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "connection", listener: (socket: Socket) => void): this;
+        on(event: "error", listener: (err: Error) => void): this;
+        on(event: "listening", listener: () => void): this;
+
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "connection", listener: (socket: Socket) => void): this;
+        once(event: "error", listener: (err: Error) => void): this;
+        once(event: "listening", listener: () => void): this;
+
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "connection", listener: (socket: Socket) => void): this;
+        prependListener(event: "error", listener: (err: Error) => void): this;
+        prependListener(event: "listening", listener: () => void): this;
+
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "connection", listener: (socket: Socket) => void): this;
+        prependOnceListener(event: "error", listener: (err: Error) => void): this;
+        prependOnceListener(event: "listening", listener: () => void): this;
+    }
+
+    interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
+        timeout?: number | undefined;
+    }
+
+    interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
+        timeout?: number | undefined;
+    }
+
+    type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;
+
+    function createServer(connectionListener?: (socket: Socket) => void): Server;
+    function createServer(options?: ServerOpts, connectionListener?: (socket: Socket) => void): Server;
+    function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function connect(port: number, host?: string, connectionListener?: () => void): Socket;
+    function connect(path: string, connectionListener?: () => void): Socket;
+    function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
+    function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
+    function createConnection(path: string, connectionListener?: () => void): Socket;
+    function isIP(input: string): number;
+    function isIPv4(input: string): boolean;
+    function isIPv6(input: string): boolean;
+}
+declare module 'node:net' {
+    export * from 'net';
+}

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

@@ -0,0 +1,243 @@
+declare module 'os' {
+    interface CpuInfo {
+        model: string;
+        speed: number;
+        times: {
+            user: number;
+            nice: number;
+            sys: number;
+            idle: number;
+            irq: number;
+        };
+    }
+
+    interface NetworkInterfaceBase {
+        address: string;
+        netmask: string;
+        mac: string;
+        internal: boolean;
+        cidr: string | null;
+    }
+
+    interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
+        family: "IPv4";
+        scopeid?: undefined;
+    }
+
+    interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
+        family: "IPv6";
+        scopeid: number;
+    }
+
+    interface UserInfo<T> {
+        username: T;
+        uid: number;
+        gid: number;
+        shell: T;
+        homedir: T;
+    }
+
+    type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
+
+    function hostname(): string;
+    function loadavg(): number[];
+    function uptime(): number;
+    function freemem(): number;
+    function totalmem(): number;
+    function cpus(): CpuInfo[];
+    function type(): string;
+    function release(): string;
+    function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
+    function homedir(): string;
+    function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
+    function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
+
+    type SignalConstants = {
+        [key in NodeJS.Signals]: number;
+    };
+
+    namespace constants {
+        const UV_UDP_REUSEADDR: number;
+        namespace signals {}
+        const signals: SignalConstants;
+        namespace errno {
+            const E2BIG: number;
+            const EACCES: number;
+            const EADDRINUSE: number;
+            const EADDRNOTAVAIL: number;
+            const EAFNOSUPPORT: number;
+            const EAGAIN: number;
+            const EALREADY: number;
+            const EBADF: number;
+            const EBADMSG: number;
+            const EBUSY: number;
+            const ECANCELED: number;
+            const ECHILD: number;
+            const ECONNABORTED: number;
+            const ECONNREFUSED: number;
+            const ECONNRESET: number;
+            const EDEADLK: number;
+            const EDESTADDRREQ: number;
+            const EDOM: number;
+            const EDQUOT: number;
+            const EEXIST: number;
+            const EFAULT: number;
+            const EFBIG: number;
+            const EHOSTUNREACH: number;
+            const EIDRM: number;
+            const EILSEQ: number;
+            const EINPROGRESS: number;
+            const EINTR: number;
+            const EINVAL: number;
+            const EIO: number;
+            const EISCONN: number;
+            const EISDIR: number;
+            const ELOOP: number;
+            const EMFILE: number;
+            const EMLINK: number;
+            const EMSGSIZE: number;
+            const EMULTIHOP: number;
+            const ENAMETOOLONG: number;
+            const ENETDOWN: number;
+            const ENETRESET: number;
+            const ENETUNREACH: number;
+            const ENFILE: number;
+            const ENOBUFS: number;
+            const ENODATA: number;
+            const ENODEV: number;
+            const ENOENT: number;
+            const ENOEXEC: number;
+            const ENOLCK: number;
+            const ENOLINK: number;
+            const ENOMEM: number;
+            const ENOMSG: number;
+            const ENOPROTOOPT: number;
+            const ENOSPC: number;
+            const ENOSR: number;
+            const ENOSTR: number;
+            const ENOSYS: number;
+            const ENOTCONN: number;
+            const ENOTDIR: number;
+            const ENOTEMPTY: number;
+            const ENOTSOCK: number;
+            const ENOTSUP: number;
+            const ENOTTY: number;
+            const ENXIO: number;
+            const EOPNOTSUPP: number;
+            const EOVERFLOW: number;
+            const EPERM: number;
+            const EPIPE: number;
+            const EPROTO: number;
+            const EPROTONOSUPPORT: number;
+            const EPROTOTYPE: number;
+            const ERANGE: number;
+            const EROFS: number;
+            const ESPIPE: number;
+            const ESRCH: number;
+            const ESTALE: number;
+            const ETIME: number;
+            const ETIMEDOUT: number;
+            const ETXTBSY: number;
+            const EWOULDBLOCK: number;
+            const EXDEV: number;
+            const WSAEINTR: number;
+            const WSAEBADF: number;
+            const WSAEACCES: number;
+            const WSAEFAULT: number;
+            const WSAEINVAL: number;
+            const WSAEMFILE: number;
+            const WSAEWOULDBLOCK: number;
+            const WSAEINPROGRESS: number;
+            const WSAEALREADY: number;
+            const WSAENOTSOCK: number;
+            const WSAEDESTADDRREQ: number;
+            const WSAEMSGSIZE: number;
+            const WSAEPROTOTYPE: number;
+            const WSAENOPROTOOPT: number;
+            const WSAEPROTONOSUPPORT: number;
+            const WSAESOCKTNOSUPPORT: number;
+            const WSAEOPNOTSUPP: number;
+            const WSAEPFNOSUPPORT: number;
+            const WSAEAFNOSUPPORT: number;
+            const WSAEADDRINUSE: number;
+            const WSAEADDRNOTAVAIL: number;
+            const WSAENETDOWN: number;
+            const WSAENETUNREACH: number;
+            const WSAENETRESET: number;
+            const WSAECONNABORTED: number;
+            const WSAECONNRESET: number;
+            const WSAENOBUFS: number;
+            const WSAEISCONN: number;
+            const WSAENOTCONN: number;
+            const WSAESHUTDOWN: number;
+            const WSAETOOMANYREFS: number;
+            const WSAETIMEDOUT: number;
+            const WSAECONNREFUSED: number;
+            const WSAELOOP: number;
+            const WSAENAMETOOLONG: number;
+            const WSAEHOSTDOWN: number;
+            const WSAEHOSTUNREACH: number;
+            const WSAENOTEMPTY: number;
+            const WSAEPROCLIM: number;
+            const WSAEUSERS: number;
+            const WSAEDQUOT: number;
+            const WSAESTALE: number;
+            const WSAEREMOTE: number;
+            const WSASYSNOTREADY: number;
+            const WSAVERNOTSUPPORTED: number;
+            const WSANOTINITIALISED: number;
+            const WSAEDISCON: number;
+            const WSAENOMORE: number;
+            const WSAECANCELLED: number;
+            const WSAEINVALIDPROCTABLE: number;
+            const WSAEINVALIDPROVIDER: number;
+            const WSAEPROVIDERFAILEDINIT: number;
+            const WSASYSCALLFAILURE: number;
+            const WSASERVICE_NOT_FOUND: number;
+            const WSATYPE_NOT_FOUND: number;
+            const WSA_E_NO_MORE: number;
+            const WSA_E_CANCELLED: number;
+            const WSAEREFUSED: number;
+        }
+        namespace priority {
+            const PRIORITY_LOW: number;
+            const PRIORITY_BELOW_NORMAL: number;
+            const PRIORITY_NORMAL: number;
+            const PRIORITY_ABOVE_NORMAL: number;
+            const PRIORITY_HIGH: number;
+            const PRIORITY_HIGHEST: number;
+        }
+    }
+
+    function arch(): string;
+    /**
+     * Returns a string identifying the kernel version.
+     * On POSIX systems, the operating system release is determined by calling
+     * [uname(3)][]. On Windows, `pRtlGetVersion` is used, and if it is not available,
+     * `GetVersionExW()` will be used. See
+     * https://en.wikipedia.org/wiki/Uname#Examples for more information.
+     */
+    function version(): string;
+    function platform(): NodeJS.Platform;
+    function tmpdir(): string;
+    const EOL: string;
+    function endianness(): "BE" | "LE";
+    /**
+     * Gets the priority of a process.
+     * Defaults to current process.
+     */
+    function getPriority(pid?: number): number;
+    /**
+     * Sets the priority of the current process.
+     * @param priority Must be in range of -20 to 19
+     */
+    function setPriority(priority: number): void;
+    /**
+     * Sets the priority of the process specified process.
+     * @param priority Must be in range of -20 to 19
+     */
+    function setPriority(pid: number, priority: number): void;
+}
+declare module 'node:os' {
+    export * from 'os';
+}