@node-red/editor-client 3.1.8 → 4.0.0-beta.2

package/public/types/node/querystring.d.ts

@@ -1,5 +1,5 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 /**
  * The `querystring` module provides utilities for parsing and formatting URL
@@ -12,7 +12,7 @@
  * `querystring` is more performant than `URLSearchParams` but is not a
  * standardized API. Use `URLSearchParams` when performance is not critical
  * or when compatibility with browser code is desirable.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/querystring.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/querystring.js)
  */
 declare module 'querystring' {
     interface StringifyOptions {

package/public/types/node/readline/promises.d.ts

@@ -0,0 +1,146 @@
+
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
+
+/**
+ * The `readline/promise` module provides an API for reading lines of input from a Readable stream one line at a time.
+ *
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline/promises.js)
+ * @since v17.0.0
+ */
+declare module 'readline/promises' {
+    import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
+    import { Abortable } from 'node:events';
+
+    class Interface extends _Interface {
+        /**
+         * The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input,
+         * then invokes the callback function passing the provided input as the first argument.
+         *
+         * When called, rl.question() will resume the input stream if it has been paused.
+         *
+         * If the readlinePromises.Interface was created with output set to null or undefined the query is not written.
+         *
+         * If the question is called after rl.close(), it returns a rejected promise.
+         *
+         * Example usage:
+         *
+         * ```js
+         * const answer = await rl.question('What is your favorite food? ');
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         *
+         * Using an AbortSignal to cancel a question.
+         *
+         * ```js
+         * const signal = AbortSignal.timeout(10_000);
+         *
+         * signal.addEventListener('abort', () => {
+         *   console.log('The food question timed out');
+         * }, { once: true });
+         *
+         * const answer = await rl.question('What is your favorite food? ', { signal });
+         * console.log(`Oh, so your favorite food is ${answer}`);
+         * ```
+         *
+         * @since v17.0.0
+         * @param query A statement or query to write to output, prepended to the prompt.
+         */
+        question(query: string): Promise<string>;
+        question(query: string, options: Abortable): Promise<string>;
+    }
+
+    class Readline {
+        /**
+         * @param stream A TTY stream.
+         */
+        constructor(stream: NodeJS.WritableStream, options?: { autoCommit?: boolean });
+        /**
+         * The `rl.clearLine()` method adds to the internal list of pending action an action that clears current line of the associated `stream` in a specified direction identified by `dir`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        clearLine(dir: Direction): this;
+        /**
+         * The `rl.clearScreenDown()` method adds to the internal list of pending action an action that clears the associated `stream` from the current position of the cursor down.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        clearScreenDown(): this;
+        /**
+         * The `rl.commit()` method sends all the pending actions to the associated `stream` and clears the internal list of pending actions.
+         */
+        commit(): Promise<void>;
+        /**
+         * The `rl.cursorTo()` method adds to the internal list of pending action an action that moves cursor to the specified position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
+         */
+        cursorTo(x: number, y?: number): this;
+        /**
+         * The `rl.moveCursor()` method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated `stream`.
+         * Call `rl.commit()` to see the effect of this method, unless autoCommit: true was passed to the constructor.
+         */
+        moveCursor(dx: number, dy: number): this;
+        /**
+         * The `rl.rollback()` method clears the internal list of pending actions without sending it to the associated `stream`.
+         */
+        rollback(): this;
+    }
+
+    /**
+     * The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
+     *
+     * ```js
+     * const readlinePromises = require('node:readline/promises');
+     * const rl = readlinePromises.createInterface({
+     *   input: process.stdin,
+     *   output: process.stdout
+     * });
+     * ```
+     *
+     * Once the `readlinePromises.Interface` instance is created, the most common case is to listen for the `'line'` event:
+     *
+     * ```js
+     * rl.on('line', (line) => {
+     *   console.log(`Received: ${line}`);
+     * });
+     * ```
+     *
+     * If `terminal` is `true` for this instance then the `output` stream will get the best compatibility if it defines an `output.columns` property,
+     * and emits a `'resize'` event on the `output`, if or when the columns ever change (`process.stdout` does this automatically when it is a TTY).
+     *
+     * ## Use of the `completer` function
+     *
+     * The `completer` function takes the current line entered by the user as an argument, and returns an `Array` with 2 entries:
+     *
+     * - An Array with matching entries for the completion.
+     * - The substring that was used for the matching.
+     *
+     * For instance: `[[substr1, substr2, ...], originalsubstring]`.
+     *
+     * ```js
+     * function completer(line) {
+     *   const completions = '.help .error .exit .quit .q'.split(' ');
+     *   const hits = completions.filter((c) => c.startsWith(line));
+     *   // Show all completions if none found
+     *   return [hits.length ? hits : completions, line];
+     * }
+     * ```
+     *
+     * The `completer` function can also returns a `Promise`, or be asynchronous:
+     *
+     * ```js
+     * async function completer(linePartial) {
+     *   await someAsyncWork();
+     *   return [['123'], linePartial];
+     * }
+     * ```
+     */
+    function createInterface(
+        input: NodeJS.ReadableStream,
+        output?: NodeJS.WritableStream,
+        completer?: Completer | AsyncCompleter,
+        terminal?: boolean,
+    ): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+}
+declare module 'node:readline/promises' {
+    export * from 'readline/promises';
+}

package/public/types/node/readline.d.ts

@@ -1,39 +1,46 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 /**
- * The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time. It can be accessed
- * using:
+ * The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time.
+ *
+ * To use the promise-based APIs:
  *
  * ```js
- * const readline = require('readline');
+ * import * as readline from 'node:readline/promises';
+ * ```
+ *
+ * To use the callback and sync APIs:
+ *
+ * ```js
+ * import * as readline from 'node:readline';
  * ```
  *
  * The following simple example illustrates the basic use of the `readline` module.
  *
  * ```js
- * const readline = require('readline');
+ * import * as readline from 'node:readline/promises';
+ * import { stdin as input, stdout as output } from 'node:process';
+ *
+ * const rl = readline.createInterface({ input, output });
  *
- * const rl = readline.createInterface({
- *   input: process.stdin,
- *   output: process.stdout
- * });
+ * const answer = await rl.question('What do you think of Node.js? ');
  *
- * rl.question('What do you think of Node.js? ', (answer) => {
- *   // TODO: Log the answer in a database
- *   console.log(`Thank you for your valuable feedback: ${answer}`);
+ * console.log(`Thank you for your valuable feedback: ${answer}`);
  *
- *   rl.close();
- * });
+ * rl.close();
  * ```
  *
  * Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
  * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v16.9.0/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline.js)
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';
-    interface Key {
+    import * as promises from 'node:readline/promises';
+
+    export { promises };
+    export interface Key {
         sequence?: string | undefined;
         name?: string | undefined;
         ctrl?: boolean | undefined;
@@ -47,7 +54,7 @@ declare module 'readline' {
      * and is read from, the `input` stream.
      * @since v0.1.104
      */
-    class Interface extends EventEmitter {
+    export class Interface extends EventEmitter {
         readonly terminal: boolean;
         /**
          * The current input data being processed by node.
@@ -314,11 +321,11 @@ declare module 'readline' {
         prependOnceListener(event: 'history', listener: (history: string[]) => void): this;
         [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     }
-    type ReadLine = Interface; // type forwarded for backwards compatibility
-    type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
-    type CompleterResult = [string[], string];
-    interface ReadLineOptions {
+    export type ReadLine = Interface; // type forwarded for backwards compatibility
+    export type Completer = (line: string) => CompleterResult;
+    export type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
+    export type CompleterResult = [string[], string];
+    export interface ReadLineOptions {
         input: NodeJS.ReadableStream;
         output?: NodeJS.WritableStream | undefined;
         completer?: Completer | AsyncCompleter | undefined;
@@ -379,8 +386,8 @@ declare module 'readline' {
      * ```
      * @since v0.1.98
      */
-    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
-    function createInterface(options: ReadLineOptions): Interface;
+    export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    export function createInterface(options: ReadLineOptions): Interface;
     /**
      * The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
      *
@@ -397,11 +404,114 @@ declare module 'readline' {
      * if (process.stdin.isTTY)
      *   process.stdin.setRawMode(true);
      * ```
+     *
+     * ## Example: Tiny CLI
+     *
+     * The following example illustrates the use of `readline.Interface` class to
+     * implement a small command-line interface:
+     *
+     * ```js
+     * const readline = require('readline');
+     * const rl = readline.createInterface({
+     *   input: process.stdin,
+     *   output: process.stdout,
+     *   prompt: 'OHAI> '
+     * });
+     *
+     * rl.prompt();
+     *
+     * rl.on('line', (line) => {
+     *   switch (line.trim()) {
+     *     case 'hello':
+     *       console.log('world!');
+     *       break;
+     *     default:
+     *       console.log(`Say what? I might have heard '${line.trim()}'`);
+     *       break;
+     *   }
+     *   rl.prompt();
+     * }).on('close', () => {
+     *   console.log('Have a great day!');
+     *   process.exit(0);
+     * });
+     * ```
+     *
+     * ## Example: Read file stream line-by-Line
+     *
+     * A common use case for `readline` is to consume an input file one line at a
+     * time. The easiest way to do so is leveraging the `fs.ReadStream` API as
+     * well as a `for await...of` loop:
+     *
+     * ```js
+     * const fs = require('fs');
+     * const readline = require('readline');
+     *
+     * async function processLineByLine() {
+     *   const fileStream = fs.createReadStream('input.txt');
+     *
+     *   const rl = readline.createInterface({
+     *     input: fileStream,
+     *     crlfDelay: Infinity
+     *   });
+     *   // Note: we use the crlfDelay option to recognize all instances of CR LF
+     *   // ('\r\n') in input.txt as a single line break.
+     *
+     *   for await (const line of rl) {
+     *     // Each line in input.txt will be successively available here as `line`.
+     *     console.log(`Line from file: ${line}`);
+     *   }
+     * }
+     *
+     * processLineByLine();
+     * ```
+     *
+     * Alternatively, one could use the `'line'` event:
+     *
+     * ```js
+     * const fs = require('fs');
+     * const readline = require('readline');
+     *
+     * const rl = readline.createInterface({
+     *   input: fs.createReadStream('sample.txt'),
+     *   crlfDelay: Infinity
+     * });
+     *
+     * rl.on('line', (line) => {
+     *   console.log(`Line from file: ${line}`);
+     * });
+     * ```
+     *
+     * Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
+     *
+     * ```js
+     * const { once } = require('events');
+     * const { createReadStream } = require('fs');
+     * const { createInterface } = require('readline');
+     *
+     * (async function processLineByLine() {
+     *   try {
+     *     const rl = createInterface({
+     *       input: createReadStream('big-file.txt'),
+     *       crlfDelay: Infinity
+     *     });
+     *
+     *     rl.on('line', (line) => {
+     *       // Process the line.
+     *     });
+     *
+     *     await once(rl, 'close');
+     *
+     *     console.log('File processed.');
+     *   } catch (err) {
+     *     console.error(err);
+     *   }
+     * })();
+     * ```
      * @since v0.7.7
      */
-    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
-    type Direction = -1 | 0 | 1;
-    interface CursorPos {
+    export function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+    export type Direction = -1 | 0 | 1;
+    export interface CursorPos {
         rows: number;
         cols: number;
     }
@@ -412,7 +522,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    export function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
     /**
      * The `readline.clearScreenDown()` method clears the given `TTY` stream from
      * the current position of the cursor down.
@@ -420,7 +530,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    export function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
     /**
      * The `readline.cursorTo()` method moves cursor to the specified position in a
      * given `TTY` `stream`.
@@ -428,7 +538,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    export function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
     /**
      * The `readline.moveCursor()` method moves the cursor _relative_ to its current
      * position in a given `TTY` `stream`.
@@ -539,7 +649,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+    export function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
 declare module 'node:readline' {
     export * from 'readline';

package/public/types/node/stream/consumers.d.ts

@@ -1,9 +1,9 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 declare module 'stream/consumers' {
-    import { Readable } from 'node:stream';
     import { Blob as NodeBlob } from "node:buffer";
+    import { Readable } from 'node:stream';
     function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Buffer>;
     function text(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<string>;
     function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<ArrayBuffer>;

package/public/types/node/stream/promises.d.ts

@@ -1,5 +1,5 @@
 
-/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/Steve-Mcl/monaco-editor-esm-i18n */
+/* NOTE: Do not edit directly! This file is generated using `npm run update-types` in https://github.com/node-red/nr-monaco-build */
 
 declare module 'stream/promises' {
     import { FinishedOptions, PipelineSource, PipelineTransform, PipelineDestination, PipelinePromise, PipelineOptions } from 'node:stream';