@scriptc/compiler 0.3.4 → 0.3.6

package/dist/frontend/lowering/builtins/readline.d.ts

@@ -6,23 +6,55 @@ import { type IrExpr, type SrcLoc } from "../../../ir/ir.js";
  * module — the name alone is too generic). The interface maps to an f64
  * handle, so the IR type cannot discriminate it from a plain number. */
 export declare function isReadlineTyped(lowerer: Lowerer, node: ts.Expression): boolean;
+/** new Readline(stream, options?) from readline/promises: the stream is
+ * process.stdout, process.stderr or a writable stream (checked with
+ * isWritable at runtime), the options an object literal with a boolean
+ * autoCommit. Null for other constructors. */
+export declare function lowerReadlineUiNew(lowerer: Lowerer, expr: ts.NewExpression): IrExpr | null;
 /** Method calls on readline Interface receivers (both modules):
  * - question(query, cb) — the callback form; question(query, { signal }?)
  *   — the promise form (readline/promises);
- * - close(), pause(), resume(), prompt(), setPrompt(p), getPrompt(),
- *   write(data);
+ * - close(), pause(), resume(), prompt(preserveCursor?), setPrompt(p),
+ *   getPrompt(), write(data, key?);
  * - on/once/addListener for 'line' ((input: string) or no parameters),
- *   'close'/'pause'/'resume' (no parameters) and 'error' ((err: Error) or
- *   no parameters), as statements.
+ *   'error' ((err: Error) or no parameters), 'history' ((history:
+ *   string[]) or no parameters), and 'close'/'pause'/'resume'/'SIGINT'/
+ *   'SIGTSTP'/'SIGCONT' (no parameters), as statements.
  * Everything else the lib declares fences member-qualified. Null for
  * non-Interface receivers. */
 export declare function lowerReadlineMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** createInterface({ input, output?, terminal?: false, crlfDelay?,
- * prompt?, signal? }) or createInterface(input, output?), from
- * node:readline or node:readline/promises. The input is process.stdin
- * or a readable stream; the output process.stdout, a writable stream, or
- * absent (prompts are then not written). rl.create's arguments: the mode
- * literal (1 stream input, 2 stream output, 4 stdout output, 8 signal,
- * 16 prompt), then the input and output streams when present, crlfDelay,
- * the prompt and the signal when present. */
-export declare function lowerReadlineCreateCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc): IrExpr;
+/** Checks a 'keypress' listener (process.stdin or a readable stream): the
+ * first argument is undefined for escape sequences, so a typed first
+ * parameter must admit undefined, and the key is readline.Key. */
+export declare function checkKeypressListener(lowerer: Lowerer, node: ts.Expression, cb: IrExpr): void;
+/** process.stdin's 'keypress' listener as the checked-dynamic function the
+ * runtime calls with (str, key). */
+export declare function stdinKeypressListener(lowerer: Lowerer, node: ts.Expression): IrExpr;
+/** readline.cursorTo(stream, x[, y][, callback]), moveCursor(stream, dx,
+ * dy[, callback]), clearLine(stream, dir[, callback]) and
+ * clearScreenDown(stream[, callback]). The stream is process.stdout,
+ * process.stderr, a writable stream, or null/undefined (nothing is
+ * written and the callback runs on the next tick). The arguments are
+ * evaluated in order; rl.seq checks them (NaN coordinates throw
+ * ERR_INVALID_ARG_VALUE) and builds the escape sequence, which goes
+ * through the stream's own write. The result is write()'s boolean, or
+ * true. */
+export declare function lowerReadlineCursorCall(lowerer: Lowerer, expr: ts.CallExpression, member: string, loc: SrcLoc): IrExpr | null;
+/** createInterface({ input, output?, terminal?, crlfDelay?, prompt?,
+ * signal?, ... }) or createInterface(input, output?, completer?,
+ * terminal?), from node:readline or node:readline/promises. The input is process.stdin or a readable
+ * stream; the output process.stdout, a writable stream, or absent
+ * (prompts are then not written). rl.create's arguments: the mode literal
+ * (1 stream input, 2 stream output, 4 stdout output, 8 signal, 16
+ * prompt), then the input and output streams when present, crlfDelay,
+ * the prompt and the signal when present. An interface that can be a
+ * terminal one (a `terminal` option that is not false, or none with
+ * process.stdout as the output, which is a terminal when it is a TTY)
+ * goes through rl.terminal with the completer. */
+export declare function lowerReadlineCreateCall(lowerer: Lowerer, expr: ts.CallExpression, loc: SrcLoc, promises: boolean): IrExpr;
+/** Property reads on an Interface: `history` (the history option itself,
+ * or the interface's own empty array), `historySize`, `historyIndex`,
+ * `crlfDelay`, `tabSize`, `escapeCodeTimeout`, `line`, `terminal` and
+ * `cursor` (a non-terminal interface's undefined cursor throws SC2020).
+ * Null for other receivers. */
+export declare function lowerReadlineProperty(lowerer: Lowerer, access: ts.PropertyAccessExpression): IrExpr | null;