@zaly/tui 0.0.4

package/dist/input-B5Vy-iaa.d.mts

@@ -0,0 +1,141 @@
+import { Nt as Size, P as RenderCtx, Z as StyleState, f as BaseEvents, nt as Reactive, p as Node } from "./queries-DH3bj74K.mjs";
+import { a as StyleBuilder } from "./inspect-D6FW_QUo.mjs";
+import { MaybePromise } from "@zaly/shared";
+import { DetectedFile } from "@zaly/shared/detect";
+//#region src/widgets/input.d.ts
+interface InputState extends StyleState {
+  /** Current text content. May include `\n` for multi-line input. */
+  value?: string;
+  /** Shown dim when `value` is empty. */
+  placeholder?: Reactive<string | undefined>;
+  /** Cursor position as a char index in `value`. Clamped to `[0, value.length]`. */
+  cursor?: number;
+  /** Render width. Defaults to `fill`. */
+  width?: Size;
+  /** Submitted input history, newest last. */
+  history?: readonly string[];
+  /** Threshold for showing pasted content as an attachment rather than raw text */
+  pasteMaxLines?: number;
+  pasteMaxChars?: number;
+  canAttach?: (file: InputAttachment) => boolean;
+  format?: (value: string, ctx: {
+    style: StyleBuilder;
+  }) => MaybePromise<string>;
+  validate?: (value: string) => boolean;
+}
+type InputValue = {
+  value: string;
+  attachments: InputAttachment[];
+};
+/** A clipboard or bracketed paste that exceeds the `pasteMax*` thresholds. **/
+type Paste = {
+  type: "paste";
+  text: string;
+};
+/** A file or image attachment detected from the clipboard. */
+type InputAttachment = DetectedFile & {
+  path: string;
+};
+type InputEvents = BaseEvents & {
+  /** Fired when the submitted history changes. */
+  history: {
+    history: string[];
+    added: string;
+  };
+  /** Fired when plain Enter is pressed. Payload is the current value. */
+  submit: {
+    value: string;
+    attachments: InputAttachment[];
+  };
+  /** Fired when the user pastes a non-text resource via the
+   *  `input.paste` action. Images and file references both land here,
+   *  discriminated by `attachment.kind`. One event fires per image
+   *  paste; one per file in a multi-file paste.
+   *
+   *  Wrapped under `attachment` because `InputAttachment` carries its
+   *  own `type` field (MIME) that would shadow the envelope's `type`
+   *  discriminator if spread directly. */
+  attach: {
+    attachment: InputAttachment;
+  };
+};
+/**
+ * Multi-line text input with auto-grow.
+ *
+ * Editing commands (`cursorLeft`, `deleteWordBack`, `submit`, …) live on
+ * `this.actions` as zero-arg methods. The input router maps keymap
+ * bindings like `"input.cursorLeft"` onto those methods — users bind
+ * different keys by configuring the keymap, not by patching the class.
+ * The methods are also callable directly (`input.actions.submit()`),
+ * which is handy in tests or for higher-level macros.
+ *
+ * What this class *still* handles via its `key` event listener:
+ *   - **Printable character insertion.** An unbound keystroke whose
+ *     `text` is set and has no ctrl/alt/meta modifier becomes a literal
+ *     insert at the cursor. There's no action for every printable char
+ *     in the keymap; the raw-key fallback handles them.
+ *   - **Paste events.** Whole payload inserted at cursor; always.
+ *
+ * Everything else (navigation, editing, submit/newline) goes through
+ * the router → actions pipeline. Unbound non-printable keys fall back
+ * to `emit("key", …)` and bubble to the parent chain.
+ *
+ * Rendering word-wraps each logical line to `ctx.width`, so long
+ * messages naturally grow vertically. The UI surface resizes its
+ * reserved footer when the Input's row count changes, so the stream
+ * above shifts accordingly.
+ */
+declare class Input extends Node<InputState, InputEvents> {
+  #private;
+  /** Class-level scope tag used by the input router to bind keymaps. */
+  static readonly type = "input";
+  readonly type = "input";
+  /**
+   * Editing actions. Parameterless — they close over `this` — so both
+   * the router (via keymap dispatch) and application code can invoke
+   * them. Add to the keymap in `src/input/actions.ts` to give them
+   * default key bindings.
+   */
+  actions: {
+    "input.cursorDown": () => void;
+    "input.cursorLeft": () => void;
+    "input.cursorLineEnd": () => void;
+    "input.cursorLineStart": () => void;
+    "input.cursorRight": () => void;
+    "input.cursorUp": () => void;
+    "input.deleteCharBack": () => void;
+    "input.deleteCharForward": () => void;
+    "input.deleteWordBack": () => void;
+    "input.insertNewline": () => void;
+    "input.insertTab": () => void;
+    "input.paste": () => void;
+    "input.submit": () => void;
+  };
+  constructor(initial?: InputState);
+  get history(): readonly string[];
+  set history(v: readonly string[]);
+  attach(att: InputAttachment | Paste): void;
+  paste(text: string): void;
+  insert(text: string): void;
+  replace(text: string): void;
+  /** Consume the input's current value and attachments.
+   * Pastes are replaced inline with their text; file/image
+   * attachments are returned in the `attachments` array and removed from the value. */
+  consume(): InputValue;
+  historyAdd(value: string): void;
+  protected _render(ctx: RenderCtx): Promise<string[]>;
+}
+/**
+ * Factory for `Input`. All fields optional; default is an empty,
+ * focusable input that fills `ctx.width` and has no placeholder.
+ *
+ * ```ts
+ * input({ placeholder: "type a message…" })
+ * const i = input({ value: "draft" })
+ * i.on("submit", (text) => console.log("user typed", text))
+ * ```
+ */
+declare function input(state?: InputState): Input;
+//#endregion
+export { InputValue as a, InputState as i, InputAttachment as n, input as o, InputEvents as r, Input as t };
+//# sourceMappingURL=input-B5Vy-iaa.d.mts.map

package/dist/input-B5Vy-iaa.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-B5Vy-iaa.d.mts","names":[],"sources":["../src/widgets/input.ts"],"mappings":";;;;;UAoBiB,mBAAmB;;EAElC;;EAEA,cAAc;;EAEd;;EAEA,QAAQ;;EAER;;EAEA;EACA;EACA,aAAa,MAAM;EACnB,UAAU,eAAe;IAAO,OAAO;QAAmB;EAC1D,YAAY;;KAGF;EAAe;EAAe,aAAa;;;KAMlD;EAAU;EAAe;;;KAGlB,kBAAkB;EAAiB;;KAEnC,cAAc;;EAExB;IAAW;IAAmB;;;EAE9B;IAAU;IAAe,aAAa;;;;;;;;;;EAStC;IAAU,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BX,cAAc,KAAK,YAAY;;;kBAE1B;WAEE;;;;;;;EAgBT;;;;;;;;;;;;;;;EAyJT,YAAY,UAAS;MA2BjB;MAIA,QAAQ;EAKZ,OAAO,KAAK,kBAAkB;EAqB9B,MAAM;EASN,OAAO;EAWP,QAAQ;;;;EAQR,WAAW;EA2BX,WAAW;YAqHK,QAAQ,KAAK,YAAY;;;;;;;;;;;;iBAyD3B,MAAM,QAAO,aAAkB"}

package/dist/inspect-D1d9t-ni.mjs

@@ -0,0 +1,101 @@
+import { t as styleBuilder } from "./builder-D49ECBEf.mjs";
+import { hasAnsi } from "@zaly/shared/ansi";
+import { hasColors } from "@zaly/shared/env";
+import { formatWithOptions, inspect } from "node:util";
+//#region src/style/inspect.ts
+const MD_RE = /[`*_#[\]\->~|]/;
+const JSON_RE = /^\s*[{[]/;
+const FORMAT_RE = /%[sdifjoOc%]/;
+/** True when `s` looks like markdown we should render — contains MD
+*  markers and isn't already ANSI-styled. Mirrors rekal's `Formatter.markdown`
+*  skip test so we avoid double-rendering pre-styled strings. */
+function isMarkdown(s) {
+	return MD_RE.test(s) && !hasAnsi(s) && !JSON_RE.test(s);
+}
+const isFormatString = (v) => typeof v === "string" && FORMAT_RE.test(v) && !hasAnsi(v);
+/**
+* Inspect a list of args the way `console.log` does, returning a single
+* string. Collapses `util.format` placeholders right-to-left, unwraps
+* `Error` values to their message (unless `stacktrace: true`), and falls
+* back to `util.formatWithOptions` for mixed values.
+*/
+function inspectFormat(msg, opts = {}) {
+	const data = opts.stacktrace ? msg : msg.map((v) => v instanceof Error ? v.message : v);
+	opts = {
+		colors: hasColors,
+		...opts
+	};
+	let ret = [];
+	for (let i = data.length - 1; i >= 0; i--) {
+		const item = data[i];
+		if (isFormatString(item)) ret = [formatWithOptions(opts, item, ...ret)];
+		else ret.unshift(item);
+	}
+	if (ret.length > 1 && isFormatString(ret[0])) return formatWithOptions(opts, ...ret);
+	return ret.map((v) => typeof v === "string" ? v : inspect$1(v, opts)).join(" ");
+}
+function inspectNumber(value) {
+	return new Intl.NumberFormat("en-US", {
+		notation: "standard",
+		useGrouping: true
+	}).format(value).replace(/,/g, "_");
+}
+function inspectField(key, s) {
+	if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) return s.syntaxField(key);
+	return s.syntaxString(JSON.stringify(key));
+}
+function inspect$1(value, opts = {}) {
+	opts = {
+		colors: hasColors,
+		null: true,
+		undefined: true,
+		...opts
+	};
+	const indent = opts.indent ?? 2;
+	const s = opts.colors ? opts.style ?? styleBuilder() : styleBuilder(false);
+	const sym = {
+		",": s.syntaxDelimiter(","),
+		":": s.syntaxDelimiter(":"),
+		"[": s.syntaxBracket("["),
+		"]": s.syntaxBracket("]"),
+		"{": s.syntaxBracket("{"),
+		"}": s.syntaxBracket("}")
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const $inspect = (v, depth) => {
+		if (seen.has(v)) return s.bold("[Circular]");
+		if (typeof v === "object" && v !== null) seen.add(v);
+		if (v === null) return s.syntaxConstant("null");
+		switch (typeof v) {
+			case "boolean": return s.syntaxBoolean(String(v));
+			case "bigint": return s.syntaxNumber(`${v}n`);
+			case "number": return s.syntaxNumber(inspectNumber(v));
+			case "string": return s.syntaxString(JSON.stringify(v));
+			case "symbol": return s.syntaxSpecial(String(v));
+			case "function": return s.syntaxFunction(`[Function${v.name ? `: ${v.name}` : ""}]`);
+			case "undefined": return s.syntaxConstant("undefined");
+			case "object": {
+				if (Array.isArray(v)) {
+					const items = v.map((item) => $inspect(item, depth + 1));
+					return `${sym["["]} ${items.join(`${sym[","]} `)} ${sym["]"]}`;
+				}
+				if (!(Object.getPrototypeOf(v) === Object.prototype)) break;
+				const entries = Object.entries(v).filter(([_, val]) => !(val === void 0 && !opts.undefined || val === null && !opts.null)).map(([key, val]) => `${inspectField(key, s)}: ${$inspect(val, depth + 1)}`);
+				if (indent) {
+					const padding = " ".repeat(indent * depth);
+					return `${sym["{"]}\n${padding}${entries.join(`${sym[","]}\n${padding}`)}\n${" ".repeat(indent * (depth - 1))}${sym["}"]}`;
+				}
+				return `${sym["{"]} ${entries.join(`${sym[","]} `)} ${sym["}"]}`;
+			}
+		}
+		return inspect(v, {
+			colors: true,
+			compact: true
+		});
+	};
+	return $inspect(value, 1);
+}
+//#endregion
+export { inspectFormat as n, isMarkdown as r, inspect$1 as t };
+
+//# sourceMappingURL=inspect-D1d9t-ni.mjs.map

package/dist/inspect-D1d9t-ni.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-D1d9t-ni.mjs","names":["inspect","nodeInspect"],"sources":["../src/style/inspect.ts"],"sourcesContent":["import type { StyleBuilder } from \"./builder.ts\"\n\nimport { hasAnsi } from \"@zaly/shared/ansi\"\nimport { hasColors } from \"@zaly/shared/env\"\nimport { formatWithOptions, inspect as nodeInspect } from \"node:util\"\nimport { styleBuilder } from \"./builder.ts\"\n\nexport interface InspectOpts {\n  style?: StyleBuilder\n  indent?: number\n  undefined?: boolean\n  null?: boolean\n  /** When `true`, preserve Error stack traces. Default: `false` — Error\n   *  values are reduced to their `.message` so logs stay compact. */\n  stacktrace?: boolean\n  colors?: boolean\n}\n\n// Markdown-ish characters. Matches rekal's skip regex.\nconst MD_RE = /[`*_#[\\]\\->~|]/\nconst JSON_RE = /^\\s*[{[]/\n\n// `util.format` placeholder tokens (`%s`, `%d`, …).\nconst FORMAT_RE = /%[sdifjoOc%]/\n\n/** True when `s` looks like markdown we should render — contains MD\n *  markers and isn't already ANSI-styled. Mirrors rekal's `Formatter.markdown`\n *  skip test so we avoid double-rendering pre-styled strings. */\nexport function isMarkdown(s: string): boolean {\n  return MD_RE.test(s) && !hasAnsi(s) && !JSON_RE.test(s)\n}\n\nconst isFormatString = (v: unknown): v is string =>\n  typeof v === \"string\" && FORMAT_RE.test(v) && !hasAnsi(v)\n\n/**\n * Inspect a list of args the way `console.log` does, returning a single\n * string. Collapses `util.format` placeholders right-to-left, unwraps\n * `Error` values to their message (unless `stacktrace: true`), and falls\n * back to `util.formatWithOptions` for mixed values.\n */\nexport function inspectFormat(msg: unknown[], opts: InspectOpts = {}): string {\n  const data = opts.stacktrace ? msg : msg.map((v) => (v instanceof Error ? v.message : v))\n  opts = { colors: hasColors, ...opts }\n\n  let ret: unknown[] = []\n  // oxlint-disable-next-line oxc/no-accumulating-spread\n  for (let i = data.length - 1; i >= 0; i--) {\n    const item = data[i]\n    if (isFormatString(item)) ret = [formatWithOptions(opts, item, ...ret)]\n    else ret.unshift(item)\n  }\n\n  if (ret.length > 1 && isFormatString(ret[0])) return formatWithOptions(opts, ...ret)\n  return ret.map((v) => (typeof v === \"string\" ? v : inspect(v, opts))).join(\" \")\n}\n\nfunction inspectNumber(value: number): string {\n  return new Intl.NumberFormat(\"en-US\", {\n    notation: \"standard\",\n    useGrouping: true,\n  })\n    .format(value)\n    .replace(/,/g, \"_\")\n}\n\nfunction inspectField(key: string, s: StyleBuilder): string {\n  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) return s.syntaxField(key)\n  return s.syntaxString(JSON.stringify(key))\n}\n\nexport function inspect(value: unknown, opts: InspectOpts = {}): string {\n  opts = { colors: hasColors, null: true, undefined: true, ...opts }\n  const indent = opts.indent ?? 2\n  const s = opts.colors ? (opts.style ?? styleBuilder()) : styleBuilder(false)\n  const sym = {\n    \",\": s.syntaxDelimiter(\",\"),\n    \":\": s.syntaxDelimiter(\":\"),\n    \"[\": s.syntaxBracket(\"[\"),\n    \"]\": s.syntaxBracket(\"]\"),\n    \"{\": s.syntaxBracket(\"{\"),\n    \"}\": s.syntaxBracket(\"}\"),\n  }\n  const seen = new Set()\n\n  const $inspect = (v: unknown, depth: number): string => {\n    if (seen.has(v)) return s.bold(\"[Circular]\")\n    if (typeof v === \"object\" && v !== null) seen.add(v)\n    if (v === null) return s.syntaxConstant(\"null\")\n    switch (typeof v) {\n      case \"boolean\": {\n        return s.syntaxBoolean(String(v))\n      }\n      case \"bigint\": {\n        return s.syntaxNumber(`${v}n`)\n      }\n      case \"number\": {\n        return s.syntaxNumber(inspectNumber(v))\n      }\n      case \"string\": {\n        return s.syntaxString(JSON.stringify(v))\n      }\n      case \"symbol\": {\n        return s.syntaxSpecial(String(v))\n      }\n      case \"function\": {\n        return s.syntaxFunction(`[Function${v.name ? `: ${v.name}` : \"\"}]`)\n      }\n      case \"undefined\": {\n        return s.syntaxConstant(\"undefined\")\n      }\n      case \"object\": {\n        if (Array.isArray(v)) {\n          const items = v.map((item) => $inspect(item, depth + 1))\n          return `${sym[\"[\"]} ${items.join(`${sym[\",\"]} `)} ${sym[\"]\"]}`\n        }\n        const isPlainObject = Object.getPrototypeOf(v) === Object.prototype\n        if (!isPlainObject) break\n        const entries = Object.entries(v)\n          .filter(\n            ([_, val]) => !((val === undefined && !opts.undefined) || (val === null && !opts.null))\n          )\n          .map(([key, val]) => `${inspectField(key, s)}: ${$inspect(val, depth + 1)}`)\n        if (indent) {\n          const padding = \" \".repeat(indent * depth)\n          return `${sym[\"{\"]}\\n${padding}${entries.join(`${sym[\",\"]}\\n${padding}`)}\\n${\" \".repeat(indent * (depth - 1))}${sym[\"}\"]}`\n        }\n        return `${sym[\"{\"]} ${entries.join(`${sym[\",\"]} `)} ${sym[\"}\"]}`\n      }\n    }\n    return nodeInspect(v, { colors: true, compact: true })\n  }\n  return $inspect(value, 1)\n}\n"],"mappings":"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"}

package/dist/inspect-D6FW_QUo.d.mts

@@ -0,0 +1,67 @@
+import { c as Color, f as Style, i as AnsiColorName, s as BrightAnsiColorName, t as Theme } from "./types-B9Eh7k2v.mjs";
+//#region src/style/builder.d.ts
+type AttrName = "bold" | "dim" | "italic" | "underline" | "inverse" | "strikethrough";
+type AnyThemeKey = Exclude<keyof Theme, "shiki" | "$schema"> | (string & {});
+type ChainSlot = Exclude<keyof Theme, "fg" | "bg" | AttrName>;
+type FgChainKey = AnsiColorName | BrightAnsiColorName | ChainSlot;
+type BgChainKey = `bg${Capitalize<FgChainKey>}`;
+type FgExtractKey = `fg${Capitalize<FgChainKey>}`;
+type StyleBuilder = {
+  theme: Theme;
+  (text: string): string;
+  fg: (color: Color) => StyleBuilder;
+  bg: (color: Color) => StyleBuilder;
+  add: (slot?: AnyThemeKey | Style) => StyleBuilder;
+  lighten: (n: number) => StyleBuilder;
+  darken: (n: number) => StyleBuilder;
+} & { readonly [K in AttrName | FgChainKey | BgChainKey | FgExtractKey]: StyleBuilder; };
+/**
+ * Build styled strings via chainable property access.
+ *
+ * ```ts
+ * style().red.bold("err")            // → "\x1b[1;31merr\x1b[0m"
+ * style().primary.bgAccent("x")      // theme slots via the default theme
+ * style(myTheme).primary("x")         // override the bound theme
+ * style().fg("#82aaff")("x")          // hex via the escape hatch
+ * style().primary[300]("x")           // tonal variant of the last color
+ * style().bgDiffAdd[200].fgDiffAdd("x") // per-channel variants on a Style slot
+ * ```
+ *
+ * Each property access returns a fresh builder, so intermediates can be
+ * reused and extended without mutation:
+ *
+ * ```ts
+ * const err = style().red.bold
+ * err("oops"); err.underline("fatal")
+ * ```
+ *
+ * Calling an empty builder is a no-op: `styleBuilder()("x")` returns `"x"` unchanged.
+ */
+declare function styleBuilder(theme?: Theme | false): StyleBuilder;
+//#endregion
+//#region src/style/inspect.d.ts
+interface InspectOpts {
+  style?: StyleBuilder;
+  indent?: number;
+  undefined?: boolean;
+  null?: boolean;
+  /** When `true`, preserve Error stack traces. Default: `false` — Error
+   *  values are reduced to their `.message` so logs stay compact. */
+  stacktrace?: boolean;
+  colors?: boolean;
+}
+/** True when `s` looks like markdown we should render — contains MD
+ *  markers and isn't already ANSI-styled. Mirrors rekal's `Formatter.markdown`
+ *  skip test so we avoid double-rendering pre-styled strings. */
+declare function isMarkdown(s: string): boolean;
+/**
+ * Inspect a list of args the way `console.log` does, returning a single
+ * string. Collapses `util.format` placeholders right-to-left, unwraps
+ * `Error` values to their message (unless `stacktrace: true`), and falls
+ * back to `util.formatWithOptions` for mixed values.
+ */
+declare function inspectFormat(msg: unknown[], opts?: InspectOpts): string;
+declare function inspect(value: unknown, opts?: InspectOpts): string;
+//#endregion
+export { StyleBuilder as a, isMarkdown as i, inspect as n, styleBuilder as o, inspectFormat as r, InspectOpts as t };
+//# sourceMappingURL=inspect-D6FW_QUo.d.mts.map

package/dist/inspect-D6FW_QUo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-D6FW_QUo.d.mts","names":[],"sources":["../src/style/builder.ts","../src/style/inspect.ts"],"mappings":";;KAOK;KAEA,cAAc,cAAc;KAK5B,YAAY,cAAc,qBAAqB;KAE/C,aAAa,gBAAgB,sBAAsB;KACnD,kBAAkB,WAAW;KAC7B,oBAAoB,WAAW;KAExB;EACV,OAAO;GACN;EACD,KAAK,OAAO,UAAU;EACtB,KAAK,OAAO,UAAU;EACtB,MAAM,OAAO,cAAc,UAAU;EACrC,UAAU,cAAc;EACxB,SAAS,cAAc;gBAGb,KAAK,WAAW,aAAa,aAAa,eAAe;;;;;;;;;;;;;;;;;;;;;;;iBAyBrD,aAAa,QAAO,gBAA+B;;;UChDlD;EACf,QAAQ;EACR;EACA;EACA;;;EAGA;EACA;;;;;iBAac,WAAW;;;;;;;iBAaX,cAAc,gBAAgB,OAAM;iBA8BpC,QAAQ,gBAAgB,OAAM"}