@zaly/tui 0.0.4

package/dist/types-D3jk1rtk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D3jk1rtk.d.mts","names":[],"sources":["../src/markdown/types.ts"],"mappings":";UAEiB;;EAEf;;EAEA;;UAGe;;EAEf;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;UAGe;;EAEf;;EAEA;;UAGe;;EAEf;;EAEA;;KAGU,YAAY;KACZ,OAAO,MAAM,kBAAkB,MAAM;UAEhC;;EAEf;;EAEA;;;;;;;;UASe;EACf,UAAU,OAAO;EACjB,YAAY;EACZ,aAAa;EACb,QAAQ,kBAAkB,OAAO;EACjC,OAAO,OAAO;EACd,WAAW,OAAO;EAClB,KAAK;EACL,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,KAAK;EACL,MAAM,kBAAkB,OAAO;EAC/B,MAAM,kBAAkB,OAAO;EAC/B,OAAO;EACP,SAAS;EACT,WAAW;EACX,OAAO,OAAO;EACd,QAAQ,OAAO;EACf,WAAW;EACX,gBAAgB;EAChB,QAAQ;;;;;;;KAQE,kBAAkB,eAAe,WAAW,aAAa,OAAO;;;;;UAM3D;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;IAAwB;IAAe;IAAe;;;EAEtD;IAAuB;IAAe;;;;;;;;;EAQtC,SAAS"}

package/dist/utils-3M4D_AXZ.mjs

@@ -0,0 +1,40 @@
+/**
+* Replace spaces inside every fenced-block info-string with `FENCE_MARKER`
+* so renderers that truncate after the first token (Bun) still surface the
+* full info-string as the first token. Inverse of the decode step done by
+* `parseCodeInfoString`.
+*
+* Closing fences (just ``` with optional trailing whitespace) are left
+* untouched — rewriting their spaces into markers would prevent the
+* parser from recognizing the closer, swallowing the rest of the document
+* as code.
+*/
+function encodeFenceInfoStrings(md) {
+	return md.replaceAll(/^( {0,3}`{3,})([^\n]*)$/gm, (match, fence, info) => info.trim() === "" ? match : fence + info.replaceAll(" ", "\0"));
+}
+/**
+* Parse a fenced code-block info-string like `jsx title="src/Hello.js"`.
+* First token → language; `title="..."` / `title='...'` → title. Unknown
+* attrs after the language are ignored.
+*
+* Input may carry `FENCE_MARKER` in place of spaces (from
+* `encodeFenceInfoStrings`); those are decoded before parsing.
+*/
+function parseCodeInfoString(info) {
+	if (!info) return void 0;
+	const decoded = info.includes("\0") ? info.replaceAll("\0", " ") : info;
+	const firstSpace = decoded.search(/\s/);
+	if (firstSpace === -1) return { language: decoded };
+	const language = decoded.slice(0, firstSpace);
+	const rest = decoded.slice(firstSpace + 1);
+	const titleMatch = /title=(?:"([^"]*)"|'([^']*)')/.exec(rest);
+	const title = titleMatch === null ? void 0 : titleMatch[1] ?? titleMatch[2];
+	const meta = {};
+	if (language !== "") meta.language = language;
+	if (title !== void 0) meta.title = title;
+	return meta;
+}
+//#endregion
+export { parseCodeInfoString as n, encodeFenceInfoStrings as t };
+
+//# sourceMappingURL=utils-3M4D_AXZ.mjs.map

package/dist/utils-3M4D_AXZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-3M4D_AXZ.mjs","names":[],"sources":["../src/markdown/utils.ts"],"sourcesContent":["// Lightweight string-level utilities for the markdown pipeline. Lives in\n// its own file so Bun callers can use them without pulling in `marked`\n// (which is the heavy dep in `src/md.ts`).\n\nimport type { MdCodeBlockMeta } from \"./types.ts\"\n\n/** Sentinel stitched into fence info-strings in place of spaces. */\nexport const FENCE_MARKER = \"\\u0000\"\n\n/**\n * Replace spaces inside every fenced-block info-string with `FENCE_MARKER`\n * so renderers that truncate after the first token (Bun) still surface the\n * full info-string as the first token. Inverse of the decode step done by\n * `parseCodeInfoString`.\n *\n * Closing fences (just ``` with optional trailing whitespace) are left\n * untouched — rewriting their spaces into markers would prevent the\n * parser from recognizing the closer, swallowing the rest of the document\n * as code.\n */\nexport function encodeFenceInfoStrings(md: string): string {\n  return md.replaceAll(/^( {0,3}`{3,})([^\\n]*)$/gm, (match, fence: string, info: string) =>\n    info.trim() === \"\" ? match : fence + info.replaceAll(\" \", FENCE_MARKER)\n  )\n}\n\n/**\n * Parse a fenced code-block info-string like `jsx title=\"src/Hello.js\"`.\n * First token → language; `title=\"...\"` / `title='...'` → title. Unknown\n * attrs after the language are ignored.\n *\n * Input may carry `FENCE_MARKER` in place of spaces (from\n * `encodeFenceInfoStrings`); those are decoded before parsing.\n */\nexport function parseCodeInfoString(info: string | undefined): MdCodeBlockMeta | undefined {\n  if (!info) return undefined\n  const decoded = info.includes(FENCE_MARKER) ? info.replaceAll(FENCE_MARKER, \" \") : info\n  const firstSpace = decoded.search(/\\s/)\n  if (firstSpace === -1) return { language: decoded }\n  const language = decoded.slice(0, firstSpace)\n  const rest = decoded.slice(firstSpace + 1)\n  const titleMatch = /title=(?:\"([^\"]*)\"|'([^']*)')/.exec(rest) as\n    | [string, string | undefined, string | undefined]\n    | null\n  const title = titleMatch === null ? undefined : (titleMatch[1] ?? titleMatch[2])\n  const meta: MdCodeBlockMeta = {}\n  if (language !== \"\") meta.language = language\n  if (title !== undefined) meta.title = title\n  return meta\n}\n"],"mappings":";;;;;;;;;;;AAoBA,SAAgB,uBAAuB,IAAoB;CACzD,OAAO,GAAG,WAAW,8BAA8B,OAAO,OAAe,SACvE,KAAK,KAAK,MAAM,KAAK,QAAQ,QAAQ,KAAK,WAAW,KAAA,IAAiB,CACxE;AACF;;;;;;;;;AAUA,SAAgB,oBAAoB,MAAuD;CACzF,IAAI,CAAC,MAAM,OAAO,KAAA;CAClB,MAAM,UAAU,KAAK,SAAA,IAAqB,IAAI,KAAK,WAAA,MAAyB,GAAG,IAAI;CACnF,MAAM,aAAa,QAAQ,OAAO,IAAI;CACtC,IAAI,eAAe,IAAI,OAAO,EAAE,UAAU,QAAQ;CAClD,MAAM,WAAW,QAAQ,MAAM,GAAG,UAAU;CAC5C,MAAM,OAAO,QAAQ,MAAM,aAAa,CAAC;CACzC,MAAM,aAAa,gCAAgC,KAAK,IAAI;CAG5D,MAAM,QAAQ,eAAe,OAAO,KAAA,IAAa,WAAW,MAAM,WAAW;CAC7E,MAAM,OAAwB,CAAC;CAC/B,IAAI,aAAa,IAAI,KAAK,WAAW;CACrC,IAAI,UAAU,KAAA,GAAW,KAAK,QAAQ;CACtC,OAAO;AACT"}

package/dist/widgets/autocomplete.d.mts

@@ -0,0 +1,2 @@
+import { a as AutocompleteState, i as AutocompleteOptions, n as Autocomplete, o as CompletionSource, r as AutocompleteEvents, s as autocomplete, t as AcceptFn } from "../autocomplete-Dfw-yQDa.mjs";
+export { AcceptFn, Autocomplete, AutocompleteEvents, AutocompleteOptions, AutocompleteState, CompletionSource, autocomplete };

package/dist/widgets/autocomplete.mjs

@@ -0,0 +1,165 @@
+import { S as unwrap, f as effect, h as memo, y as signal } from "../reactive-f7NpAi69.mjs";
+import { t as Node } from "../node-BZ7f6HzU.mjs";
+import { t as picker } from "../picker-ndVVt6qF.mjs";
+import { Input } from "./input.mjs";
+//#region src/widgets/autocomplete.ts
+/**
+* Autocomplete popup bound to an `Input`. Watches the input's value and
+* cursor; when one of the configured sources' trigger regexes matches
+* the text before the cursor, the source's `complete(query)` is called
+* and the resulting items are shown in a `Menu` child.
+*
+* Selecting an item replaces the matched trigger-prefix + query with
+* the item's `value` and fires `"complete"` for apps that want to react
+* beyond plain text insertion.
+*
+* ```ts
+* autocomplete({
+*   input: "chat-input",
+*   sources: {
+*     slash: {
+*       triggers: [/^\s*\//],
+*       complete: (q) => slashCommands.filter((c) => c.startsWith(q)),
+*     },
+*   },
+* }).on("complete", (src, item) => { ... })
+* ```
+*
+* Positioning is layout-based — place the `Autocomplete` in your tree
+* (typically directly above the input inside the UI footer) and it
+* takes as many rows as it has items (up to `maxHeight`). When no
+* source matches, `visible` flips to `false` and the widget takes
+* zero rows, so the footer naturally collapses.
+*/
+var Autocomplete = class Autocomplete extends Node {
+	static type = "autocomplete";
+	type = Autocomplete.type;
+	select;
+	#opts;
+	#sources;
+	#match;
+	constructor(opts) {
+		super({ visible: false });
+		this.#opts = opts;
+		this.#sources = opts.sources;
+		const [cancelled, cancel] = signal(false);
+		this.#match = memo(() => {
+			const ret = this.#detect();
+			if (ret) cancel(false);
+			return ret;
+		});
+		const source = memo(() => {
+			const m = this.#match();
+			return m ? this.#sources[m.source] : void 0;
+		});
+		const visible = memo(() => this.enabled && this.#match() !== void 0 && !cancelled() && this.select.count > 0);
+		effect(() => {
+			if (visible()) this.show();
+			else this.hide();
+		});
+		this.select = picker({
+			...opts,
+			items: memo(() => unwrap(source()?.complete) ?? []),
+			maxHeight: opts.maxHeight ?? 8,
+			pattern: memo(() => this.#match()?.query ?? ""),
+			render: memo(() => source()?.render),
+			visible
+		});
+		this.add(this.select);
+		this.select.bind(this.#opts.input);
+		this.select.on("complete", ({ item }) => this.#complete(item));
+		this.select.on("accept", ({ item }) => this.#accept(item));
+		this.select.on("close", () => cancel(true));
+	}
+	get #input() {
+		if (this.#opts.input instanceof Input) return this.#opts.input;
+		return this.#opts.input();
+	}
+	get enabled() {
+		return unwrap(this.#opts.enabled) ?? true;
+	}
+	#detect() {
+		if (!this.#input) return void 0;
+		const value = this.#input.state.value ?? "";
+		const cursor = this.#input.state.cursor ?? 0;
+		const before = value.slice(0, cursor);
+		for (const [name, src] of Object.entries(this.#sources)) for (const rx of src.triggers) {
+			const re = new RegExp(rx.source, rx.flags.replace("g", ""));
+			let searchFrom = 0;
+			let best;
+			while (searchFrom <= before.length) {
+				const m = re.exec(before.slice(searchFrom));
+				if (m === null) break;
+				const start = searchFrom + m.index;
+				const end = start + m[0].length;
+				best = {
+					end,
+					start
+				};
+				searchFrom = end;
+			}
+			if (best === void 0) continue;
+			const query = before.slice(best.end);
+			if (/\s/.test(query)) continue;
+			return {
+				end: best.end,
+				query,
+				source: name,
+				start: best.start
+			};
+		}
+	}
+	#complete(item) {
+		const match = this.#match();
+		if (match === void 0) return;
+		this.#replace(item, defaultAccept(item), match.end);
+	}
+	#accept(item) {
+		const match = this.#match();
+		if (match === void 0) return;
+		const source = this.#sources[match.source];
+		this.#replace(item, source.accept ? source.accept(item, match.query) : defaultAccept(item), match.start);
+	}
+	#replace(item, accepted, start) {
+		const match = this.#match();
+		if (match === void 0 || !this.#input) return;
+		const value = this.#input.state.value ?? "";
+		const cursor = this.#input.state.cursor ?? 0;
+		const tail = value.slice(cursor);
+		accepted ??= "";
+		const newValue = value.slice(0, start) + accepted + tail;
+		if (newValue.trim() === "") {
+			const completed = value.slice(0, match.end) + defaultAccept(item) + tail;
+			if (completed.trim() !== "") this.#input.historyAdd(completed);
+		}
+		this.#input.state.set({
+			cursor: start + accepted.length,
+			value: newValue
+		});
+		this.emit("complete", {
+			item,
+			source: match.source
+		});
+		this.hide();
+	}
+	_render(ctx) {
+		return this.select.render(ctx);
+	}
+};
+/** Default `accept` fallback used when a source doesn't provide one.
+*  Assumes the item is `MenuItem`-shaped and inserts `value + " "` —
+*  matches the old `trailingSpace: true` behaviour. Returns `undefined`
+*  (clear-only) when the item has no `text`. */
+function defaultAccept(item) {
+	return `${item.text} `;
+}
+/**
+* Factory for `Autocomplete`. See the class doc for the full API.
+*/
+function autocomplete(opts) {
+	return new Autocomplete(opts);
+}
+//#endregion
+export { Autocomplete, autocomplete };
+
+//# sourceMappingURL=autocomplete.mjs.map

package/dist/widgets/autocomplete.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.mjs","names":["#sources","#opts","#match","#detect","#complete","#accept","#input","#replace"],"sources":["../../src/widgets/autocomplete.ts"],"sourcesContent":["import type { RenderCtx } from \"../core/ctx.ts\"\nimport type { BaseEvents } from \"../core/node.ts\"\nimport type { Accessor, Reactive, Ref } from \"../core/reactive.ts\"\nimport type { StyleState } from \"../core/state.ts\"\nimport type { SearchItems, SearchOptions } from \"../search/search.ts\"\nimport type { Option, OptionRender, Select } from \"./select.ts\"\n\nimport { Node } from \"../core/node.ts\"\nimport { effect, memo, signal, unwrap } from \"../core/reactive.ts\"\nimport { Input } from \"./input.ts\"\nimport { picker } from \"./picker.ts\"\n\n/** Called when the user picks `item` from this source. Return a string\n *  to insert in place of the trigger + query range, or `undefined`\n *  when the source handled the selection itself (dispatched an action,\n *  opened a modal, …) and the trigger range should just be removed. */\nexport type AcceptFn<T> = (item: T, query: string) => string | undefined\n\n/** Single completion source. `triggers` are regexes run against the text\n *  *before the cursor*; the first regex whose match ends in the trailing\n *  word wins. The slice between match-end and the cursor becomes the\n *  `query` passed to `complete`.\n *\n *  `complete` receives a `match` helper bound to `query` — call it on\n *  whatever string the source considers the matching field (action id,\n *  file basename, contact email, etc.) and either filter or rank.\n *\n *  `accept` controls what happens on selection. Default: insert\n *  `item.value + \" \"`. Return `undefined` to have the source do its own\n *  side effect (dispatch an action, open a picker, …) and just clear\n *  the trigger range in the input.\n *\n *  `render` is forwarded to the internal `Menu` so the source can carry\n *  its own row presentation — handy when `T` isn't a plain `MenuItem`. */\nexport interface CompletionSource<T extends Option = Option> {\n  triggers: readonly RegExp[]\n  complete: Reactive<SearchItems<T>>\n  accept?: AcceptFn<T>\n  render?: OptionRender<T>\n}\n\n// oxlint-disable-next-line no-empty-interface\nexport interface AutocompleteState extends StyleState {}\n\nexport interface AutocompleteOptions extends SearchOptions {\n  /** The `Input` to watch. Pass the node directly, or a `Ref<Input>`\n   *  populated by `node.ref(ref)` elsewhere in the tree — the latter\n   *  enables fully inline composition where the input doesn't need a\n   *  local binding. The ref is dereferenced on mount, so wiring is\n   *  type-safe and ordering-flexible (autocomplete can be constructed\n   *  before the Input is). */\n  input: Input | Ref<Input>\n  // Per-source item types are erased at this level — each source\n  // declares its own `T` which is preserved within its own `complete`\n  // / `accept` / `render` callbacks. The `complete` event payload is\n  // consequently typed as `unknown`; callers discriminate by source\n  // name and cast.\n  sources: Record<string, CompletionSource<any>>\n  /** Cap on rows the popup shows at once. Default: 8. */\n  maxHeight?: Reactive<number>\n  enabled?: Reactive<boolean>\n  reverse?: boolean\n}\n\nexport interface AutocompleteEvents extends BaseEvents {\n  /** Fired after an item is inserted into the input. Payload item type\n   *  is `unknown` because sources may have different `T`; discriminate\n   *  by source name and cast. */\n  complete: { source: string; item: Option }\n}\n\ninterface Match {\n  source: string\n  /** Absolute start index of the trigger in the input value. */\n  start: number\n  /** Absolute end index of the trigger in the input value. */\n  end: number\n  /** The query (text between trigger-end and cursor). */\n  query: string\n}\n\n// const AutocompleteBase = Node as unknown as abstract new <T extends MenuItem>(\n//   ...args: ConstructorParameters<typeof Menu<T>>\n// ) => Node<MenuState<T>> & Emitter<MenuEvents<T> & EventMap>\n\n/**\n * Autocomplete popup bound to an `Input`. Watches the input's value and\n * cursor; when one of the configured sources' trigger regexes matches\n * the text before the cursor, the source's `complete(query)` is called\n * and the resulting items are shown in a `Menu` child.\n *\n * Selecting an item replaces the matched trigger-prefix + query with\n * the item's `value` and fires `\"complete\"` for apps that want to react\n * beyond plain text insertion.\n *\n * ```ts\n * autocomplete({\n *   input: \"chat-input\",\n *   sources: {\n *     slash: {\n *       triggers: [/^\\s*\\//],\n *       complete: (q) => slashCommands.filter((c) => c.startsWith(q)),\n *     },\n *   },\n * }).on(\"complete\", (src, item) => { ... })\n * ```\n *\n * Positioning is layout-based — place the `Autocomplete` in your tree\n * (typically directly above the input inside the UI footer) and it\n * takes as many rows as it has items (up to `maxHeight`). When no\n * source matches, `visible` flips to `false` and the widget takes\n * zero rows, so the footer naturally collapses.\n */\nexport class Autocomplete extends Node<AutocompleteState, AutocompleteEvents> {\n  static readonly type = \"autocomplete\"\n  override readonly type = Autocomplete.type\n\n  readonly select: Select\n  #opts: AutocompleteOptions\n  readonly #sources: Record<string, CompletionSource<any>>\n  #match: Accessor<Match | undefined>\n\n  constructor(opts: AutocompleteOptions) {\n    super({ visible: false })\n    this.#opts = opts\n    this.#sources = opts.sources\n\n    const [cancelled, cancel] = signal(false)\n\n    this.#match = memo(() => {\n      const ret = this.#detect()\n      if (ret) cancel(false)\n      return ret\n    })\n\n    const source = memo(() => {\n      const m = this.#match()\n      return m ? this.#sources[m.source] : undefined\n    })\n\n    const visible = memo(\n      () => this.enabled && this.#match() !== undefined && !cancelled() && this.select.count > 0\n    )\n\n    // Use an effect instead of setting a signal, since Node.show/hide overwrites the signal\n    effect(() => {\n      if (visible()) this.show()\n      else this.hide()\n    })\n\n    this.select = picker({\n      ...opts,\n      items: memo(() => unwrap(source()?.complete) ?? []),\n      maxHeight: opts.maxHeight ?? 8,\n      pattern: memo(() => this.#match()?.query ?? \"\"),\n      render: memo(() => source()?.render),\n      visible,\n    })\n\n    this.add(this.select)\n    this.select.bind(this.#opts.input)\n\n    // Bridge menu events to input rewrite. Tab completes by inserting the\n    // item's value; Enter selects, giving the source a chance to execute.\n    this.select.on(\"complete\", ({ item }) => this.#complete(item))\n    this.select.on(\"accept\", ({ item }) => this.#accept(item))\n    this.select.on(\"close\", () => cancel(true))\n  }\n\n  get #input(): Input | undefined {\n    if (this.#opts.input instanceof Input) return this.#opts.input\n    return this.#opts.input()\n  }\n\n  get enabled(): boolean {\n    return unwrap(this.#opts.enabled) ?? true\n  }\n\n  #detect(): Match | undefined {\n    if (!this.#input) return undefined\n    const value = this.#input.state.value ?? \"\"\n    const cursor = this.#input.state.cursor ?? 0\n    const before = value.slice(0, cursor)\n    for (const [name, src] of Object.entries(this.#sources)) {\n      for (const rx of src.triggers) {\n        // `exec` with /g wouldn't help — we want the *last* match whose\n        // tail reaches the cursor, since the relevant trigger is the one\n        // just typed. Scan with a sticky-ish loop and keep the latest hit.\n        const re = new RegExp(rx.source, rx.flags.replace(\"g\", \"\"))\n        let searchFrom = 0\n        let best: { start: number; end: number } | undefined\n        while (searchFrom <= before.length) {\n          const m = re.exec(before.slice(searchFrom))\n          if (m === null) break\n          const start = searchFrom + m.index\n          const end = start + m[0].length\n          best = { end, start }\n          searchFrom = end\n        }\n        if (best === undefined) continue\n        // The query is text from trigger-end to cursor. Reject if there's\n        // whitespace between them — that means the trigger word is over.\n        const query = before.slice(best.end)\n        if (/\\s/.test(query)) continue\n        return { end: best.end, query, source: name, start: best.start }\n      }\n    }\n    return undefined\n  }\n\n  #complete(item: Option): void {\n    const match = this.#match()\n    if (match === undefined) return\n    // Completion keeps the trigger (`/`, `@`, ...) and only replaces the query.\n    this.#replace(item, defaultAccept(item), match.end)\n  }\n\n  #accept(item: Option): void {\n    const match = this.#match()\n    if (match === undefined) return\n    const source = this.#sources[match.source]\n    // Source-provided accept wins on Enter; default is `item.value + \" \"` when\n    // the item looks MenuItem-shaped, otherwise a no-op clear.\n    this.#replace(\n      item,\n      source.accept ? source.accept(item, match.query) : defaultAccept(item),\n      match.start\n    )\n  }\n\n  #replace(item: Option, accepted: string | undefined, start: number): void {\n    const match = this.#match()\n    if (match === undefined || !this.#input) return\n    const value = this.#input.state.value ?? \"\"\n    const cursor = this.#input.state.cursor ?? 0\n    const tail = value.slice(cursor)\n    accepted ??= \"\"\n    const newValue = value.slice(0, start) + accepted + tail\n\n    if (newValue.trim() === \"\") {\n      // In case the source fully consumed the input, add the fully completed value\n      // to the input history. When not fully consumed, submit will add the completed\n      // value to the history, so we don't need to do it here.\n      const completed = value.slice(0, match.end) + defaultAccept(item) + tail\n      if (completed.trim() !== \"\") this.#input.historyAdd(completed)\n    }\n\n    this.#input.state.set({\n      cursor: start + accepted.length,\n      value: newValue,\n    })\n    void this.emit(\"complete\", { item, source: match.source })\n    this.hide()\n  }\n\n  protected _render(ctx: RenderCtx): string[] | Promise<string[]> {\n    // Menu does all the layout. We're just a wrapper node so callers\n    // can place the popup in their tree and so the `visible` toggle\n    // flows through one handle.\n    return this.select.render(ctx)\n  }\n}\n\n/** Default `accept` fallback used when a source doesn't provide one.\n *  Assumes the item is `MenuItem`-shaped and inserts `value + \" \"` —\n *  matches the old `trailingSpace: true` behaviour. Returns `undefined`\n *  (clear-only) when the item has no `text`. */\nfunction defaultAccept(item: Option): string {\n  return `${item.text} `\n}\n\n/**\n * Factory for `Autocomplete`. See the class doc for the full API.\n */\nexport function autocomplete(opts: AutocompleteOptions): Autocomplete {\n  return new Autocomplete(opts)\n}\n"],"mappings":"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"}

package/dist/widgets/box.d.mts

@@ -0,0 +1,2 @@
+import { B as Padding, R as Box, V as box, z as BoxStyle } from "../queries-DH3bj74K.mjs";
+export { Box, BoxStyle, Padding, box };

package/dist/widgets/box.mjs

@@ -0,0 +1,2 @@
+import { n as box, t as Box } from "../box-DyaByEiG.mjs";
+export { Box, box };

package/dist/widgets/code.d.mts

@@ -0,0 +1,48 @@
+import { R as Box, X as State, nt as Reactive } from "../queries-DH3bj74K.mjs";
+import { o as AnyStyle } from "../types-B9Eh7k2v.mjs";
+//#region src/widgets/code.d.ts
+interface CodeState {
+  /** Source to render. Plain string or reactive accessor — pass a
+   *  signal for streaming bash output / tool results. */
+  code: Reactive<string>;
+  /** Optional file path. Drives the default `lang` (extension) and
+   *  `title` (path) when those aren't set explicitly. */
+  path?: Reactive<string>;
+  /** Language for syntax highlighting (any shiki-bundled name or
+   *  alias). Defaults to `extname(path).slice(1)` when `path` is set.
+   *  Unknown langs fall through to plain rendering. */
+  lang?: string;
+  /** Title line shown above the block. May contain ANSI. Defaults to
+   *  `path` when set. */
+  title?: Reactive<string>;
+  /** Disable syntax highlighting even if `lang` is set. Default: `true`. */
+  syntax?: boolean;
+  style?: AnyStyle | false;
+  numbered?: boolean;
+  numberOffset?: Reactive<number | undefined>;
+  offset?: Reactive<number | undefined>;
+  limit?: Reactive<number | undefined>;
+  more?: (more: number, msg: string) => string;
+}
+/**
+ * Standalone code block: shiki-highlighted body inside a `code`-styled
+ * shrink-to-content backdrop, optionally titled.
+ *
+ * Composition over custom layout — the backdrop is `box({ bg: "code",
+ * width: "fit" })`, the body is plain `text(...)`. Ambient theme/style
+ * arrive via `useContext(RenderContext)`; the async closure reads
+ * `style()?.theme` so it stays correct across theme swaps.
+ *
+ * Async highlighting flows through `createAsync`: signal reads inside
+ * the async closure auto-track, so `props.code` (or any other reactive
+ * source) drives a re-fire. The accessor returns `initialValue` (the
+ * plain source) until shiki resolves, then swaps to the highlighted
+ * version. When called inside a Stream surface's `append`, the surface
+ * installs a `SuspenseContext` boundary; Stream awaits it before
+ * painting, so rows committed to scrollback always reflect the
+ * resolved highlight rather than the initial plain source.
+ */
+declare const code: (props: State<CodeState>) => Box<{}>;
+//#endregion
+export { CodeState, code };
+//# sourceMappingURL=code.d.mts.map

package/dist/widgets/code.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code.d.mts","names":[],"sources":["../../src/widgets/code.ts"],"mappings":";;;UAciB;;;EAGf,MAAM;;;EAGN,OAAO;;;;EAIP;;;EAGA,QAAQ;;EAER;EACA,QAAQ;EACR;EACA,eAAe;EACf,SAAS;EACT,QAAQ;EACR,QAAQ,cAAc;;;;;;;;;;;;;;;;;;;;cAqBX,OAAI,OAAkB,MAAM,eAAN"}

package/dist/widgets/code.mjs

@@ -0,0 +1,59 @@
+import { S as unwrap, h as memo, r as createAsync, w as useContext } from "../reactive-f7NpAi69.mjs";
+import { n as box } from "../box-DyaByEiG.mjs";
+import { formatLines } from "../text.mjs";
+import { text } from "./text.mjs";
+import { t as RenderContext } from "../render-DxVLqqB9.mjs";
+import { t as codeToAnsi } from "../shiki-BrjVUkeh.mjs";
+import { widget } from "./widget.mjs";
+import { show } from "./show.mjs";
+import { extname } from "pathe";
+//#region src/widgets/code.ts
+/**
+* Standalone code block: shiki-highlighted body inside a `code`-styled
+* shrink-to-content backdrop, optionally titled.
+*
+* Composition over custom layout — the backdrop is `box({ bg: "code",
+* width: "fit" })`, the body is plain `text(...)`. Ambient theme/style
+* arrive via `useContext(RenderContext)`; the async closure reads
+* `style()?.theme` so it stays correct across theme swaps.
+*
+* Async highlighting flows through `createAsync`: signal reads inside
+* the async closure auto-track, so `props.code` (or any other reactive
+* source) drives a re-fire. The accessor returns `initialValue` (the
+* plain source) until shiki resolves, then swaps to the highlighted
+* version. When called inside a Stream surface's `append`, the surface
+* installs a `SuspenseContext` boundary; Stream awaits it before
+* painting, so rows committed to scrollback always reflect the
+* resolved highlight rather than the initial plain source.
+*/
+const code = widget((props) => {
+	const path = unwrap(props.path);
+	const lang = props.lang ?? (path !== void 0 ? extname(path).slice(1).toLowerCase() : void 0);
+	const syntax = props.syntax ?? true;
+	const context = useContext(RenderContext);
+	const title = memo(() => unwrap(props.title) ?? path);
+	const plain = () => unwrap(props.code).replace(/\n+$/, "");
+	const body = createAsync(async () => {
+		const source = plain();
+		if (!lang || !syntax) return source;
+		return await codeToAnsi(source, lang, { theme: context?.style().theme.shiki });
+	}, { initialValue: plain() });
+	const formatted = memo(() => formatLines(body().split("\n"), {
+		limit: unwrap(props.limit),
+		more: props.more,
+		numberOffset: unwrap(props.numberOffset),
+		numbered: props.numbered,
+		offset: unwrap(props.offset),
+		style: context?.style().gutter
+	}).join("\n"));
+	return box({
+		flexDirection: "column",
+		padding: props.style === false ? void 0 : [0, 1],
+		style: props.style === false ? void 0 : props.style ?? "code",
+		width: "fit"
+	}, show({ when: title }, () => text((ctx) => ctx.style.codeTitle(title() ?? ""), { wrap: "none" })), text(formatted, { wrap: "none" }));
+});
+//#endregion
+export { code };
+
+//# sourceMappingURL=code.mjs.map

package/dist/widgets/code.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"code.mjs","names":[],"sources":["../../src/widgets/code.ts"],"sourcesContent":["import type { Reactive } from \"../core/reactive.ts\"\nimport type { State } from \"../core/state.ts\"\nimport type { AnyStyle } from \"../style/types.ts\"\n\nimport { extname } from \"pathe\"\nimport { createAsync, memo, unwrap, useContext } from \"../core/reactive.ts\"\nimport { RenderContext } from \"../core/render.ts\"\nimport { formatLines } from \"../layout/text.ts\"\nimport { codeToAnsi } from \"../shiki/shiki.ts\"\nimport { box } from \"./box.ts\"\nimport { show } from \"./show.ts\"\nimport { text } from \"./text.ts\"\nimport { widget } from \"./widget.ts\"\n\nexport interface CodeState {\n  /** Source to render. Plain string or reactive accessor — pass a\n   *  signal for streaming bash output / tool results. */\n  code: Reactive<string>\n  /** Optional file path. Drives the default `lang` (extension) and\n   *  `title` (path) when those aren't set explicitly. */\n  path?: Reactive<string>\n  /** Language for syntax highlighting (any shiki-bundled name or\n   *  alias). Defaults to `extname(path).slice(1)` when `path` is set.\n   *  Unknown langs fall through to plain rendering. */\n  lang?: string\n  /** Title line shown above the block. May contain ANSI. Defaults to\n   *  `path` when set. */\n  title?: Reactive<string>\n  /** Disable syntax highlighting even if `lang` is set. Default: `true`. */\n  syntax?: boolean\n  style?: AnyStyle | false\n  numbered?: boolean\n  numberOffset?: Reactive<number | undefined>\n  offset?: Reactive<number | undefined>\n  limit?: Reactive<number | undefined>\n  more?: (more: number, msg: string) => string\n}\n\n/**\n * Standalone code block: shiki-highlighted body inside a `code`-styled\n * shrink-to-content backdrop, optionally titled.\n *\n * Composition over custom layout — the backdrop is `box({ bg: \"code\",\n * width: \"fit\" })`, the body is plain `text(...)`. Ambient theme/style\n * arrive via `useContext(RenderContext)`; the async closure reads\n * `style()?.theme` so it stays correct across theme swaps.\n *\n * Async highlighting flows through `createAsync`: signal reads inside\n * the async closure auto-track, so `props.code` (or any other reactive\n * source) drives a re-fire. The accessor returns `initialValue` (the\n * plain source) until shiki resolves, then swaps to the highlighted\n * version. When called inside a Stream surface's `append`, the surface\n * installs a `SuspenseContext` boundary; Stream awaits it before\n * painting, so rows committed to scrollback always reflect the\n * resolved highlight rather than the initial plain source.\n */\nexport const code = widget((props: State<CodeState>) => {\n  const path = unwrap(props.path)\n  const lang = props.lang ?? (path !== undefined ? extname(path).slice(1).toLowerCase() : undefined)\n  const syntax = props.syntax ?? true\n\n  // Theme is sourced from a render-time hook since the async closure\n  // runs outside the render phase.\n\n  const context = useContext(RenderContext)\n\n  const title = memo(() => unwrap(props.title) ?? path)\n\n  const plain = () => unwrap(props.code).replace(/\\n+$/, \"\")\n\n  const body = createAsync(\n    async () => {\n      const source = plain()\n      if (!lang || !syntax) return source\n      return await codeToAnsi(source, lang, { theme: context?.style().theme.shiki })\n    },\n    { initialValue: plain() }\n  )\n\n  const formatted = memo(() =>\n    formatLines(body().split(\"\\n\"), {\n      limit: unwrap(props.limit),\n      more: props.more,\n      numberOffset: unwrap(props.numberOffset),\n      numbered: props.numbered,\n      offset: unwrap(props.offset),\n      style: context?.style().gutter,\n    }).join(\"\\n\")\n  )\n\n  return box(\n    {\n      flexDirection: \"column\",\n      padding: props.style === false ? undefined : [0, 1],\n      style: props.style === false ? undefined : (props.style ?? \"code\"),\n      width: \"fit\",\n    },\n    show({ when: title }, () =>\n      text((ctx) => ctx.style.codeTitle(title() ?? \"\"), { wrap: \"none\" })\n    ),\n    text(formatted, { wrap: \"none\" })\n  )\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,OAAO,QAAQ,UAA4B;CACtD,MAAM,OAAO,OAAO,MAAM,IAAI;CAC9B,MAAM,OAAO,MAAM,SAAS,SAAS,KAAA,IAAY,QAAQ,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,IAAI,KAAA;CACxF,MAAM,SAAS,MAAM,UAAU;CAK/B,MAAM,UAAU,WAAW,aAAa;CAExC,MAAM,QAAQ,WAAW,OAAO,MAAM,KAAK,KAAK,IAAI;CAEpD,MAAM,cAAc,OAAO,MAAM,IAAI,CAAC,CAAC,QAAQ,QAAQ,EAAE;CAEzD,MAAM,OAAO,YACX,YAAY;EACV,MAAM,SAAS,MAAM;EACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,OAAO;EAC7B,OAAO,MAAM,WAAW,QAAQ,MAAM,EAAE,OAAO,SAAS,MAAM,CAAC,CAAC,MAAM,MAAM,CAAC;CAC/E,GACA,EAAE,cAAc,MAAM,EAAE,CAC1B;CAEA,MAAM,YAAY,WAChB,YAAY,KAAK,CAAC,CAAC,MAAM,IAAI,GAAG;EAC9B,OAAO,OAAO,MAAM,KAAK;EACzB,MAAM,MAAM;EACZ,cAAc,OAAO,MAAM,YAAY;EACvC,UAAU,MAAM;EAChB,QAAQ,OAAO,MAAM,MAAM;EAC3B,OAAO,SAAS,MAAM,CAAC,CAAC;CAC1B,CAAC,CAAC,CAAC,KAAK,IAAI,CACd;CAEA,OAAO,IACL;EACE,eAAe;EACf,SAAS,MAAM,UAAU,QAAQ,KAAA,IAAY,CAAC,GAAG,CAAC;EAClD,OAAO,MAAM,UAAU,QAAQ,KAAA,IAAa,MAAM,SAAS;EAC3D,OAAO;CACT,GACA,KAAK,EAAE,MAAM,MAAM,SACjB,MAAM,QAAQ,IAAI,MAAM,UAAU,MAAM,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC,CACpE,GACA,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC,CAClC;AACF,CAAC"}

package/dist/widgets/completions/actions.d.mts

@@ -0,0 +1,41 @@
+import { Bt as Actions, It as ActionDef } from "../../queries-DH3bj74K.mjs";
+import { n as PickerItem } from "../../picker-D8OLb6kZ.mjs";
+import { o as CompletionSource } from "../../autocomplete-Dfw-yQDa.mjs";
+//#region src/widgets/completions/actions.d.ts
+/** Completion item produced by `actionsSource`. Carries the full
+ *  `ActionInfo` plus the action `id` so the source's `accept` can
+ *  dispatch without a secondary lookup. Items match the `MenuItem`
+ *  contract loosely via the overlapping `name`/... shape. */
+type ActionCompletionItem = ActionDef & PickerItem & {
+  id: string;
+  score: number;
+};
+interface ActionsSourceOptions {
+  /** Registry to read from. Usually `renderer.actions`. */
+  actions: Actions;
+  /** Trigger regex. Default: `/^\s*\//` (slash at start of line). */
+  trigger?: RegExp;
+  /** Keep predicate. Default skips `info.hidden`. Return `false` to
+   *  drop the entry from the completion list. */
+  filter?: (id: string, info: ActionDef) => boolean;
+}
+/**
+ * Completion source backed by the `Actions` registry — typical slash
+ * command ergonomics. Items are raw `ActionInfo` objects augmented
+ * with their `id`; `accept` dispatches the action through the registry
+ * and clears the trigger+query range, so the user's typed `/foo` is
+ * removed once the action fires (no stale text left in the input).
+ *
+ * ```ts
+ * autocomplete({
+ *   input: "chat-input",
+ *   sources: {
+ *     slash: actionsSource({ actions: renderer.actions }),
+ *   },
+ * })
+ * ```
+ */
+declare function actionsSource(opts: ActionsSourceOptions): CompletionSource<ActionCompletionItem>;
+//#endregion
+export { ActionCompletionItem, ActionsSourceOptions, actionsSource };
+//# sourceMappingURL=actions.d.mts.map

package/dist/widgets/completions/actions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.mts","names":[],"sources":["../../../src/widgets/completions/actions.ts"],"mappings":";;;;;;;;KAQY,uBAAuB,YAAY;EAAe;EAAY;;UAEzD;;EAEf,SAAS;;EAET,UAAU;;;EAGV,UAAU,YAAY,MAAM;;;;;;;;;;;;;;;;;;iBAmBd,cAAc,MAAM,uBAAuB,iBAAiB"}

package/dist/widgets/completions/actions.mjs

@@ -0,0 +1,48 @@
+//#region src/widgets/completions/actions.ts
+/**
+* Completion source backed by the `Actions` registry — typical slash
+* command ergonomics. Items are raw `ActionInfo` objects augmented
+* with their `id`; `accept` dispatches the action through the registry
+* and clears the trigger+query range, so the user's typed `/foo` is
+* removed once the action fires (no stale text left in the input).
+*
+* ```ts
+* autocomplete({
+*   input: "chat-input",
+*   sources: {
+*     slash: actionsSource({ actions: renderer.actions }),
+*   },
+* })
+* ```
+*/
+function actionsSource(opts) {
+	const trigger = opts.trigger ?? /^\//;
+	const filter = opts.filter ?? ((_id, info) => !info.hidden && !!info.cmd);
+	return {
+		accept(item) {
+			opts.actions.dispatch(item.id, { source: "autocomplete" });
+		},
+		complete(_query, match) {
+			const out = [];
+			for (const info of opts.actions.list()) {
+				if (!filter(info.id, info)) continue;
+				const name = info.cmd ?? info.id;
+				const score = match(name);
+				if (!score) continue;
+				out.push({
+					...info,
+					id: info.id,
+					name,
+					score,
+					text: name
+				});
+			}
+			return out;
+		},
+		triggers: [trigger]
+	};
+}
+//#endregion
+export { actionsSource };
+
+//# sourceMappingURL=actions.mjs.map

package/dist/widgets/completions/actions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.mjs","names":[],"sources":["../../../src/widgets/completions/actions.ts"],"sourcesContent":["import type { ActionDef, Actions } from \"../../input/actions.ts\"\nimport type { CompletionSource } from \"../autocomplete.ts\"\nimport type { PickerItem } from \"../picker.ts\"\n\n/** Completion item produced by `actionsSource`. Carries the full\n *  `ActionInfo` plus the action `id` so the source's `accept` can\n *  dispatch without a secondary lookup. Items match the `MenuItem`\n *  contract loosely via the overlapping `name`/... shape. */\nexport type ActionCompletionItem = ActionDef & PickerItem & { id: string; score: number }\n\nexport interface ActionsSourceOptions {\n  /** Registry to read from. Usually `renderer.actions`. */\n  actions: Actions\n  /** Trigger regex. Default: `/^\\s*\\//` (slash at start of line). */\n  trigger?: RegExp\n  /** Keep predicate. Default skips `info.hidden`. Return `false` to\n   *  drop the entry from the completion list. */\n  filter?: (id: string, info: ActionDef) => boolean\n}\n\n/**\n * Completion source backed by the `Actions` registry — typical slash\n * command ergonomics. Items are raw `ActionInfo` objects augmented\n * with their `id`; `accept` dispatches the action through the registry\n * and clears the trigger+query range, so the user's typed `/foo` is\n * removed once the action fires (no stale text left in the input).\n *\n * ```ts\n * autocomplete({\n *   input: \"chat-input\",\n *   sources: {\n *     slash: actionsSource({ actions: renderer.actions }),\n *   },\n * })\n * ```\n */\nexport function actionsSource(opts: ActionsSourceOptions): CompletionSource<ActionCompletionItem> {\n  const trigger = opts.trigger ?? /^\\//\n  const filter = opts.filter ?? ((_id, info): boolean => !info.hidden && !!info.cmd)\n\n  return {\n    accept(item): undefined {\n      opts.actions.dispatch(item.id, { source: \"autocomplete\" })\n      return undefined\n    },\n    complete(_query, match): ActionCompletionItem[] {\n      const out: ActionCompletionItem[] = []\n      for (const info of opts.actions.list()) {\n        if (!filter(info.id, info)) continue\n        const name = info.cmd ?? info.id\n        const score = match(name)\n        if (!score) continue\n        out.push({ ...info, id: info.id, name, score, text: name })\n      }\n      return out\n    },\n    triggers: [trigger],\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoCA,SAAgB,cAAc,MAAoE;CAChG,MAAM,UAAU,KAAK,WAAW;CAChC,MAAM,SAAS,KAAK,YAAY,KAAK,SAAkB,CAAC,KAAK,UAAU,CAAC,CAAC,KAAK;CAE9E,OAAO;EACL,OAAO,MAAiB;GACtB,KAAK,QAAQ,SAAS,KAAK,IAAI,EAAE,QAAQ,eAAe,CAAC;EAE3D;EACA,SAAS,QAAQ,OAA+B;GAC9C,MAAM,MAA8B,CAAC;GACrC,KAAK,MAAM,QAAQ,KAAK,QAAQ,KAAK,GAAG;IACtC,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,GAAG;IAC5B,MAAM,OAAO,KAAK,OAAO,KAAK;IAC9B,MAAM,QAAQ,MAAM,IAAI;IACxB,IAAI,CAAC,OAAO;IACZ,IAAI,KAAK;KAAE,GAAG;KAAM,IAAI,KAAK;KAAI;KAAM;KAAO,MAAM;IAAK,CAAC;GAC5D;GACA,OAAO;EACT;EACA,UAAU,CAAC,OAAO;CACpB;AACF"}

package/dist/widgets/completions/files.d.mts

@@ -0,0 +1,29 @@
+import { n as PickerItem } from "../../picker-D8OLb6kZ.mjs";
+import { o as CompletionSource } from "../../autocomplete-Dfw-yQDa.mjs";
+import { FindOptions } from "@zaly/shared/find";
+//#region src/widgets/completions/files.d.ts
+interface FilesSourceOptions extends FindOptions {
+  /** Base directory relative queries resolve against. Default:
+   *  `process.cwd()`. */
+  cwd?: string;
+  /** Trigger regex. Default: `/(?<=^|\s)@/` — `@` preceded by start-of-
+   *  string or whitespace. Lookbehind keeps `match.start` on the `@`
+   *  itself so the leading space isn't eaten on insertion. */
+  trigger?: RegExp;
+  /** Prefix prepended to accepted values so the trigger character stays
+   *  in the input after a pick (letting users keep typing to drill into
+   *  subdirectories). Default: `"@"` — matches the default trigger.
+   *  When customizing `trigger`, set this to the character your trigger
+   *  represents. */
+  prefix?: string;
+  refreshInterval?: number;
+}
+type File = PickerItem & {
+  file: string;
+};
+/** Completion source for files. Uses `@zaly/shared/find` under the hood, so
+ * supports all the same options and respects .gitignore by default. */
+declare function filesSource(opts?: FilesSourceOptions): CompletionSource<File>;
+//#endregion
+export { FilesSourceOptions, filesSource };
+//# sourceMappingURL=files.d.mts.map

package/dist/widgets/completions/files.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.mts","names":[],"sources":["../../../src/widgets/completions/files.ts"],"mappings":";;;;UAQiB,2BAA2B;;;EAG1C;;;;EAIA,UAAU;;;;;;EAMV;EACA;;KAGG,OAAO;EAAe;;;;iBAIX,YAAY,OAAM,qBAA0B,iBAAiB"}

package/dist/widgets/completions/files.mjs

@@ -0,0 +1,42 @@
+import { a as createIterable, y as signal } from "../../reactive-f7NpAi69.mjs";
+import { normPath } from "@zaly/shared";
+//#region src/widgets/completions/files.ts
+/** Completion source for files. Uses `@zaly/shared/find` under the hood, so
+* supports all the same options and respects .gitignore by default. */
+function filesSource(opts = {}) {
+	const cwd = normPath(opts.cwd);
+	const trigger = opts.trigger ?? /(?<=^|\s)@/;
+	const prefix = opts.prefix ?? "@";
+	let results;
+	const [gen, setGen] = signal(0);
+	let lastRefresh = 0;
+	return {
+		accept: (item) => {
+			const v = item.file;
+			return `${prefix}${v}${v.endsWith("/") ? "" : " "}`;
+		},
+		get complete() {
+			const now = performance.now();
+			if (!results?.loading() && now - lastRefresh > (opts.refreshInterval ?? 1e4)) {
+				setGen((g) => g + 1);
+				lastRefresh = now;
+			}
+			return results ??= createIterable(async function* iterFiles() {
+				gen();
+				const { find } = await import("@zaly/shared/find");
+				for await (const f of find({
+					...opts,
+					cwd
+				})) yield (Array.isArray(f) ? f : [f]).map((file) => ({
+					file,
+					text: file
+				}));
+			});
+		},
+		triggers: [trigger]
+	};
+}
+//#endregion
+export { filesSource };
+
+//# sourceMappingURL=files.mjs.map

package/dist/widgets/completions/files.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.mjs","names":[],"sources":["../../../src/widgets/completions/files.ts"],"sourcesContent":["import type { FindOptions } from \"@zaly/shared/find\"\nimport type { Progressive } from \"../../core/reactive.ts\"\nimport type { CompletionSource } from \"../autocomplete.ts\"\nimport type { PickerItem } from \"../picker.ts\"\n\nimport { normPath } from \"@zaly/shared\"\nimport { createIterable, signal } from \"../../core/reactive.ts\"\n\nexport interface FilesSourceOptions extends FindOptions {\n  /** Base directory relative queries resolve against. Default:\n   *  `process.cwd()`. */\n  cwd?: string\n  /** Trigger regex. Default: `/(?<=^|\\s)@/` — `@` preceded by start-of-\n   *  string or whitespace. Lookbehind keeps `match.start` on the `@`\n   *  itself so the leading space isn't eaten on insertion. */\n  trigger?: RegExp\n  /** Prefix prepended to accepted values so the trigger character stays\n   *  in the input after a pick (letting users keep typing to drill into\n   *  subdirectories). Default: `\"@\"` — matches the default trigger.\n   *  When customizing `trigger`, set this to the character your trigger\n   *  represents. */\n  prefix?: string\n  refreshInterval?: number\n}\n\ntype File = PickerItem & { file: string }\n\n/** Completion source for files. Uses `@zaly/shared/find` under the hood, so\n * supports all the same options and respects .gitignore by default. */\nexport function filesSource(opts: FilesSourceOptions = {}): CompletionSource<File> {\n  const cwd = normPath(opts.cwd)\n  const trigger = opts.trigger ?? /(?<=^|\\s)@/\n  const prefix = opts.prefix ?? \"@\"\n  let results: Progressive<readonly File[]> | undefined\n  const [gen, setGen] = signal(0)\n  let lastRefresh = 0\n  return {\n    accept: (item) => {\n      // Dirs keep the popup open (trigger still matches, user can\n      // drill in). Files close it — a trailing space makes `#detect`\n      // see whitespace in the query and bail.\n      const v = item.file\n      return `${prefix}${v}${v.endsWith(\"/\") ? \"\" : \" \"}`\n    },\n    get complete() {\n      const now = performance.now()\n      if (!results?.loading() && now - lastRefresh > (opts.refreshInterval ?? 10_000)) {\n        setGen((g) => g + 1) // Refresh results\n        lastRefresh = now\n      }\n      return (results ??= createIterable<File>(async function* iterFiles() {\n        gen() // Re-run when `gen` changes\n        const { find } = await import(\"@zaly/shared/find\")\n        for await (const f of find({ ...opts, cwd })) {\n          const ff = Array.isArray(f) ? f : [f]\n          yield ff.map((file) => ({ file, text: file }))\n        }\n      }))\n    },\n    triggers: [trigger],\n  }\n}\n"],"mappings":";;;;;AA6BA,SAAgB,YAAY,OAA2B,CAAC,GAA2B;CACjF,MAAM,MAAM,SAAS,KAAK,GAAG;CAC7B,MAAM,UAAU,KAAK,WAAW;CAChC,MAAM,SAAS,KAAK,UAAU;CAC9B,IAAI;CACJ,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC;CAC9B,IAAI,cAAc;CAClB,OAAO;EACL,SAAS,SAAS;GAIhB,MAAM,IAAI,KAAK;GACf,OAAO,GAAG,SAAS,IAAI,EAAE,SAAS,GAAG,IAAI,KAAK;EAChD;EACA,IAAI,WAAW;GACb,MAAM,MAAM,YAAY,IAAI;GAC5B,IAAI,CAAC,SAAS,QAAQ,KAAK,MAAM,eAAe,KAAK,mBAAmB,MAAS;IAC/E,QAAQ,MAAM,IAAI,CAAC;IACnB,cAAc;GAChB;GACA,OAAQ,YAAY,eAAqB,gBAAgB,YAAY;IACnE,IAAI;IACJ,MAAM,EAAE,SAAS,MAAM,OAAO;IAC9B,WAAW,MAAM,KAAK,KAAK;KAAE,GAAG;KAAM;IAAI,CAAC,GAEzC,OADW,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC,EAAA,CAC3B,KAAK,UAAU;KAAE;KAAM,MAAM;IAAK,EAAE;GAEjD,CAAC;EACH;EACA,UAAU,CAAC,OAAO;CACpB;AACF"}

package/dist/widgets/completions/github.d.mts

@@ -0,0 +1,64 @@
+import { n as PickerItem } from "../../picker-D8OLb6kZ.mjs";
+import { o as CompletionSource } from "../../autocomplete-Dfw-yQDa.mjs";
+//#region src/widgets/completions/github.d.ts
+/** A GitHub issue or pull request returned by `githubSource`. Shape
+ *  mirrors the `gh` CLI's `--json number,title,state,author,url`
+ *  output, with `type` added to distinguish issues from PRs. */
+type GithubItem = PickerItem & {
+  number: number;
+  title: string;
+  /** `"open"` / `"closed"` for issues; `"open"` / `"closed"` / `"merged"`
+   *  for PRs. Kept as a string so we don't trip if gh evolves. */
+  state: string;
+  type: "issue" | "pr";
+  url: string;
+  author?: {
+    login?: string;
+  };
+};
+type GithubState = "open" | "closed" | "all";
+type GithubFetcher = (cwd: string, state: GithubState) => Promise<GithubItem[]>;
+interface GithubSourceOptions {
+  /** Working directory used to locate the repo. `gh` resolves the repo
+   *  from the git remote of this dir. Default: `process.cwd()`. */
+  cwd?: string;
+  /** Trigger regex. Default: `/(?<=^|\s)#/` — `#` preceded by start-of-
+   *  string or whitespace (same lookbehind trick as `filesSource`). */
+  trigger?: RegExp;
+  /** Prepended to the accepted value so the trigger character stays in
+   *  the input. Default: `"#"`. */
+  prefix?: string;
+  /** Which issues / PRs to include. Default: `"open"`. */
+  state?: GithubState;
+  /** Per-kind cap passed to `gh`. Default: `50`. */
+  limit?: number;
+  /** Override the fetch implementation. Mainly useful for tests — the
+   *  default shells out to `gh`. The fetcher is called at most once per
+   *  `githubSource` instance; results are cached thereafter. */
+  fetcher?: GithubFetcher;
+}
+/**
+ * Completion source for GitHub issues and pull requests from the repo
+ * at `cwd`. Shells out to the `gh` CLI on first use, caches the result,
+ * and fuzzy-filters locally on subsequent calls so typing stays snappy.
+ *
+ * Accepts insert `#123 ` into the input — ready for a markdown-style
+ * reference in a chat message or commit subject.
+ *
+ * ```ts
+ * autocomplete({
+ *   input: "chat-input",
+ *   sources: {
+ *     gh: githubSource(),
+ *   },
+ * })
+ * ```
+ *
+ * Silently returns no items when `gh` isn't installed, the user isn't
+ * authenticated, or the directory isn't a GitHub repo — so it's safe
+ * to wire up unconditionally.
+ */
+declare function githubSource(opts?: GithubSourceOptions): CompletionSource<GithubItem>;
+//#endregion
+export { GithubFetcher, GithubItem, GithubSourceOptions, GithubState, githubSource };
+//# sourceMappingURL=github.d.mts.map