@nocobase/plugin-multi-app-manager 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/node_modules/mariadb/node_modules/@types/node/string_decoder.d.ts

@@ -1,67 +0,0 @@
-/**
- * The `string_decoder` module provides an API for decoding `Buffer` objects into
- * strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
- * characters. It can be accessed using:
- *
- * ```js
- * const { StringDecoder } = require('string_decoder');
- * ```
- *
- * The following example shows the basic use of the `StringDecoder` class.
- *
- * ```js
- * const { StringDecoder } = require('string_decoder');
- * const decoder = new StringDecoder('utf8');
- *
- * const cent = Buffer.from([0xC2, 0xA2]);
- * console.log(decoder.write(cent));
- *
- * const euro = Buffer.from([0xE2, 0x82, 0xAC]);
- * console.log(decoder.write(euro));
- * ```
- *
- * When a `Buffer` instance is written to the `StringDecoder` instance, an
- * internal buffer is used to ensure that the decoded string does not contain
- * any incomplete multibyte characters. These are held in the buffer until the
- * next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
- *
- * In the following example, the three UTF-8 encoded bytes of the European Euro
- * symbol (`€`) are written over three separate operations:
- *
- * ```js
- * const { StringDecoder } = require('string_decoder');
- * const decoder = new StringDecoder('utf8');
- *
- * decoder.write(Buffer.from([0xE2]));
- * decoder.write(Buffer.from([0x82]));
- * console.log(decoder.end(Buffer.from([0xAC])));
- * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/string_decoder.js)
- */
-declare module 'string_decoder' {
-    class StringDecoder {
-        constructor(encoding?: BufferEncoding);
-        /**
-         * Returns a decoded string, ensuring that any incomplete multibyte characters at
-         * the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
-         * returned string and stored in an internal buffer for the next call to`stringDecoder.write()` or `stringDecoder.end()`.
-         * @since v0.1.99
-         * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
-         */
-        write(buffer: Buffer): string;
-        /**
-         * Returns any remaining input stored in the internal buffer as a string. Bytes
-         * representing incomplete UTF-8 and UTF-16 characters will be replaced with
-         * substitution characters appropriate for the character encoding.
-         *
-         * If the `buffer` argument is provided, one final call to `stringDecoder.write()`is performed before returning the remaining input.
-         * After `end()` is called, the `stringDecoder` object can be reused for new input.
-         * @since v0.9.3
-         * @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
-         */
-        end(buffer?: Buffer): string;
-    }
-}
-declare module 'node:string_decoder' {
-    export * from 'string_decoder';
-}

package/dist/node_modules/mariadb/node_modules/@types/node/timers/promises.d.ts

@@ -1,68 +0,0 @@
-/**
- * The `timers/promises` API provides an alternative set of timer functions
- * that return `Promise` objects. The API is accessible via`require('timers/promises')`.
- *
- * ```js
- * import {
- *   setTimeout,
- *   setImmediate,
- *   setInterval,
- * } from 'timers/promises';
- * ```
- * @since v15.0.0
- */
-declare module 'timers/promises' {
-    import { TimerOptions } from 'node:timers';
-    /**
-     * ```js
-     * import {
-     *   setTimeout,
-     * } from 'timers/promises';
-     *
-     * const res = await setTimeout(100, 'result');
-     *
-     * console.log(res);  // Prints 'result'
-     * ```
-     * @since v15.0.0
-     * @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
-     * @param value A value with which the promise is fulfilled.
-     */
-    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
-    /**
-     * ```js
-     * import {
-     *   setImmediate,
-     * } from 'timers/promises';
-     *
-     * const res = await setImmediate('result');
-     *
-     * console.log(res);  // Prints 'result'
-     * ```
-     * @since v15.0.0
-     * @param value A value with which the promise is fulfilled.
-     */
-    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
-    /**
-     * Returns an async iterator that generates values in an interval of `delay` ms.
-     *
-     * ```js
-     * import {
-     *   setInterval,
-     * } from 'timers/promises';
-     *
-     * const interval = 100;
-     * for await (const startTime of setInterval(interval, Date.now())) {
-     *   const now = Date.now();
-     *   console.log(now);
-     *   if ((now - startTime) > 1000)
-     *     break;
-     * }
-     * console.log(Date.now());
-     * ```
-     * @since v15.9.0
-     */
-    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
-}
-declare module 'node:timers/promises' {
-    export * from 'timers/promises';
-}

package/dist/node_modules/mariadb/node_modules/@types/node/timers.d.ts

@@ -1,94 +0,0 @@
-/**
- * The `timer` module exposes a global API for scheduling functions to
- * be called at some future period of time. Because the timer functions are
- * globals, there is no need to call `require('timers')` to use the API.
- *
- * The timer functions within Node.js implement a similar API as the timers API
- * provided by Web Browsers but use a different internal implementation that is
- * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/timers.js)
- */
-declare module 'timers' {
-    import { Abortable } from 'node:events';
-    import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
-    interface TimerOptions extends Abortable {
-        /**
-         * Set to `false` to indicate that the scheduled `Timeout`
-         * should not require the Node.js event loop to remain active.
-         * @default true
-         */
-        ref?: boolean | undefined;
-    }
-    let setTimeout: typeof global.setTimeout;
-    let clearTimeout: typeof global.clearTimeout;
-    let setInterval: typeof global.setInterval;
-    let clearInterval: typeof global.clearInterval;
-    let setImmediate: typeof global.setImmediate;
-    let clearImmediate: typeof global.clearImmediate;
-    global {
-        namespace NodeJS {
-            // compatibility with older typings
-            interface Timer extends RefCounted {
-                hasRef(): boolean;
-                refresh(): this;
-                [Symbol.toPrimitive](): number;
-            }
-            interface Immediate extends RefCounted {
-                /**
-                 * If true, the `Immediate` object will keep the Node.js event loop active.
-                 * @since v11.0.0
-                 */
-                hasRef(): boolean;
-                _onImmediate: Function; // to distinguish it from the Timeout class
-            }
-            interface Timeout extends Timer {
-                /**
-                 * If true, the `Timeout` object will keep the Node.js event loop active.
-                 * @since v11.0.0
-                 */
-                hasRef(): boolean;
-                /**
-                 * Sets the timer's start time to the current time, and reschedules the timer to
-                 * call its callback at the previously specified duration adjusted to the current
-                 * time. This is useful for refreshing a timer without allocating a new
-                 * JavaScript object.
-                 *
-                 * Using this on a timer that has already called its callback will reactivate the
-                 * timer.
-                 * @since v10.2.0
-                 * @return a reference to `timeout`
-                 */
-                refresh(): this;
-                [Symbol.toPrimitive](): number;
-            }
-        }
-        function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
-        // util.promisify no rest args compability
-        // tslint:disable-next-line void-return
-        function setTimeout(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
-        namespace setTimeout {
-            const __promisify__: typeof setTimeoutPromise;
-        }
-        function clearTimeout(timeoutId: NodeJS.Timeout | undefined): void;
-        function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
-        // util.promisify no rest args compability
-        // tslint:disable-next-line void-return
-        function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
-        namespace setInterval {
-            const __promisify__: typeof setIntervalPromise;
-        }
-        function clearInterval(intervalId: NodeJS.Timeout | undefined): void;
-        function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
-        // util.promisify no rest args compability
-        // tslint:disable-next-line void-return
-        function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
-        namespace setImmediate {
-            const __promisify__: typeof setImmediatePromise;
-        }
-        function clearImmediate(immediateId: NodeJS.Immediate | undefined): void;
-        function queueMicrotask(callback: () => void): void;
-    }
-}
-declare module 'node:timers' {
-    export * from 'timers';
-}