@kitn.ai/ui 0.28.0 → 0.29.0

package/src/components/composer-highlight.ts

@@ -1,242 +0,0 @@
-import type { HighlightRule } from './composer';
-import { createTextWalker } from './composer-dom';
-
-export interface HighlightMatch {
-  start: number;
-  end: number;
-  class: string | undefined;
-}
-
-/** Escape special regex metacharacters in a literal string. */
-function escapeRegex(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Find all non-overlapping highlight ranges in `text` for the given rules.
- *
- * - A string rule is matched as a case-insensitive literal (regex metachars are escaped).
- * - An object rule uses `new RegExp(pattern, flags ?? 'gi')`.
- * - Overlapping ranges are resolved in earliest-start order; later ranges that
- *   overlap an already-claimed span are dropped.
- * - Zero-width matches are skipped to avoid infinite loops.
- * - Returns `[]` when nothing matches.
- */
-export function findHighlightMatches(text: string, rules: HighlightRule[]): HighlightMatch[] {
-  const candidates: HighlightMatch[] = [];
-
-  for (const rule of rules) {
-    let regex: RegExp;
-    let cls: string | undefined;
-
-    if (typeof rule === 'string') {
-      regex = new RegExp(escapeRegex(rule), 'gi');
-      cls = undefined;
-    } else {
-      regex = new RegExp(rule.pattern, rule.flags ?? 'gi');
-      cls = rule.class;
-    }
-
-    // Reset lastIndex so we scan from the beginning regardless of flag state.
-    regex.lastIndex = 0;
-
-    let match: RegExpExecArray | null;
-    while ((match = regex.exec(text)) !== null) {
-      const start = match.index;
-      const end = start + match[0].length;
-
-      // Guard against zero-width matches to avoid infinite loops.
-      if (end === start) {
-        regex.lastIndex = start + 1;
-        continue;
-      }
-
-      candidates.push({ start, end, class: cls });
-    }
-  }
-
-  // Sort by start position (tie-break: earlier rule wins, which preserves insertion order).
-  candidates.sort((a, b) => a.start - b.start);
-
-  // Remove overlapping ranges (greedy earliest-start wins).
-  const result: HighlightMatch[] = [];
-  let frontier = -1; // end of the last accepted range
-  for (const c of candidates) {
-    if (c.start >= frontier) {
-      result.push(c);
-      frontier = c.end;
-    }
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// CSS Custom Highlight API — ambient type declarations
-// (jsdom does not ship these; they are defined here rather than in a lib to
-// keep the footprint minimal and avoid tsconfig changes.)
-// ---------------------------------------------------------------------------
-
-declare global {
-  // CSS.highlights is defined on the CSS namespace object.
-  interface CSSNamespace {
-    highlights?: HighlightRegistry;
-  }
-  interface HighlightRegistry {
-    set(name: string, highlight: CSSHighlight): void;
-    delete(name: string): boolean;
-    has(name: string): boolean;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  class CSSHighlight {
-    constructor(...ranges: Range[]);
-  }
-}
-
-/**
- * Feature-detect whether the CSS Custom Highlight API is available in the
- * current environment.  Returns false in jsdom (decoration no-op).
- */
-export function supportsHighlightAPI(): boolean {
-  try {
-    return (
-      typeof CSS !== 'undefined' &&
-      typeof CSS.highlights !== 'undefined' &&
-      typeof Highlight !== 'undefined'
-    );
-  } catch {
-    return false;
-  }
-}
-
-const HIGHLIGHT_NAME = 'kai-composer-highlight';
-
-/**
- * Apply highlight matches to a contenteditable element using the CSS Custom
- * Highlight API.  Maps text offsets (ZWSP-stripped concatenated text) to DOM
- * Ranges spanning across text nodes, builds a `Highlight`, and registers it.
- *
- * If the API is unavailable (jsdom, older browsers), this is a strict no-op.
- *
- * @param root     The contenteditable element.
- * @param matches  Pre-computed non-overlapping `{start, end}` ranges.
- * @param zwsp     The ZWSP character used in the editable (passed to avoid
- *                 a circular import; callers pass ZWSP from composer-dom).
- */
-export function applyHighlights(
-  root: HTMLElement,
-  matches: HighlightMatch[],
-  zwsp: string,
-  name = HIGHLIGHT_NAME,
-): void {
-  if (!supportsHighlightAPI()) return;
-
-  const registry = CSS.highlights as HighlightRegistry;
-
-  if (matches.length === 0) {
-    registry.delete(name);
-    return;
-  }
-
-  // Build a flat list of {node, rawStart, rawEnd} segments mirroring
-  // how getFullText works, but retaining the raw (pre-stripped) offsets so
-  // we can set Range.setStart/setEnd correctly.
-  //
-  // Each entry records:
-  //   textNode   - the DOM Text node
-  //   stripped   - the node's textContent with ZWSP removed
-  //   rawOffset  - raw index in textContent where the stripped content starts
-  //                at the node level (always 0 — we need per-char mapping when
-  //                ZWSP chars are interspersed, so we build a per-node map)
-  //   strippedStart - cumulative stripped-text offset at the start of this node
-  //
-  interface NodeEntry {
-    node: Text;
-    strippedStart: number; // cumulative stripped offset before this node
-    // Maps stripped-relative index i → raw textContent index
-    strippedToRaw: Int32Array;
-  }
-
-  const entries: NodeEntry[] = [];
-  let cursor = 0; // cumulative stripped offset
-
-  const ownerDoc = root.ownerDocument;
-  const walker = createTextWalker(root); // skip text inside entity pills
-  let node = walker.nextNode() as Text | null;
-  while (node) {
-    const raw = node.textContent ?? '';
-    // Build stripped→raw index map for this node.
-    const strippedIndices: number[] = [];
-    for (let ri = 0; ri < raw.length; ri++) {
-      if (raw[ri] !== zwsp) {
-        strippedIndices.push(ri);
-      }
-    }
-    if (strippedIndices.length > 0) {
-      const map = new Int32Array(strippedIndices.length);
-      for (let i = 0; i < strippedIndices.length; i++) map[i] = strippedIndices[i];
-      entries.push({ node, strippedStart: cursor, strippedToRaw: map });
-      cursor += strippedIndices.length;
-    }
-    node = walker.nextNode() as Text | null;
-  }
-
-  /**
-   * Convert a stripped-text offset to a {node, rawOffset} pair for Range API.
-   * Returns null if out of range.
-   */
-  function resolve(
-    strippedOffset: number,
-  ): { node: Text; rawOffset: number } | null {
-    // Binary-search for the entry that contains strippedOffset.
-    let lo = 0;
-    let hi = entries.length - 1;
-    while (lo <= hi) {
-      const mid = (lo + hi) >> 1;
-      const e = entries[mid];
-      const eEnd = e.strippedStart + e.strippedToRaw.length;
-      if (strippedOffset < e.strippedStart) {
-        hi = mid - 1;
-      } else if (strippedOffset >= eEnd) {
-        lo = mid + 1;
-      } else {
-        const localIdx = strippedOffset - e.strippedStart;
-        return { node: e.node, rawOffset: e.strippedToRaw[localIdx] };
-      }
-    }
-    // strippedOffset is exactly at the end of the last entry — point after
-    // the last raw character of the last node.
-    if (entries.length > 0) {
-      const last = entries[entries.length - 1];
-      const localIdx = strippedOffset - last.strippedStart;
-      if (localIdx === last.strippedToRaw.length) {
-        // End position: raw offset is one past the last stripped char's raw index.
-        return {
-          node: last.node,
-          rawOffset: last.strippedToRaw[last.strippedToRaw.length - 1] + 1,
-        };
-      }
-    }
-    return null;
-  }
-
-  const ranges: Range[] = [];
-  for (const m of matches) {
-    const startPos = resolve(m.start);
-    const endPos = resolve(m.end);
-    if (!startPos || !endPos) continue;
-
-    const r = ownerDoc.createRange();
-    r.setStart(startPos.node, startPos.rawOffset);
-    r.setEnd(endPos.node, endPos.rawOffset);
-    ranges.push(r);
-  }
-
-  if (ranges.length === 0) {
-    registry.delete(name);
-    return;
-  }
-
-  const hl = new Highlight(...ranges);
-  registry.set(name, hl);
-}

package/src/components/composer-history.ts

@@ -1,82 +0,0 @@
-import type { ComposerDoc } from '../primitives/composer-model';
-
-/**
- * Undo/redo history for the composer.
- *
- * The browser's native contenteditable undo stack can't track our programmatic
- * pill insertion/deletion — it leaves pills stuck and replays text edits against
- * a DOM we changed underneath it, corrupting the content. So we own the history:
- * a stack of document-model snapshots. Restoring a snapshot re-renders the doc
- * (pills included, since each snapshot holds full EntityRefs) and the caret.
- *
- * Pure module — no DOM. The caller computes `coalesce` (true to merge a run of
- * consecutive typing into one undo step; false for a structural edit like a pill
- * insert/delete, which gets its own step).
- */
-
-export interface Snapshot {
-  doc: ComposerDoc;
-  caret: number;
-}
-
-export interface ComposerHistory {
-  /** Record a new state. `coalesce` merges it into the current entry instead of
-   *  pushing a new one (used for consecutive typing). */
-  record(snap: Snapshot, coalesce: boolean): void;
-  /** Step back; returns the snapshot to restore, or null if nothing to undo. */
-  undo(): Snapshot | null;
-  /** Step forward; returns the snapshot to restore, or null if nothing to redo. */
-  redo(): Snapshot | null;
-  /** Replace all history with a single baseline entry (e.g. external value set). */
-  reset(snap: Snapshot): void;
-  canUndo(): boolean;
-  canRedo(): boolean;
-  /** Current entry count (for tests/debugging). */
-  size(): number;
-}
-
-export function createHistory(initial: Snapshot, limit = 200): ComposerHistory {
-  let entries: Snapshot[] = [initial];
-  let index = 0;
-
-  return {
-    record(snap, coalesce) {
-      if (coalesce && index === entries.length - 1) {
-        // Merge into the current entry (a continuing run of typing).
-        entries[index] = snap;
-        return;
-      }
-      // Drop any redo branch, then push a fresh entry.
-      entries = entries.slice(0, index + 1);
-      entries.push(snap);
-      if (entries.length > limit) {
-        entries.shift();
-      } else {
-        index++;
-      }
-    },
-    undo() {
-      if (index === 0) return null;
-      index--;
-      return entries[index];
-    },
-    redo() {
-      if (index >= entries.length - 1) return null;
-      index++;
-      return entries[index];
-    },
-    reset(snap) {
-      entries = [snap];
-      index = 0;
-    },
-    canUndo() {
-      return index > 0;
-    },
-    canRedo() {
-      return index < entries.length - 1;
-    },
-    size() {
-      return entries.length;
-    },
-  };
-}