node-red-contrib-tak-registration 0.11.5 → 0.12.0

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

@@ -23,7 +23,7 @@
  * server.bind(41234);
  * // Prints: server listening 0.0.0.0:41234
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/dgram.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/dgram.js)
  */
 declare module "dgram" {
     import { AddressInfo } from "node:net";
@@ -66,7 +66,7 @@ declare module "dgram" {
      * (it does the right thing for both `udp4` and `udp6` sockets). The bound address
      * and port can be retrieved using `socket.address().address` and `socket.address().port`.
      *
-     * If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.close()` on the socket:
+     * If the `signal` option is enabled, calling `.abort()` on the corresponding `AbortController` is similar to calling `.close()` on the socket:
      *
      * ```js
      * const controller = new AbortController();
@@ -93,7 +93,7 @@ declare module "dgram" {
      */
     class Socket extends EventEmitter {
         /**
-         * Tells the kernel to join a multicast group at the given `multicastAddress` and`multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the`multicastInterface` argument is not
+         * Tells the kernel to join a multicast group at the given `multicastAddress` and `multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the `multicastInterface` argument is not
          * specified, the operating system will choose
          * one interface and will add membership to it. To add membership to every
          * available interface, call `addMembership` multiple times, once per interface.
@@ -122,7 +122,7 @@ declare module "dgram" {
         addMembership(multicastAddress: string, multicastInterface?: string): void;
         /**
          * Returns an object containing the address information for a socket.
-         * For UDP sockets, this object will contain `address`, `family`, and `port`properties.
+         * For UDP sockets, this object will contain `address`, `family`, and `port` properties.
          *
          * This method throws `EBADF` if called on an unbound socket.
          * @since v0.1.99
@@ -133,10 +133,10 @@ declare module "dgram" {
          * messages on a named `port` and optional `address`. If `port` is not
          * specified or is `0`, the operating system will attempt to bind to a
          * random port. If `address` is not specified, the operating system will
-         * attempt to listen on all addresses. Once binding is complete, a`'listening'` event is emitted and the optional `callback` function is
+         * attempt to listen on all addresses. Once binding is complete, a `'listening'` event is emitted and the optional `callback` function is
          * called.
          *
-         * Specifying both a `'listening'` event listener and passing a`callback` to the `socket.bind()` method is not harmful but not very
+         * Specifying both a `'listening'` event listener and passing a `callback` to the `socket.bind()` method is not harmful but not very
          * useful.
          *
          * A bound datagram socket keeps the Node.js process running to receive
@@ -206,7 +206,7 @@ declare module "dgram" {
          */
         disconnect(): void;
         /**
-         * Instructs the kernel to leave a multicast group at `multicastAddress` using the`IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
+         * Instructs the kernel to leave a multicast group at `multicastAddress` using the `IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
          * kernel when the socket is closed or the process terminates, so most apps will
          * never have reason to call this.
          *
@@ -227,6 +227,16 @@ declare module "dgram" {
          * @return the `SO_SNDBUF` socket send buffer size in bytes.
          */
         getSendBufferSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of bytes queued for sending.
+         */
+        getSendQueueSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of send requests currently in the queue awaiting to be processed.
+         */
+        getSendQueueCount(): number;
         /**
          * By default, binding a socket will cause it to block the Node.js process from
          * exiting as long as the socket is open. The `socket.unref()` method can be used
@@ -259,14 +269,14 @@ declare module "dgram" {
          * any `TypedArray` or a `DataView`,
          * the `offset` and `length` specify the offset within the `Buffer` where the
          * message begins and the number of bytes in the message, respectively.
-         * If `msg` is a `String`, then it is automatically converted to a `Buffer`with `'utf8'` encoding. With messages that
+         * If `msg` is a `String`, then it is automatically converted to a `Buffer` with `'utf8'` encoding. With messages that
          * contain multi-byte characters, `offset` and `length` will be calculated with
          * respect to `byte length` and not the character position.
          * If `msg` is an array, `offset` and `length` must not be specified.
          *
          * The `address` argument is a string. If the value of `address` is a host name,
          * DNS will be used to resolve the address of the host. If `address` is not
-         * provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'`(for `udp6` sockets) will be used by default.
+         * provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets) will be used by default.
          *
          * If the socket has not been previously bound with a call to `bind`, the socket
          * is assigned a random port number and is bound to the "all interfaces" address
@@ -277,7 +287,7 @@ declare module "dgram" {
          * DNS lookups delay the time to send for at least one tick of the
          * Node.js event loop.
          *
-         * The only way to know for sure that the datagram has been sent is by using a`callback`. If an error occurs and a `callback` is given, the error will be
+         * The only way to know for sure that the datagram has been sent is by using a `callback`. If an error occurs and a `callback` is given, the error will be
          * passed as the first argument to the `callback`. If a `callback` is not given,
          * the error is emitted as an `'error'` event on the `socket` object.
          *
@@ -319,7 +329,7 @@ declare module "dgram" {
          * determine the optimal strategy on a case-by-case basis. Generally speaking,
          * however, sending multiple buffers is faster.
          *
-         * Example of sending a UDP packet using a socket connected to a port on`localhost`:
+         * Example of sending a UDP packet using a socket connected to a port on `localhost`:
          *
          * ```js
          * import dgram from 'node:dgram';
@@ -509,10 +519,10 @@ declare module "dgram" {
          */
         unref(): this;
         /**
-         * Tells the kernel to join a source-specific multicast channel at the given`sourceAddress` and `groupAddress`, using the `multicastInterface` with the`IP_ADD_SOURCE_MEMBERSHIP` socket
+         * Tells the kernel to join a source-specific multicast channel at the given `sourceAddress` and `groupAddress`, using the `multicastInterface` with the `IP_ADD_SOURCE_MEMBERSHIP` socket
          * option. If the `multicastInterface` argument
          * is not specified, the operating system will choose one interface and will add
-         * membership to it. To add membership to every available interface, call`socket.addSourceSpecificMembership()` multiple times, once per interface.
+         * membership to it. To add membership to every available interface, call `socket.addSourceSpecificMembership()` multiple times, once per interface.
          *
          * When called on an unbound socket, this method will implicitly bind to a random
          * port, listening on all interfaces.
@@ -520,7 +530,7 @@ declare module "dgram" {
          */
         addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
         /**
-         * Instructs the kernel to leave a source-specific multicast channel at the given`sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`socket option. This method is
+         * Instructs the kernel to leave a source-specific multicast channel at the given `sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP` socket option. This method is
          * automatically called by the kernel when the
          * socket is closed or the process terminates, so most apps will never have
          * reason to call this.

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

@@ -20,9 +20,10 @@
  * should generally include the module name to avoid collisions with data from
  * other modules.
  * @since v15.1.0, v14.17.0
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/diagnostics_channel.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/diagnostics_channel.js)
  */
 declare module "diagnostics_channel" {
+    import { AsyncLocalStorage } from "node:async_hooks";
     /**
      * Check if there are active subscribers to the named channel. This is helpful if
      * the message you want to send might be expensive to prepare.
@@ -95,6 +96,36 @@ declare module "diagnostics_channel" {
      * @return `true` if the handler was found, `false` otherwise.
      */
     function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
+    /**
+     * Creates a `TracingChannel` wrapper for the given `TracingChannel Channels`. If a name is given, the corresponding tracing
+     * channels will be created in the form of `tracing:${name}:${eventType}` where `eventType` corresponds to the types of `TracingChannel Channels`.
+     *
+     * ```js
+     * import diagnostics_channel from 'node:diagnostics_channel';
+     *
+     * const channelsByName = diagnostics_channel.tracingChannel('my-channel');
+     *
+     * // or...
+     *
+     * const channelsByCollection = diagnostics_channel.tracingChannel({
+     *   start: diagnostics_channel.channel('tracing:my-channel:start'),
+     *   end: diagnostics_channel.channel('tracing:my-channel:end'),
+     *   asyncStart: diagnostics_channel.channel('tracing:my-channel:asyncStart'),
+     *   asyncEnd: diagnostics_channel.channel('tracing:my-channel:asyncEnd'),
+     *   error: diagnostics_channel.channel('tracing:my-channel:error'),
+     * });
+     * ```
+     * @since v19.9.0
+     * @experimental
+     * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
+     * @return Collection of channels to trace with
+     */
+    function tracingChannel<
+        StoreType = unknown,
+        ContextType extends object = StoreType extends object ? StoreType : object,
+    >(
+        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
+    ): TracingChannel<StoreType, ContextType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -104,7 +135,7 @@ declare module "diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel {
+    class Channel<StoreType = unknown, ContextType = StoreType> {
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -184,6 +215,338 @@ declare module "diagnostics_channel" {
          * @return `true` if the handler was found, `false` otherwise.
          */
         unsubscribe(onMessage: ChannelListener): void;
+        /**
+         * When `channel.runStores(context, ...)` is called, the given context data
+         * will be applied to any store bound to the channel. If the store has already been
+         * bound the previous `transform` function will be replaced with the new one.
+         * The `transform` function may be omitted to set the given context data as the
+         * context directly.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (data) => {
+         *   return { data };
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to which to bind the context data
+         * @param transform Transform context data before setting the store context
+         */
+        bindStore(store: AsyncLocalStorage<StoreType>, transform?: (context: ContextType) => StoreType): void;
+        /**
+         * Remove a message handler previously registered to this channel with `channel.bindStore(store)`.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store);
+         * channel.unbindStore(store);
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to unbind from the channel.
+         * @return `true` if the store was found, `false` otherwise.
+         */
+        unbindStore(store: any): void;
+        /**
+         * Applies the given data to any AsyncLocalStorage instances bound to the channel
+         * for the duration of the given function, then publishes to the channel within
+         * the scope of that data is applied to the stores.
+         *
+         * If a transform function was given to `channel.bindStore(store)` it will be
+         * applied to transform the message data before it becomes the context value for
+         * the store. The prior storage context is accessible from within the transform
+         * function in cases where context linking is required.
+         *
+         * The context applied to the store should be accessible in any async code which
+         * continues from execution which began during the given function, however
+         * there are some situations in which `context loss` may occur.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (message) => {
+         *   const parent = store.getStore();
+         *   return new Span(message, parent);
+         * });
+         * channel.runStores({ some: 'message' }, () => {
+         *   store.getStore(); // Span({ some: 'message' })
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param context Message to send to subscribers and bind to stores
+         * @param fn Handler to run within the entered storage context
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runStores(): void;
+    }
+    interface TracingChannelSubscribers<ContextType extends object> {
+        start: (message: ContextType) => void;
+        end: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncStart: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncEnd: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        error: (
+            message: ContextType & {
+                error: unknown;
+            },
+        ) => void;
+    }
+    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+    }
+    /**
+     * The class `TracingChannel` is a collection of `TracingChannel Channels` which
+     * together express a single traceable action. It is used to formalize and
+     * simplify the process of producing events for tracing application flow. {@link tracingChannel} is used to construct a `TracingChannel`. As with `Channel` it is recommended to create and reuse a
+     * single `TracingChannel` at the top-level of the file rather than creating them
+     * dynamically.
+     * @since v19.9.0
+     * @experimental
+     */
+    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+        /**
+         * Helper to subscribe a collection of functions to the corresponding channels.
+         * This is the same as calling `channel.subscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.subscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         */
+        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Helper to unsubscribe a collection of functions from the corresponding channels.
+         * This is the same as calling `channel.unsubscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.unsubscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         * @return `true` if all handlers were successfully unsubscribed, and `false` otherwise.
+         */
+        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Trace a synchronous function call. This will always produce a `start event` and `end event` around the execution and may produce an `error event` if the given function throws an error.
+         * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * To ensure only correct trace graphs are formed, events will only be published if subscribers are present prior to starting the trace. Subscriptions
+         * which are added after the trace begins will not receive future events from that trace, only future traces will be seen.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceSync(() => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Function to wrap a trace around
+         * @param context Shared object to correlate events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceSync<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => any,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a promise-returning function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce an `asyncStart event` and `asyncEnd event` when a promise continuation is reached. It may also
+         * produce an `error event` if the given function throws an error or the
+         * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * To ensure only correct trace graphs are formed, events will only be published if subscribers are present prior to starting the trace. Subscriptions
+         * which are added after the trace begins will not receive future events from that trace, only future traces will be seen.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.tracePromise(async () => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Promise-returning function to wrap a trace around
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return Chained from promise returned by the given function
+         */
+        tracePromise<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => Promise<any>,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a callback-receiving function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce a `asyncStart event` and `asyncEnd event` around the callback execution. It may also produce an `error event` if the given function throws an error or
+         * the returned
+         * promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * The `position` will be -1 by default to indicate the final argument should
+         * be used as the callback.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceCallback((arg1, callback) => {
+         *   // Do something
+         *   callback(null, 'result');
+         * }, 1, {
+         *   some: 'thing',
+         * }, thisArg, arg1, callback);
+         * ```
+         *
+         * The callback will also be run with `channel.runStores(context, ...)` which
+         * enables context loss recovery in some cases.
+         *
+         * To ensure only correct trace graphs are formed, events will only be published if subscribers are present prior to starting the trace. Subscriptions
+         * which are added after the trace begins will not receive future events from that trace, only future traces will be seen.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         * const myStore = new AsyncLocalStorage();
+         *
+         * // The start channel sets the initial store data to something
+         * // and stores that store data value on the trace context object
+         * channels.start.bindStore(myStore, (data) => {
+         *   const span = new Span(data);
+         *   data.span = span;
+         *   return span;
+         * });
+         *
+         * // Then asyncStart can restore from that data it stored previously
+         * channels.asyncStart.bindStore(myStore, (data) => {
+         *   return data.span;
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn callback using function to wrap a trace around
+         * @param position Zero-indexed argument position of expected callback
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceCallback<Fn extends (this: any, ...args: any) => any>(
+            fn: Fn,
+            position: number | undefined,
+            context: ContextType | undefined,
+            thisArg: any,
+            ...args: Parameters<Fn>
+        ): void;
     }
 }
 declare module "node:diagnostics_channel" {