@machhub-dev/node-red-nodes 1.0.5

package/node_modules/@types/node/dom-events.d.ts

@@ -0,0 +1,124 @@
+export {}; // Don't export anything!
+
+//// DOM-like Events
+// NB: The Event / EventTarget / EventListener implementations below were copied
+// from lib.dom.d.ts, then edited to reflect Node's documentation at
+// https://nodejs.org/api/events.html#class-eventtarget.
+// Please read that link to understand important implementation differences.
+
+// This conditional type will be the existing global Event in a browser, or
+// the copy below in a Node environment.
+type __Event = typeof globalThis extends { onmessage: any; Event: any } ? {}
+    : {
+        /** This is not used in Node.js and is provided purely for completeness. */
+        readonly bubbles: boolean;
+        /** Alias for event.stopPropagation(). This is not used in Node.js and is provided purely for completeness. */
+        cancelBubble: () => void;
+        /** True if the event was created with the cancelable option */
+        readonly cancelable: boolean;
+        /** This is not used in Node.js and is provided purely for completeness. */
+        readonly composed: boolean;
+        /** Returns an array containing the current EventTarget as the only entry or empty if the event is not being dispatched. This is not used in Node.js and is provided purely for completeness. */
+        composedPath(): [EventTarget?];
+        /** Alias for event.target. */
+        readonly currentTarget: EventTarget | null;
+        /** Is true if cancelable is true and event.preventDefault() has been called. */
+        readonly defaultPrevented: boolean;
+        /** This is not used in Node.js and is provided purely for completeness. */
+        readonly eventPhase: 0 | 2;
+        /** The `AbortSignal` "abort" event is emitted with `isTrusted` set to `true`. The value is `false` in all other cases. */
+        readonly isTrusted: boolean;
+        /** Sets the `defaultPrevented` property to `true` if `cancelable` is `true`. */
+        preventDefault(): void;
+        /** This is not used in Node.js and is provided purely for completeness. */
+        returnValue: boolean;
+        /** Alias for event.target. */
+        readonly srcElement: EventTarget | null;
+        /** Stops the invocation of event listeners after the current one completes. */
+        stopImmediatePropagation(): void;
+        /** This is not used in Node.js and is provided purely for completeness. */
+        stopPropagation(): void;
+        /** The `EventTarget` dispatching the event */
+        readonly target: EventTarget | null;
+        /** The millisecond timestamp when the Event object was created. */
+        readonly timeStamp: number;
+        /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
+        readonly type: string;
+    };
+
+// See comment above explaining conditional type
+type __EventTarget = typeof globalThis extends { onmessage: any; EventTarget: any } ? {}
+    : {
+        /**
+         * Adds a new handler for the `type` event. Any given `listener` is added only once per `type` and per `capture` option value.
+         *
+         * If the `once` option is true, the `listener` is removed after the next time a `type` event is dispatched.
+         *
+         * The `capture` option is not used by Node.js in any functional way other than tracking registered event listeners per the `EventTarget` specification.
+         * Specifically, the `capture` option is used as part of the key when registering a `listener`.
+         * Any individual `listener` may be added once with `capture = false`, and once with `capture = true`.
+         */
+        addEventListener(
+            type: string,
+            listener: EventListener | EventListenerObject,
+            options?: AddEventListenerOptions | boolean,
+        ): void;
+        /** Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. */
+        dispatchEvent(event: Event): boolean;
+        /** Removes the event listener in target's event listener list with the same type, callback, and options. */
+        removeEventListener(
+            type: string,
+            listener: EventListener | EventListenerObject,
+            options?: EventListenerOptions | boolean,
+        ): void;
+    };
+
+interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+
+interface EventListenerOptions {
+    /** Not directly used by Node.js. Added for API completeness. Default: `false`. */
+    capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+    /** When `true`, the listener is automatically removed when it is first invoked. Default: `false`. */
+    once?: boolean;
+    /** When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. Default: false. */
+    passive?: boolean;
+    /** The listener will be removed when the given AbortSignal object's `abort()` method is called. */
+    signal?: AbortSignal;
+}
+
+interface EventListener {
+    (evt: Event): void;
+}
+
+interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+
+import {} from "events"; // Make this an ambient declaration
+declare global {
+    /** An event which takes place in the DOM. */
+    interface Event extends __Event {}
+    var Event: typeof globalThis extends { onmessage: any; Event: infer T } ? T
+        : {
+            prototype: __Event;
+            new(type: string, eventInitDict?: EventInit): __Event;
+        };
+
+    /**
+     * EventTarget is a DOM interface implemented by objects that can
+     * receive events and may have listeners for them.
+     */
+    interface EventTarget extends __EventTarget {}
+    var EventTarget: typeof globalThis extends { onmessage: any; EventTarget: infer T } ? T
+        : {
+            prototype: __EventTarget;
+            new(): __EventTarget;
+        };
+}

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

@@ -0,0 +1,170 @@
+/**
+ * **This module is pending deprecation.** Once a replacement API has been
+ * finalized, this module will be fully deprecated. Most developers should
+ * **not** have cause to use this module. Users who absolutely must have
+ * the functionality that domains provide may rely on it for the time being
+ * but should expect to have to migrate to a different solution
+ * in the future.
+ *
+ * Domains provide a way to handle multiple different IO operations as a
+ * single group. If any of the event emitters or callbacks registered to a
+ * domain emit an `'error'` event, or throw an error, then the domain object
+ * will be notified, rather than losing the context of the error in the `process.on('uncaughtException')` handler, or causing the program to
+ * exit immediately with an error code.
+ * @deprecated Since v1.4.2 - Deprecated
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/domain.js)
+ */
+declare module "domain" {
+    import EventEmitter = require("node:events");
+    /**
+     * The `Domain` class encapsulates the functionality of routing errors and
+     * uncaught exceptions to the active `Domain` object.
+     *
+     * To handle the errors that it catches, listen to its `'error'` event.
+     */
+    class Domain extends EventEmitter {
+        /**
+         * An array of timers and event emitters that have been explicitly added
+         * to the domain.
+         */
+        members: Array<EventEmitter | NodeJS.Timer>;
+        /**
+         * The `enter()` method is plumbing used by the `run()`, `bind()`, and `intercept()` methods to set the active domain. It sets `domain.active` and `process.domain` to the domain, and implicitly
+         * pushes the domain onto the domain
+         * stack managed by the domain module (see {@link exit} for details on the
+         * domain stack). The call to `enter()` delimits the beginning of a chain of
+         * asynchronous calls and I/O operations bound to a domain.
+         *
+         * Calling `enter()` changes only the active domain, and does not alter the domain
+         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
+         * single domain.
+         */
+        enter(): void;
+        /**
+         * The `exit()` method exits the current domain, popping it off the domain stack.
+         * Any time execution is going to switch to the context of a different chain of
+         * asynchronous calls, it's important to ensure that the current domain is exited.
+         * The call to `exit()` delimits either the end of or an interruption to the chain
+         * of asynchronous calls and I/O operations bound to a domain.
+         *
+         * If there are multiple, nested domains bound to the current execution context, `exit()` will exit any domains nested within this domain.
+         *
+         * Calling `exit()` changes only the active domain, and does not alter the domain
+         * itself. `enter()` and `exit()` can be called an arbitrary number of times on a
+         * single domain.
+         */
+        exit(): void;
+        /**
+         * Run the supplied function in the context of the domain, implicitly
+         * binding all event emitters, timers, and low-level requests that are
+         * created in that context. Optionally, arguments can be passed to
+         * the function.
+         *
+         * This is the most basic way to use a domain.
+         *
+         * ```js
+         * const domain = require('node:domain');
+         * const fs = require('node:fs');
+         * const d = domain.create();
+         * d.on('error', (er) => {
+         *   console.error('Caught error!', er);
+         * });
+         * d.run(() => {
+         *   process.nextTick(() => {
+         *     setTimeout(() => { // Simulating some various async stuff
+         *       fs.open('non-existent file', 'r', (er, fd) => {
+         *         if (er) throw er;
+         *         // proceed...
+         *       });
+         *     }, 100);
+         *   });
+         * });
+         * ```
+         *
+         * In this example, the `d.on('error')` handler will be triggered, rather
+         * than crashing the program.
+         */
+        run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+        /**
+         * Explicitly adds an emitter to the domain. If any event handlers called by
+         * the emitter throw an error, or if the emitter emits an `'error'` event, it
+         * will be routed to the domain's `'error'` event, just like with implicit
+         * binding.
+         *
+         * This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by
+         * the domain `'error'` handler.
+         *
+         * If the Timer or `EventEmitter` was already bound to a domain, it is removed
+         * from that one, and bound to this one instead.
+         * @param emitter emitter or timer to be added to the domain
+         */
+        add(emitter: EventEmitter | NodeJS.Timer): void;
+        /**
+         * The opposite of {@link add}. Removes domain handling from the
+         * specified emitter.
+         * @param emitter emitter or timer to be removed from the domain
+         */
+        remove(emitter: EventEmitter | NodeJS.Timer): void;
+        /**
+         * The returned function will be a wrapper around the supplied callback
+         * function. When the returned function is called, any errors that are
+         * thrown will be routed to the domain's `'error'` event.
+         *
+         * ```js
+         * const d = domain.create();
+         *
+         * function readSomeFile(filename, cb) {
+         *   fs.readFile(filename, 'utf8', d.bind((er, data) => {
+         *     // If this throws, it will also be passed to the domain.
+         *     return cb(er, data ? JSON.parse(data) : null);
+         *   }));
+         * }
+         *
+         * d.on('error', (er) => {
+         *   // An error occurred somewhere. If we throw it now, it will crash the program
+         *   // with the normal line number and stack message.
+         * });
+         * ```
+         * @param callback The callback function
+         * @return The bound function
+         */
+        bind<T extends Function>(callback: T): T;
+        /**
+         * This method is almost identical to {@link bind}. However, in
+         * addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function.
+         *
+         * In this way, the common `if (err) return callback(err);` pattern can be replaced
+         * with a single error handler in a single place.
+         *
+         * ```js
+         * const d = domain.create();
+         *
+         * function readSomeFile(filename, cb) {
+         *   fs.readFile(filename, 'utf8', d.intercept((data) => {
+         *     // Note, the first argument is never passed to the
+         *     // callback since it is assumed to be the 'Error' argument
+         *     // and thus intercepted by the domain.
+         *
+         *     // If this throws, it will also be passed to the domain
+         *     // so the error-handling logic can be moved to the 'error'
+         *     // event on the domain instead of being repeated throughout
+         *     // the program.
+         *     return cb(null, JSON.parse(data));
+         *   }));
+         * }
+         *
+         * d.on('error', (er) => {
+         *   // An error occurred somewhere. If we throw it now, it will crash the program
+         *   // with the normal line number and stack message.
+         * });
+         * ```
+         * @param callback The callback function
+         * @return The intercepted function
+         */
+        intercept<T extends Function>(callback: T): T;
+    }
+    function create(): Domain;
+}
+declare module "node:domain" {
+    export * from "domain";
+}