@zaly/tui 0.0.4 → 0.0.5

package/dist/widgets/select.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"select.mjs","names":["#items","#direction","#clamp","#windowStart"],"sources":["../../src/widgets/select.ts"],"sourcesContent":["import type { RenderCtx } from \"../core/ctx.ts\"\nimport type { BaseEvents } from \"../core/node.ts\"\nimport type { Reactive, Ref } from \"../core/reactive.ts\"\nimport type { State } from \"../core/state.ts\"\nimport type { NodeActionMap } from \"../input/actions.ts\"\nimport type { Size } from \"../layout/size.ts\"\nimport type { Style } from \"../style/types.ts\"\n\nimport { fitAnsi, stringWidth } from \"@zaly/shared/ansi\"\nimport { Node } from \"../core/node.ts\"\nimport { effect, unwrap } from \"../core/reactive.ts\"\nimport { resolveSize } from \"../layout/size.ts\"\n\n/** Default shape for selectable options. `text` is the canonical\n *  searchable/fallback label. `name` overrides the displayed label in the\n *  default renderer, and `desc` is shown as a dim right-column description. */\nexport type Option = {\n  name?: string\n  desc?: string\n  text: string\n}\n\nexport type OptionRenderCtx<T> = RenderCtx & {\n  visible: readonly T[]\n  items: readonly T[]\n  active?: boolean\n  prefixWidth?: number\n}\n\n/** Per-row rendering hook. `ctx.active` lets callers branch on selection\n *  state (e.g. swap an icon or pick a different fg) — but Select still\n *  applies the `optionActive` theme slot uniformly so the highlight stays\n *  visually consistent. The returned string is clipped/padded to the row\n *  width by Select. */\nexport type OptionRender<T> = (item: T, ctx: OptionRenderCtx<T>) => string\n\nexport interface SelectState<T extends Option = Option> extends Style {\n  /** Items to show. Accepts a signal accessor so the list can be\n   *  driven from reactive state (filtered results, search, etc.). */\n  items: Reactive<readonly T[]>\n  /** Index of the highlighted row. Defaults to 0; clamped on render. */\n  active?: number\n  /** Max item rows visible at once. The counter (when shown) is an\n   *  extra row on top of this, not counted against the cap. Window\n   *  slides to keep `active` in view (pin-until-leave). */\n  maxHeight?: Reactive<number>\n  /** Show a `(active+1 / total)` footer as an extra row when items\n   *  don't fit. `undefined` (default) auto-shows when needed;\n   *  `false` disables, `true` forces on. */\n  counter?: boolean\n  /** Render width. Defaults to `fill`. */\n  width?: Size\n  /** Width of the label column for the default renderer. Defaults to the\n   *  widest visible label, capped to half the row width. Ignored when\n   *  `render` is set. */\n  labelWidth?: number\n  /** Per-item renderer. When omitted, the default two-column layout uses\n   *  `name ?? text` as the label and `desc` as the right-column hint. */\n  render?: Reactive<OptionRender<T> | undefined>\n  reverse?: boolean\n  /** Whether there are more items available than are currently shown. This is a hint for the\n   *  default renderer to show a \"more\" indicator in the counter. */\n  more?: boolean\n}\n\nexport interface SelectEvents<T extends Option = Option> extends BaseEvents {\n  /** Fired when the user completes the active item. Payload is the item. */\n  complete: { item: T }\n  /** Fired when the user picks the active item. Payload is the item. */\n  accept: { item: T }\n  /** Fired when the user closes the select (esc). */\n  close: {}\n  changed: { active: number; item?: T }\n}\n\n/**\n * Selectable list. Items are rendered one per row with an active-row\n * highlight; navigation actions (`next`, `prev`, `first`, `last`,\n * `accept`, `complete`, `cancel`) live on `this.actions`, same pattern as\n * `Input`.\n *\n * Used standalone for simple lists and as the underlying list primitive for\n * `picker`, `tree`, and `autocomplete`. Doesn't open/close itself — callers\n * control visibility via `state.visible`.\n */\nexport class Select<T extends Option = Option> extends Node<SelectState<T>, SelectEvents<T>> {\n  static readonly type = \"select\"\n  override readonly type = Select.type\n\n  override actions = {\n    \"select.accept\": (): void => {\n      const items = this.#items\n      if (items.length === 0) return\n      void this.emit(\"accept\", { item: items[this.active] })\n    },\n    \"select.close\": (): void => {\n      void this.emit(\"close\")\n    },\n    \"select.complete\": (): void => {\n      const items = this.#items\n      if (items.length === 0) return\n      void this.emit(\"complete\", { item: items[this.active] })\n    },\n    \"select.first\": (): void => {\n      if (this.#items.length === 0) return\n      this.active = 0\n    },\n    \"select.last\": (): void => {\n      const n = this.#items.length\n      if (n === 0) return\n      this.active = n - 1\n    },\n    \"select.next\": (): void => {\n      const n = this.#items.length\n      if (n === 0) return\n      this.active += this.#direction\n    },\n    \"select.page-down\": (): void => {\n      const n = this.#items.length\n      if (n === 0) return\n      const page = Math.max(this.pageSize - 1, 1)\n      this.state.active = this.#clamp(this.active + this.#direction * page)\n    },\n    \"select.page-up\": (): void => {\n      const n = this.#items.length\n      if (n === 0) return\n      const page = Math.max(this.pageSize - 1, 1)\n      this.state.active = this.#clamp(this.active - this.#direction * page)\n    },\n    \"select.prev\": (): void => {\n      const n = this.#items.length\n      if (n === 0) return\n      this.active -= this.#direction\n    },\n  } satisfies NodeActionMap\n\n  /** Top of the currently-rendered window, in absolute item indices.\n   *  Updated per render using the pin-until-leave rule: stays put\n   *  while `active` remains in `[start, start + visible)`, slides just\n   *  enough to re-admit it otherwise. */\n  #windowStart = 0\n\n  constructor(initial: SelectState<T>) {\n    super({ active: 0, ...initial } as SelectState<T>)\n\n    let active = this.item\n    effect(() => {\n      const next = this.item\n      if (next === active) return\n      active = next\n      void this.emit(\"changed\", { active: this.active, item: next })\n    })\n  }\n\n  get #direction(): 1 | -1 {\n    return this.state.reverse ? -1 : 1\n  }\n\n  get #items() {\n    return unwrap(this.state.items)\n  }\n\n  #clamp(i: number): number {\n    const n = this.#items.length\n    return n === 0 ? 0 : Math.max(0, Math.min(n - 1, i))\n  }\n\n  set active(i: number) {\n    const n = this.#items.length\n    this.state.active = n === 0 ? 0 : ((i % n) + n) % n\n  }\n\n  get active(): number {\n    const a = this.state.active ?? 0\n    const n = this.#items.length\n    if (n === 0) return 0\n    return Math.max(0, Math.min(n - 1, a))\n  }\n\n  bind(node: Node | Ref<Node>): this {\n    let n: Node | undefined\n    const getn = () => (n = node instanceof Node ? node : node())\n    this.on(\"mount\", () => getn().addActionTarget(this))\n    this.on(\"unmount\", () => n?.removeActionTarget(this))\n    if (this.mounted) getn().addActionTarget(this)\n    return this\n  }\n\n  get count(): number {\n    return this.#items.length\n  }\n\n  get pageSize(): number {\n    return unwrap(this.state.maxHeight) ?? Math.max(this.#items.length, 1)\n  }\n\n  get item(): T | undefined {\n    return this.#items[this.active]\n  }\n\n  protected _render(ctx: RenderCtx): string[] {\n    const items = this.#items\n    if (items.length === 0) return []\n\n    const width = resolveSize(this.state.width ?? \"fill\", ctx.width) ?? ctx.width\n    const active = this.active\n    const height = Math.min(this.pageSize, items.length)\n    if (height === 0) return []\n\n    // Pin-until-leave window. `#windowStart` is kept across renders so\n    // the list doesn't recenter while the user nudges up/down inside\n    let start = this.#windowStart\n    if (active < start) start = active\n    else if (active >= start + height) start = active - height + 1\n    start = Math.max(0, Math.min(Math.max(0, items.length - height), start))\n    this.#windowStart = start\n\n    const visible = items.slice(start, start + height)\n    const renderer = this.renderer\n\n    const rows: string[] = []\n    for (let i = start; i < start + height; i++) {\n      const item = items[i]\n      let row = renderer(item, {\n        ...ctx,\n        active: i === active,\n        items,\n        visible,\n      }).replace(/\\n/g, \" \")\n      row = fitAnsi(row, width)\n      rows.push(i === active ? ctx.style.optionActive(row) : row)\n    }\n    if (this.state.reverse) rows.reverse()\n\n    if (this.state.counter ?? items.length > height) {\n      const shown = items.length === 0 ? 0 : active + 1\n      const label = `(${shown}/${items.length}${this.state.more ? \"+\" : \"\"})`\n      rows.push(ctx.style.gutter(fitAnsi(label, width)))\n    }\n\n    return rows\n  }\n\n  get renderer(): OptionRender<T> {\n    return unwrap(this.state.render) ?? this.defaultRenderer()\n  }\n\n  extendRenderer(fn: (prev: OptionRender<T>) => OptionRender<T>): this {\n    const prev = this.renderer\n    this.state.render = fn(prev)\n    return this\n  }\n\n  defaultRenderer(): OptionRender<Option> {\n    let visible: readonly Option[] = []\n    let labelWidth = 0\n\n    const update = (ctx: OptionRenderCtx<Option>) => {\n      if (ctx.visible === visible) return\n      visible = ctx.visible\n      if (!visible.some((i) => i.desc)) return (labelWidth = ctx.width) // No desc, so full width\n      labelWidth = this.state.labelWidth ?? 0\n      labelWidth ||= visible\n        .map(itemLabel)\n        .reduce((max, label) => Math.max(max, stringWidth(label)), 0)\n      labelWidth = Math.min(labelWidth, Math.floor(ctx.width / 2))\n    }\n\n    return (item: Option, ctx): string => {\n      update(ctx)\n      const label = fitAnsi(itemLabel(item), labelWidth)\n      if (!item.desc) return ctx.style.optionName(label)\n      const desc = fitAnsi(item.desc ?? \"\", Math.max(0, ctx.width - labelWidth - 2))\n      return `${ctx.style.optionName(label)}  ${ctx.style.optionDesc(desc)}`\n    }\n  }\n}\n\nconst itemLabel = (item: Option): string => (item.name ?? item.text).replace(/\\s+/g, \" \").trim()\n\n/**\n * Factory for a selectable list.\n *\n * ```ts\n * const s = select({ items: [{ text: \"/help\" }, { text: \"/quit\" }] })\n * s.on(\"accept\", ({ item }) => console.log(\"picked\", item.text))\n * ```\n */\nexport function select<T extends Option = Option>(state: State<SelectState<T>>): Select<T> {\n  return new Select<T>(state)\n}\n"],"mappings":"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"}

package/dist/widgets/show.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"show.mjs","names":["#state","#owner","#nodes"],"sources":["../../src/widgets/show.ts"],"sourcesContent":["import type { RenderCtx } from \"../core/ctx.ts\"\nimport type { Reactive } from \"../core/reactive.ts\"\n\nimport { Node } from \"../core/node.ts\"\nimport { untrack, unwrap, useActiveOwner, withOwner } from \"../core/reactive.ts\"\n\nexport type ShowGate = { when: Reactive<unknown> }\nexport type ShowBranch = { when: Reactive<unknown>; use: ShowChildren }\nexport type ShowChildren = () => Node | Node[]\nexport type ShowSpec = (ShowGate | ShowBranch)[] | [...(ShowGate | ShowBranch)[], ShowChildren]\n\ntype ShowState = {\n  when: Reactive<unknown>\n  use?: ShowChildren\n  children?: Node[]\n}\n\nexport type { Show }\n\n/** Conditional fragment backing `show()`. Branches are created lazily:\n * a `use` factory only runs the first time its condition wins. Once\n * created, the branch remains mounted and owned; inactive branches simply\n * don't participate in layout/rendering and contribute zero rows.\n *\n * Lazy factories run under the owner captured at `show()` creation time,\n * so context reads behave as if the branch had been constructed eagerly.\n */\nclass Show extends Node {\n  #state: ShowState[] = []\n  #owner = useActiveOwner()\n\n  constructor(spec: ShowSpec) {\n    super({})\n    let fallback = false\n    for (const s of spec) {\n      if (fallback) throw new Error(\"Show: `fallback` must be the final argument\")\n      if (typeof s === \"function\") {\n        this.#state.push({ use: s, when: true })\n        fallback = true\n      } else this.#state.push(s)\n    }\n  }\n\n  #nodes(s: ShowState, use: ShowChildren): Node[] {\n    if (s.children) return s.children\n    const create = () => untrack(use)\n    const nodes = this.#owner ? withOwner(this.#owner, create) : create()\n    s.children = Array.isArray(nodes) ? nodes : [nodes]\n    for (const c of s.children) this.add(c)\n    return s.children\n  }\n\n  override layoutChildren(): readonly Node[] {\n    for (const s of this.#state) {\n      const matches = unwrap(s.when)\n      if (s.use === undefined) {\n        if (!matches) return []\n        continue\n      } else if (!matches) continue\n      return this.#nodes(s, s.use)\n    }\n    return []\n  }\n\n  /** Standalone-render fallback. Box parents go through\n   *  `layoutChildren` and bypass this; only fires when `Show` sits\n   *  outside a layout container (root, overlay, etc.). */\n  protected async _render(ctx: RenderCtx): Promise<string[]> {\n    const targets = this.layoutChildren()\n    const rows = await Promise.all(targets.map((c) => c.render(ctx)))\n    return rows.flat()\n  }\n}\n\n/** Lazy conditional rendering.\n *\n * Specs are evaluated from left to right:\n * - `{ when }` is a guard. When false, rendering stops with no rows; when\n *   true, evaluation continues.\n * - `{ when, use }` is a conditional branch. The first branch whose\n *   condition is truthy is rendered.\n * - A final bare factory is the fallback branch and must be the last\n *   argument.\n *\n * Branch factories are lazy and run at most once. Created branches stay\n * mounted across toggles, preserving state, effects, and async resources.\n *\n * ```ts\n * show({ when: isLoading }, () => spinner({ color: \"accent\" }))\n *\n * show(\n *   { when: full },\n *   { when: isError, use: () => errorView() },\n *   () => resultView()\n * )\n * ```\n */\nexport function show(...spec: ShowSpec): Show {\n  return new Show(spec)\n}\n"],"mappings":";;;;;;;;;;;AA2BA,IAAM,OAAN,cAAmB,KAAK;CACtB,SAAsB,CAAC;CACvB,SAAS,eAAe;CAExB,YAAY,MAAgB;EAC1B,MAAM,CAAC,CAAC;EACR,IAAI,WAAW;EACf,KAAK,MAAM,KAAK,MAAM;GACpB,IAAI,UAAU,MAAM,IAAI,MAAM,6CAA6C;GAC3E,IAAI,OAAO,MAAM,YAAY;IAC3B,KAAKA,OAAO,KAAK;KAAE,KAAK;KAAG,MAAM;IAAK,CAAC;IACvC,WAAW;GACb,OAAO,KAAKA,OAAO,KAAK,CAAC;EAC3B;CACF;CAEA,OAAO,GAAc,KAA2B;EAC9C,IAAI,EAAE,UAAU,OAAO,EAAE;EACzB,MAAM,eAAe,QAAQ,GAAG;EAChC,MAAM,QAAQ,KAAKC,SAAS,UAAU,KAAKA,QAAQ,MAAM,IAAI,OAAO;EACpE,EAAE,WAAW,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;EAClD,KAAK,MAAM,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;EACtC,OAAO,EAAE;CACX;CAEA,iBAA2C;EACzC,KAAK,MAAM,KAAK,KAAKD,QAAQ;GAC3B,MAAM,UAAU,OAAO,EAAE,IAAI;GAC7B,IAAI,EAAE,QAAQ,KAAA,GAAW;IACvB,IAAI,CAAC,SAAS,OAAO,CAAC;IACtB;GACF,OAAO,IAAI,CAAC,SAAS;GACrB,OAAO,KAAKE,OAAO,GAAG,EAAE,GAAG;EAC7B;EACA,OAAO,CAAC;CACV;;;;CAKA,MAAgB,QAAQ,KAAmC;EACzD,MAAM,UAAU,KAAK,eAAe;EAEpC,QAAO,MADY,QAAQ,IAAI,QAAQ,KAAK,MAAM,EAAE,OAAO,GAAG,CAAC,CAAC,EAAA,CACpD,KAAK;CACnB;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,KAAK,GAAG,MAAsB;CAC5C,OAAO,IAAI,KAAK,IAAI;AACtB"}

package/dist/widgets/text.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.mjs","names":[],"sources":["../../src/widgets/text.ts"],"sourcesContent":["import type { MaybePromise } from \"@zaly/shared\"\nimport type { RenderCtx } from \"../core/ctx.ts\"\nimport type { Reactive } from \"../core/reactive.ts\"\nimport type { State } from \"../core/state.ts\"\nimport type { Style } from \"../style/types.ts\"\n\nimport { Node } from \"../core/node.ts\"\nimport { unwrap } from \"../core/reactive.ts\"\nimport { calcLayout, formatText } from \"../layout/text.ts\"\n\n/**\n * Text content — three forms, resolved at render time:\n *\n *   1. Plain string — static content.\n *   2. Reactive accessor (`signal()` / `memo()`) — re-reads on each\n *      render and subscribes the node so signal writes invalidate.\n *   3. `(ctx) => string` — computed from the render context. Use this\n *      for inline-styled spans via `ctx.style`.\n *\n * Branded accessors are picked up via `isAccessor`; any other function\n * is treated as the ctx-aware form. Plain strings pass through.\n *\n * ```ts\n * text(\"hello\")\n * text(name)                                  // signal accessor\n * text(({ style }) => style.ok(`✓ ${count}`)) // ctx-aware\n * ```\n */\nexport type TextContent = Reactive<string> | ((ctx: RenderCtx) => MaybePromise<Reactive<string>>)\n\nexport interface TextStyle extends Style {\n  content: TextContent\n  wrap?: \"word\" | \"char\" | \"none\"\n}\n\nexport class Text extends Node<TextStyle> {\n  protected async _render(ctx: RenderCtx): Promise<string[]> {\n    const content = await textContent(this.state.content, ctx)\n    return formatText(content, {\n      style: ctx.style.add(this.state),\n      width: ctx.width,\n      wrap: this.state.wrap,\n    })\n  }\n\n  override async layout(ctx: RenderCtx) {\n    return calcLayout(await textContent(this.state.content, ctx), { wrap: this.state.wrap })\n  }\n}\n\nexport function textContent(content: TextContent, ctx: RenderCtx): Promise<string>\nexport function textContent(content: TextContent | undefined, ctx: RenderCtx): Promise<undefined>\nexport async function textContent(\n  content: TextContent | undefined,\n  ctx: RenderCtx\n): Promise<string | undefined> {\n  if (content === undefined) return\n  const raw = unwrap(content)\n  return unwrap(typeof raw === \"string\" ? raw : await raw(ctx))\n}\n\n/**\n * Factory for `Text`. Content can be a plain string or a `(ctx) => string`\n * function that's called at render time — use the function form when you\n * want inline-styled spans via `ctx.style`.\n *\n * ```ts\n * text(\"hello\")\n * text(\"hello\", { fg: \"primary\", bold: true })\n * text({ content: \"hello\", fg: \"primary\" })\n * text(({ style }) => `ok: ${style.ok(\"yes\")}`)\n * ```\n */\nexport function text(content: TextContent, style?: Omit<State<TextStyle>, \"content\">): Text\nexport function text(style: State<TextStyle>): Text\nexport function text(\n  first: TextContent | State<TextStyle>,\n  style?: Omit<State<TextStyle>, \"content\">\n): Text {\n  // TextContent: string | function (incl. reactive accessor) | …\n  // TextStyle:   plain object with a `content` field.\n  // The TextStyle branch is picked only when `first` is a non-function\n  // object — accessors are functions, so they go through the content path.\n  if (typeof first === \"string\" || typeof first === \"function\") {\n    return new Text({ content: first, ...style })\n  }\n  return new Text(first)\n}\n"],"mappings":";;;;AAmCA,IAAa,OAAb,cAA0B,KAAgB;CACxC,MAAgB,QAAQ,KAAmC;EAEzD,OAAO,WAAW,MADI,YAAY,KAAK,MAAM,SAAS,GAAG,GAC9B;GACzB,OAAO,IAAI,MAAM,IAAI,KAAK,KAAK;GAC/B,OAAO,IAAI;GACX,MAAM,KAAK,MAAM;EACnB,CAAC;CACH;CAEA,MAAe,OAAO,KAAgB;EACpC,OAAO,WAAW,MAAM,YAAY,KAAK,MAAM,SAAS,GAAG,GAAG,EAAE,MAAM,KAAK,MAAM,KAAK,CAAC;CACzF;AACF;AAIA,eAAsB,YACpB,SACA,KAC6B;CAC7B,IAAI,YAAY,KAAA,GAAW;CAC3B,MAAM,MAAM,OAAO,OAAO;CAC1B,OAAO,OAAO,OAAO,QAAQ,WAAW,MAAM,MAAM,IAAI,GAAG,CAAC;AAC9D;AAgBA,SAAgB,KACd,OACA,OACM;CAKN,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAChD,OAAO,IAAI,KAAK;EAAE,SAAS;EAAO,GAAG;CAAM,CAAC;CAE9C,OAAO,IAAI,KAAK,KAAK;AACvB"}

package/dist/widgets/tree.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree.mjs","names":["#build"],"sources":["../../src/widgets/tree.ts"],"sourcesContent":["import type { Reactive } from \"../core/reactive.ts\"\nimport type { Option, Select, SelectState } from \"./select.ts\"\n\nimport { stringWidth } from \"@zaly/shared/ansi\"\nimport { memo, unwrap } from \"../core/reactive.ts\"\nimport { select } from \"./select.ts\"\nimport { widget } from \"./widget.ts\"\n\nexport type TreeItem<T extends Option = Option> = T & {\n  children?: TreeItem<T>[]\n  icon?: string\n}\n\nexport type TreeProps<T extends TreeItem = TreeItem> = Omit<SelectState<T>, \"items\" | \"active\"> & {\n  tree: Reactive<T>\n  /** If true, the root node will be rendered and selectable. Defaults to false. */\n  root?: boolean\n  active?: T | ((item: T) => boolean)\n}\n\nconst icons = {\n  // last: \"└─\",\n  last: \"╰─\",\n  middle: \"├─\",\n  vertical: \"│ \",\n}\n\nexport type TreeNode<T extends TreeItem> = {\n  last?: boolean\n  parent?: T\n}\n\nclass Tree<T extends TreeItem> {\n  nodes = new Map<T, TreeNode<T>>()\n  items: T[] = []\n\n  constructor(public root: T) {\n    this.#build(root, undefined, true)\n  }\n\n  #build(item: T, parent?: T, last?: boolean) {\n    this.nodes.set(item, { last, parent })\n    this.items.push(item)\n    const children = item.children ?? []\n    for (let c = 0; c < children.length; c++) {\n      const child = children[c] as T\n      this.#build(child, item, c === children.length - 1)\n    }\n  }\n\n  node(item: T) {\n    return this.nodes.get(item)\n  }\n}\n\nexport const tree = widget(\n  <T extends TreeItem>(props: TreeProps<T>): Select<T> & { items: Reactive<T[]> } => {\n    const builder = memo(() => new Tree(unwrap(props.tree)))\n    const items = memo(() => (props.root === true ? builder().items : builder().items.slice(1)))\n\n    const activeFn =\n      typeof props.active === \"function\" ? props.active : (i: T) => i === props.active\n    const active = props.active ? items().findIndex((i) => activeFn(i)) : -1\n\n    const ret = select({ ...props, active: active === -1 ? 0 : active, items })\n\n    ret.extendRenderer((prev) => (item, ctx) => {\n      const t = builder()\n      const path: string[] = []\n      const s = ctx.style\n      const itemNode = t.node(item)\n      let n = t.node(item)\n      while (n?.parent) {\n        if (props.root !== true && n.parent === props.tree) break\n        let icon = \"\"\n        if (n !== itemNode) icon = n.last ? \"  \" : icons.vertical\n        else icon = n.last ? icons.last : icons.middle\n        path.unshift(icon)\n        n = t.node(n.parent)\n      }\n      const prefix = path.join(\"\")\n      const prefixWidth = stringWidth(prefix)\n      const text = prev(item, { ...ctx, prefixWidth, width: ctx.width - prefixWidth }).replace(\n        /\\s/g,\n        \" \"\n      )\n      return `${s.gutter(prefix)}${text}`\n    })\n\n    return Object.assign(ret, { items })\n  }\n)\n"],"mappings":";;;;;AAoBA,MAAM,QAAQ;CAEZ,MAAM;CACN,QAAQ;CACR,UAAU;AACZ;AAOA,IAAM,OAAN,MAA+B;CAIV;CAHnB,wBAAQ,IAAI,IAAoB;CAChC,QAAa,CAAC;CAEd,YAAY,MAAgB;EAAT,KAAA,OAAA;EACjB,KAAKA,OAAO,MAAM,KAAA,GAAW,IAAI;CACnC;CAEA,OAAO,MAAS,QAAY,MAAgB;EAC1C,KAAK,MAAM,IAAI,MAAM;GAAE;GAAM;EAAO,CAAC;EACrC,KAAK,MAAM,KAAK,IAAI;EACpB,MAAM,WAAW,KAAK,YAAY,CAAC;EACnC,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,MAAM,QAAQ,SAAS;GACvB,KAAKA,OAAO,OAAO,MAAM,MAAM,SAAS,SAAS,CAAC;EACpD;CACF;CAEA,KAAK,MAAS;EACZ,OAAO,KAAK,MAAM,IAAI,IAAI;CAC5B;AACF;AAEA,MAAa,OAAO,QACG,UAA8D;CACjF,MAAM,UAAU,WAAW,IAAI,KAAK,OAAO,MAAM,IAAI,CAAC,CAAC;CACvD,MAAM,QAAQ,WAAY,MAAM,SAAS,OAAO,QAAQ,CAAC,CAAC,QAAQ,QAAQ,CAAC,CAAC,MAAM,MAAM,CAAC,CAAE;CAE3F,MAAM,WACJ,OAAO,MAAM,WAAW,aAAa,MAAM,UAAU,MAAS,MAAM,MAAM;CAC5E,MAAM,SAAS,MAAM,SAAS,MAAM,CAAC,CAAC,WAAW,MAAM,SAAS,CAAC,CAAC,IAAI;CAEtE,MAAM,MAAM,OAAO;EAAE,GAAG;EAAO,QAAQ,WAAW,KAAK,IAAI;EAAQ;CAAM,CAAC;CAE1E,IAAI,gBAAgB,UAAU,MAAM,QAAQ;EAC1C,MAAM,IAAI,QAAQ;EAClB,MAAM,OAAiB,CAAC;EACxB,MAAM,IAAI,IAAI;EACd,MAAM,WAAW,EAAE,KAAK,IAAI;EAC5B,IAAI,IAAI,EAAE,KAAK,IAAI;EACnB,OAAO,GAAG,QAAQ;GAChB,IAAI,MAAM,SAAS,QAAQ,EAAE,WAAW,MAAM,MAAM;GACpD,IAAI,OAAO;GACX,IAAI,MAAM,UAAU,OAAO,EAAE,OAAO,OAAO,MAAM;QAC5C,OAAO,EAAE,OAAO,MAAM,OAAO,MAAM;GACxC,KAAK,QAAQ,IAAI;GACjB,IAAI,EAAE,KAAK,EAAE,MAAM;EACrB;EACA,MAAM,SAAS,KAAK,KAAK,EAAE;EAC3B,MAAM,cAAc,YAAY,MAAM;EACtC,MAAM,OAAO,KAAK,MAAM;GAAE,GAAG;GAAK;GAAa,OAAO,IAAI,QAAQ;EAAY,CAAC,CAAC,CAAC,QAC/E,OACA,GACF;EACA,OAAO,GAAG,EAAE,OAAO,MAAM,IAAI;CAC/B,CAAC;CAED,OAAO,OAAO,OAAO,KAAK,EAAE,MAAM,CAAC;AACrC,CACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"widget.d.mts","names":[],"sources":["../../src/widgets/widget.ts"],"mappings":";;KAIY,QAAQ;;;;;;;;;;;KAYR,OAAO,+BAA+B,UAAU,OAAO,YAAY,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkC3E,OAAO,UAAU,QAAQ,IAAI,IAAI"}

package/dist/widgets/widget.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"widget.mjs","names":[],"sources":["../../src/widgets/widget.ts"],"sourcesContent":["import type { Node } from \"../core/node.ts\"\n\nimport { createNode } from \"../core/reactive.ts\"\n\nexport type Props = Record<string, unknown>\n\n/**\n * A widget factory: takes some args, returns a `Node`.\n *\n * The default `A = never[]` makes the *bare* `Widget` the universal\n * \"any widget\" type — the `(...args: never[]) => Node` idiom. Every\n * concrete factory (zero-arg, `state + ...children`, single-props) is\n * assignable to it, so it works both as the `widget()` constraint and\n * as a stored value type (`details?: Widget`, invoked zero-arg). Supply\n * `A` explicitly for a precise signature: `Widget<[State<LogState>]>`.\n */\nexport type Widget<A extends unknown[] = never[], N extends Node = Node> = (...args: A) => N\n\n/**\n * Type helper for declaring widgets — runtime identity, just `return fn`.\n *\n * Three things it earns:\n *   1. Inference at the declaration site: TS infers `S` from the function\n *      parameter and enforces it on every call site.\n *   2. A consistent grep target: every component reads as\n *      `export const foo = widget((props) => …)`.\n *   3. A future seam for instrumentation, lifecycle wrappers, devtools.\n *\n * The factory body runs **once** at construction. Reactive content lives\n * in leaf thunks (`text(({ style }) => …)`), not by re-running the body\n * — this is the Solid model, not React's. `ctx` is therefore unavailable\n * inside the factory; reach for it inside leaf thunks where it belongs.\n *\n * ```ts\n * const status = widget((props: { level: \"ok\" | \"warn\"; msg: string }) =>\n *   text(({ style }) => `${style.bold[props.level](\"●\")} ${style.dim(props.msg)}`),\n * )\n *\n * status({ level: \"ok\", msg: \"all systems nominal\" })\n * ```\n */\n/**\n * Call-site args derived from `S`:\n *   - If `S` declares `children`, `children` is injected from rest args;\n *     state at the call site has `children` omitted, then `...children`.\n *   - Otherwise, no rest is allowed.\n *   - Either way, the state arg is optional when every field of the\n *     resolved state is optional (so bare `widget()` works).\n */\n\nexport function widget<T extends Widget>(fn: T): T {\n  return ((...args: Parameters<T>) => createNode(() => fn(...args))) as T\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,OAAyB,IAAU;CACjD,SAAS,GAAG,SAAwB,iBAAiB,GAAG,GAAG,IAAI,CAAC;AAClE"}

package/dist/worker-DjHuQSbY.mjs

@@ -1,27 +0,0 @@
-//#region src/shiki/worker.ts
-async function createWorker(scriptURL) {
-	if (typeof globalThis.Worker === "function") {
-		const w = new Worker(scriptURL, { type: "module" });
-		w.unref?.();
-		return {
-			on: (event, handler) => {
-				if (event === "error") w.addEventListener(event, (e) => void handler(e.error ?? new Error(e.message)));
-				else w.addEventListener(event, (e) => void handler(e.data));
-			},
-			postMessage: (message) => w.postMessage(message),
-			terminate: () => w.terminate()
-		};
-	}
-	const { Worker: NodeWorker } = await import("node:worker_threads");
-	const worker = new NodeWorker(scriptURL);
-	worker.unref();
-	return {
-		on: (event, handler) => worker.on(event, (e) => void handler(e)),
-		postMessage: (message) => worker.postMessage(message),
-		terminate: () => void worker.terminate()
-	};
-}
-//#endregion
-export { createWorker };
-
-//# sourceMappingURL=worker-DjHuQSbY.mjs.map

package/dist/worker-DjHuQSbY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-DjHuQSbY.mjs","names":[],"sources":["../src/shiki/worker.ts"],"sourcesContent":["// oxlint-disable typescript/method-signature-style unicorn/require-post-message-target-origin\nimport type { MaybePromise } from \"@zaly/shared\"\n\nexport const workerHost = {\n  onMessage: (handler: (message: any) => MaybePromise): void => {\n    if (typeof globalThis.addEventListener === \"function\") {\n      globalThis.addEventListener(\"message\", (event: MessageEvent) => void handler(event.data))\n      return\n    }\n    void import(\"node:worker_threads\").then(({ parentPort }) => {\n      parentPort?.on(\"message\", (message) => void handler(message))\n    })\n  },\n\n  postMessage: (message: unknown): void => {\n    if (typeof globalThis.postMessage === \"function\") {\n      // oxlint-disable-next-line unicorn/require-post-message-target-origin\n      globalThis.postMessage(message)\n      return\n    }\n    void import(\"node:worker_threads\").then(({ parentPort }) => {\n      // oxlint-disable-next-line unicorn/require-post-message-target-origin\n      parentPort?.postMessage(message)\n    })\n  },\n}\n\nexport type WorkerInstance<In = unknown, Out = unknown> = {\n  on(event: \"message\", handler: (message: Out) => MaybePromise): void\n  on(event: \"error\", handler: (error: Error) => MaybePromise): void\n  postMessage(message: In): void\n  terminate(): void\n}\n\nexport async function createWorker<In = unknown, Out = unknown>(\n  scriptURL: string | URL\n): Promise<WorkerInstance<In, Out>> {\n  if (typeof globalThis.Worker === \"function\") {\n    const w = new Worker(scriptURL, { type: \"module\" })\n    // oxlint-disable-next-line typescript/no-unnecessary-condition\n    w.unref?.()\n    return {\n      on: (event, handler) => {\n        if (event === \"error\")\n          w.addEventListener(event, (e) => void handler(e.error ?? new Error(e.message)))\n        else w.addEventListener(event, (e) => void handler(e.data))\n      },\n      postMessage: (message) => w.postMessage(message),\n      terminate: () => w.terminate(),\n    }\n  }\n  const { Worker: NodeWorker } = await import(\"node:worker_threads\")\n  const worker = new NodeWorker(scriptURL)\n  worker.unref()\n  return {\n    on: (event, handler) => worker.on(event, (e) => void handler(e)),\n    postMessage: (message) => worker.postMessage(message),\n    terminate: () => void worker.terminate(),\n  }\n}\n"],"mappings":";AAkCA,eAAsB,aACpB,WACkC;CAClC,IAAI,OAAO,WAAW,WAAW,YAAY;EAC3C,MAAM,IAAI,IAAI,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC;EAElD,EAAE,QAAQ;EACV,OAAO;GACL,KAAK,OAAO,YAAY;IACtB,IAAI,UAAU,SACZ,EAAE,iBAAiB,QAAQ,MAAM,KAAK,QAAQ,EAAE,SAAS,IAAI,MAAM,EAAE,OAAO,CAAC,CAAC;SAC3E,EAAE,iBAAiB,QAAQ,MAAM,KAAK,QAAQ,EAAE,IAAI,CAAC;GAC5D;GACA,cAAc,YAAY,EAAE,YAAY,OAAO;GAC/C,iBAAiB,EAAE,UAAU;EAC/B;CACF;CACA,MAAM,EAAE,QAAQ,eAAe,MAAM,OAAO;CAC5C,MAAM,SAAS,IAAI,WAAW,SAAS;CACvC,OAAO,MAAM;CACb,OAAO;EACL,KAAK,OAAO,YAAY,OAAO,GAAG,QAAQ,MAAM,KAAK,QAAQ,CAAC,CAAC;EAC/D,cAAc,YAAY,OAAO,YAAY,OAAO;EACpD,iBAAiB,KAAK,OAAO,UAAU;CACzC;AACF"}