@xmem-ai/memcode 4.0.2

package/dist/ink/components/TerminalFocusContext.js

@@ -0,0 +1,45 @@
+import { jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { createContext, useSyncExternalStore } from "react";
+import { getTerminalFocused, getTerminalFocusState, subscribeTerminalFocus } from "../terminal-focus-state.js";
+const TerminalFocusContext = createContext({
+  isTerminalFocused: true,
+  terminalFocusState: "unknown"
+});
+TerminalFocusContext.displayName = "TerminalFocusContext";
+function TerminalFocusProvider(t0) {
+  const $ = _c(6);
+  const {
+    children
+  } = t0;
+  const isTerminalFocused = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocused);
+  const terminalFocusState = useSyncExternalStore(subscribeTerminalFocus, getTerminalFocusState);
+  let t1;
+  if ($[0] !== isTerminalFocused || $[1] !== terminalFocusState) {
+    t1 = {
+      isTerminalFocused,
+      terminalFocusState
+    };
+    $[0] = isTerminalFocused;
+    $[1] = terminalFocusState;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const value = t1;
+  let t2;
+  if ($[3] !== children || $[4] !== value) {
+    t2 = /* @__PURE__ */ jsx(TerminalFocusContext.Provider, { value, children });
+    $[3] = children;
+    $[4] = value;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+var TerminalFocusContext_default = TerminalFocusContext;
+export {
+  TerminalFocusProvider,
+  TerminalFocusContext_default as default
+};

package/dist/ink/components/TerminalSizeContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const TerminalSizeContext = createContext(null);
+export {
+  TerminalSizeContext
+};

package/dist/ink/components/Text.js

@@ -0,0 +1,195 @@
+import { jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+const memoizedStylesForWrap = {
+  wrap: {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "wrap"
+  },
+  "wrap-trim": {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "wrap-trim"
+  },
+  end: {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "end"
+  },
+  middle: {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "middle"
+  },
+  "truncate-end": {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "truncate-end"
+  },
+  truncate: {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "truncate"
+  },
+  "truncate-middle": {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "truncate-middle"
+  },
+  "truncate-start": {
+    flexGrow: 0,
+    flexShrink: 1,
+    flexDirection: "row",
+    textWrap: "truncate-start"
+  }
+};
+function Text(t0) {
+  const $ = _c(29);
+  const {
+    color,
+    backgroundColor,
+    bold,
+    dim,
+    italic: t1,
+    underline: t2,
+    strikethrough: t3,
+    inverse: t4,
+    wrap: t5,
+    children
+  } = t0;
+  const italic = t1 === void 0 ? false : t1;
+  const underline = t2 === void 0 ? false : t2;
+  const strikethrough = t3 === void 0 ? false : t3;
+  const inverse = t4 === void 0 ? false : t4;
+  const wrap = t5 === void 0 ? "wrap" : t5;
+  if (children === void 0 || children === null) {
+    return null;
+  }
+  let t6;
+  if ($[0] !== color) {
+    t6 = color && {
+      color
+    };
+    $[0] = color;
+    $[1] = t6;
+  } else {
+    t6 = $[1];
+  }
+  let t7;
+  if ($[2] !== backgroundColor) {
+    t7 = backgroundColor && {
+      backgroundColor
+    };
+    $[2] = backgroundColor;
+    $[3] = t7;
+  } else {
+    t7 = $[3];
+  }
+  let t8;
+  if ($[4] !== dim) {
+    t8 = dim && {
+      dim
+    };
+    $[4] = dim;
+    $[5] = t8;
+  } else {
+    t8 = $[5];
+  }
+  let t9;
+  if ($[6] !== bold) {
+    t9 = bold && {
+      bold
+    };
+    $[6] = bold;
+    $[7] = t9;
+  } else {
+    t9 = $[7];
+  }
+  let t10;
+  if ($[8] !== italic) {
+    t10 = italic && {
+      italic
+    };
+    $[8] = italic;
+    $[9] = t10;
+  } else {
+    t10 = $[9];
+  }
+  let t11;
+  if ($[10] !== underline) {
+    t11 = underline && {
+      underline
+    };
+    $[10] = underline;
+    $[11] = t11;
+  } else {
+    t11 = $[11];
+  }
+  let t12;
+  if ($[12] !== strikethrough) {
+    t12 = strikethrough && {
+      strikethrough
+    };
+    $[12] = strikethrough;
+    $[13] = t12;
+  } else {
+    t12 = $[13];
+  }
+  let t13;
+  if ($[14] !== inverse) {
+    t13 = inverse && {
+      inverse
+    };
+    $[14] = inverse;
+    $[15] = t13;
+  } else {
+    t13 = $[15];
+  }
+  let t14;
+  if ($[16] !== t10 || $[17] !== t11 || $[18] !== t12 || $[19] !== t13 || $[20] !== t6 || $[21] !== t7 || $[22] !== t8 || $[23] !== t9) {
+    t14 = {
+      ...t6,
+      ...t7,
+      ...t8,
+      ...t9,
+      ...t10,
+      ...t11,
+      ...t12,
+      ...t13
+    };
+    $[16] = t10;
+    $[17] = t11;
+    $[18] = t12;
+    $[19] = t13;
+    $[20] = t6;
+    $[21] = t7;
+    $[22] = t8;
+    $[23] = t9;
+    $[24] = t14;
+  } else {
+    t14 = $[24];
+  }
+  const textStyles = t14;
+  const t15 = memoizedStylesForWrap[wrap];
+  let t16;
+  if ($[25] !== children || $[26] !== t15 || $[27] !== textStyles) {
+    t16 = /* @__PURE__ */ jsx("ink-text", { style: t15, textStyles, children });
+    $[25] = children;
+    $[26] = t15;
+    $[27] = textStyles;
+    $[28] = t16;
+  } else {
+    t16 = $[28];
+  }
+  return t16;
+}
+export {
+  Text as default
+};

package/dist/ink/constants.js

@@ -0,0 +1,4 @@
+const FRAME_INTERVAL_MS = 16;
+export {
+  FRAME_INTERVAL_MS
+};

package/dist/ink/dom.js

@@ -0,0 +1,240 @@
+import { createLayoutNode } from "./layout/engine.js";
+import { LayoutDisplay, LayoutMeasureMode } from "./layout/node.js";
+import measureText from "./measure-text.js";
+import { addPendingClear, nodeCache } from "./node-cache.js";
+import squashTextNodes from "./squash-text-nodes.js";
+import { expandTabs } from "./tabstops.js";
+import wrapText from "./wrap-text.js";
+const createNode = (nodeName) => {
+  const needsYogaNode = nodeName !== "ink-virtual-text" && nodeName !== "ink-link" && nodeName !== "ink-progress";
+  const node = {
+    nodeName,
+    style: {},
+    attributes: {},
+    childNodes: [],
+    parentNode: void 0,
+    yogaNode: needsYogaNode ? createLayoutNode() : void 0,
+    dirty: false
+  };
+  if (nodeName === "ink-text") {
+    node.yogaNode?.setMeasureFunc(measureTextNode.bind(null, node));
+  } else if (nodeName === "ink-raw-ansi") {
+    node.yogaNode?.setMeasureFunc(measureRawAnsiNode.bind(null, node));
+  }
+  return node;
+};
+const appendChildNode = (node, childNode) => {
+  if (childNode.parentNode) {
+    removeChildNode(childNode.parentNode, childNode);
+  }
+  childNode.parentNode = node;
+  node.childNodes.push(childNode);
+  if (childNode.yogaNode) {
+    node.yogaNode?.insertChild(
+      childNode.yogaNode,
+      node.yogaNode.getChildCount()
+    );
+  }
+  markDirty(node);
+};
+const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+  if (newChildNode.parentNode) {
+    removeChildNode(newChildNode.parentNode, newChildNode);
+  }
+  newChildNode.parentNode = node;
+  const index = node.childNodes.indexOf(beforeChildNode);
+  if (index >= 0) {
+    let yogaIndex = 0;
+    if (newChildNode.yogaNode && node.yogaNode) {
+      for (let i = 0; i < index; i++) {
+        if (node.childNodes[i]?.yogaNode) {
+          yogaIndex++;
+        }
+      }
+    }
+    node.childNodes.splice(index, 0, newChildNode);
+    if (newChildNode.yogaNode && node.yogaNode) {
+      node.yogaNode.insertChild(newChildNode.yogaNode, yogaIndex);
+    }
+    markDirty(node);
+    return;
+  }
+  node.childNodes.push(newChildNode);
+  if (newChildNode.yogaNode) {
+    node.yogaNode?.insertChild(
+      newChildNode.yogaNode,
+      node.yogaNode.getChildCount()
+    );
+  }
+  markDirty(node);
+};
+const removeChildNode = (node, removeNode) => {
+  if (removeNode.yogaNode) {
+    removeNode.parentNode?.yogaNode?.removeChild(removeNode.yogaNode);
+  }
+  collectRemovedRects(node, removeNode);
+  removeNode.parentNode = void 0;
+  const index = node.childNodes.indexOf(removeNode);
+  if (index >= 0) {
+    node.childNodes.splice(index, 1);
+  }
+  markDirty(node);
+};
+function collectRemovedRects(parent, removed, underAbsolute = false) {
+  if (removed.nodeName === "#text") return;
+  const elem = removed;
+  const isAbsolute = underAbsolute || elem.style.position === "absolute";
+  const cached = nodeCache.get(elem);
+  if (cached) {
+    addPendingClear(parent, cached, isAbsolute);
+    nodeCache.delete(elem);
+  }
+  for (const child of elem.childNodes) {
+    collectRemovedRects(parent, child, isAbsolute);
+  }
+}
+const setAttribute = (node, key, value) => {
+  if (key === "children") {
+    return;
+  }
+  if (node.attributes[key] === value) {
+    return;
+  }
+  node.attributes[key] = value;
+  markDirty(node);
+};
+const setStyle = (node, style) => {
+  if (stylesEqual(node.style, style)) {
+    return;
+  }
+  node.style = style;
+  markDirty(node);
+};
+const setTextStyles = (node, textStyles) => {
+  if (shallowEqual(node.textStyles, textStyles)) {
+    return;
+  }
+  node.textStyles = textStyles;
+  markDirty(node);
+};
+function stylesEqual(a, b) {
+  return shallowEqual(a, b);
+}
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (a === void 0 || b === void 0) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (a[key] !== b[key]) return false;
+  }
+  return true;
+}
+const createTextNode = (text) => {
+  const node = {
+    nodeName: "#text",
+    nodeValue: text,
+    yogaNode: void 0,
+    parentNode: void 0,
+    style: {}
+  };
+  setTextNodeValue(node, text);
+  return node;
+};
+const measureTextNode = function(node, width, widthMode) {
+  const rawText = node.nodeName === "#text" ? node.nodeValue : squashTextNodes(node);
+  const text = expandTabs(rawText);
+  const dimensions = measureText(text, width);
+  if (dimensions.width <= width) {
+    return dimensions;
+  }
+  if (dimensions.width >= 1 && width > 0 && width < 1) {
+    return dimensions;
+  }
+  if (text.includes("\n") && widthMode === LayoutMeasureMode.Undefined) {
+    const effectiveWidth = Math.max(width, dimensions.width);
+    return measureText(text, effectiveWidth);
+  }
+  const textWrap = node.style?.textWrap ?? "wrap";
+  const wrappedText = wrapText(text, width, textWrap);
+  return measureText(wrappedText, width);
+};
+const measureRawAnsiNode = function(node) {
+  return {
+    width: node.attributes["rawWidth"],
+    height: node.attributes["rawHeight"]
+  };
+};
+const markDirty = (node) => {
+  let current = node;
+  let markedYoga = false;
+  while (current) {
+    if (current.nodeName !== "#text") {
+      ;
+      current.dirty = true;
+      if (!markedYoga && (current.nodeName === "ink-text" || current.nodeName === "ink-raw-ansi") && current.yogaNode) {
+        current.yogaNode.markDirty();
+        markedYoga = true;
+      }
+    }
+    current = current.parentNode;
+  }
+};
+const scheduleRenderFrom = (node) => {
+  let cur = node;
+  while (cur?.parentNode) cur = cur.parentNode;
+  if (cur && cur.nodeName !== "#text") cur.onRender?.();
+};
+const setTextNodeValue = (node, text) => {
+  if (typeof text !== "string") {
+    text = String(text);
+  }
+  if (node.nodeValue === text) {
+    return;
+  }
+  node.nodeValue = text;
+  markDirty(node);
+};
+function isDOMElement(node) {
+  return node.nodeName !== "#text";
+}
+const clearYogaNodeReferences = (node) => {
+  if ("childNodes" in node) {
+    for (const child of node.childNodes) {
+      clearYogaNodeReferences(child);
+    }
+  }
+  node.yogaNode = void 0;
+};
+function findOwnerChainAtRow(root, y) {
+  let best = [];
+  walk(root, 0);
+  return best;
+  function walk(node, offsetY) {
+    const yoga = node.yogaNode;
+    if (!yoga || yoga.getDisplay() === LayoutDisplay.None) return;
+    const top = offsetY + yoga.getComputedTop();
+    const height = yoga.getComputedHeight();
+    if (y < top || y >= top + height) return;
+    if (node.debugOwnerChain) best = node.debugOwnerChain;
+    for (const child of node.childNodes) {
+      if (isDOMElement(child)) walk(child, top);
+    }
+  }
+}
+export {
+  appendChildNode,
+  clearYogaNodeReferences,
+  createNode,
+  createTextNode,
+  findOwnerChainAtRow,
+  insertBeforeNode,
+  markDirty,
+  removeChildNode,
+  scheduleRenderFrom,
+  setAttribute,
+  setStyle,
+  setTextNodeValue,
+  setTextStyles
+};

package/dist/ink/events/click-event.js

@@ -0,0 +1,32 @@
+import { Event } from "./event.js";
+class ClickEvent extends Event {
+  /** 0-indexed screen column of the click */
+  col;
+  /** 0-indexed screen row of the click */
+  row;
+  /**
+   * Click column relative to the current handler's Box (col - box.x).
+   * Recomputed by dispatchClick before each handler fires, so an onClick
+   * on a container sees coords relative to that container, not to any
+   * child the click landed on.
+   */
+  localCol = 0;
+  /** Click row relative to the current handler's Box (row - box.y). */
+  localRow = 0;
+  /**
+   * True if the clicked cell has no visible content (unwritten in the
+   * screen buffer — both packed words are 0). Handlers can check this to
+   * ignore clicks on blank space to the right of text, so accidental
+   * clicks on empty terminal space don't toggle state.
+   */
+  cellIsBlank;
+  constructor(col, row, cellIsBlank) {
+    super();
+    this.col = col;
+    this.row = row;
+    this.cellIsBlank = cellIsBlank;
+  }
+}
+export {
+  ClickEvent
+};

package/dist/ink/events/dispatcher.js

@@ -0,0 +1,148 @@
+import {
+  ContinuousEventPriority,
+  DefaultEventPriority,
+  DiscreteEventPriority,
+  NoEventPriority
+} from "react-reconciler/constants.js";
+import { logError } from "../../utils/log.js";
+import { HANDLER_FOR_EVENT } from "./event-handlers.js";
+function getHandler(node, eventType, capture) {
+  const handlers = node._eventHandlers;
+  if (!handlers) return void 0;
+  const mapping = HANDLER_FOR_EVENT[eventType];
+  if (!mapping) return void 0;
+  const propName = capture ? mapping.capture : mapping.bubble;
+  if (!propName) return void 0;
+  return handlers[propName];
+}
+function collectListeners(target, event) {
+  const listeners = [];
+  let node = target;
+  while (node) {
+    const isTarget = node === target;
+    const captureHandler = getHandler(node, event.type, true);
+    const bubbleHandler = getHandler(node, event.type, false);
+    if (captureHandler) {
+      listeners.unshift({
+        node,
+        handler: captureHandler,
+        phase: isTarget ? "at_target" : "capturing"
+      });
+    }
+    if (bubbleHandler && (event.bubbles || isTarget)) {
+      listeners.push({
+        node,
+        handler: bubbleHandler,
+        phase: isTarget ? "at_target" : "bubbling"
+      });
+    }
+    node = node.parentNode;
+  }
+  return listeners;
+}
+function processDispatchQueue(listeners, event) {
+  let previousNode;
+  for (const { node, handler, phase } of listeners) {
+    if (event._isImmediatePropagationStopped()) {
+      break;
+    }
+    if (event._isPropagationStopped() && node !== previousNode) {
+      break;
+    }
+    event._setEventPhase(phase);
+    event._setCurrentTarget(node);
+    event._prepareForTarget(node);
+    try {
+      handler(event);
+    } catch (error) {
+      logError(error);
+    }
+    previousNode = node;
+  }
+}
+function getEventPriority(eventType) {
+  switch (eventType) {
+    case "keydown":
+    case "keyup":
+    case "click":
+    case "focus":
+    case "blur":
+    case "paste":
+      return DiscreteEventPriority;
+    case "resize":
+    case "scroll":
+    case "mousemove":
+      return ContinuousEventPriority;
+    default:
+      return DefaultEventPriority;
+  }
+}
+class Dispatcher {
+  currentEvent = null;
+  currentUpdatePriority = DefaultEventPriority;
+  discreteUpdates = null;
+  /**
+   * Infer event priority from the currently-dispatching event.
+   * Called by the reconciler host config's resolveUpdatePriority
+   * when no explicit priority has been set.
+   */
+  resolveEventPriority() {
+    if (this.currentUpdatePriority !== NoEventPriority) {
+      return this.currentUpdatePriority;
+    }
+    if (this.currentEvent) {
+      return getEventPriority(this.currentEvent.type);
+    }
+    return DefaultEventPriority;
+  }
+  /**
+   * Dispatch an event through capture and bubble phases.
+   * Returns true if preventDefault() was NOT called.
+   */
+  dispatch(target, event) {
+    const previousEvent = this.currentEvent;
+    this.currentEvent = event;
+    try {
+      event._setTarget(target);
+      const listeners = collectListeners(target, event);
+      processDispatchQueue(listeners, event);
+      event._setEventPhase("none");
+      event._setCurrentTarget(null);
+      return !event.defaultPrevented;
+    } finally {
+      this.currentEvent = previousEvent;
+    }
+  }
+  /**
+   * Dispatch with discrete (sync) priority.
+   * For user-initiated events: keyboard, click, focus, paste.
+   */
+  dispatchDiscrete(target, event) {
+    if (!this.discreteUpdates) {
+      return this.dispatch(target, event);
+    }
+    return this.discreteUpdates(
+      (t, e) => this.dispatch(t, e),
+      target,
+      event,
+      void 0,
+      void 0
+    );
+  }
+  /**
+   * Dispatch with continuous priority.
+   * For high-frequency events: resize, scroll, mouse move.
+   */
+  dispatchContinuous(target, event) {
+    const previousPriority = this.currentUpdatePriority;
+    try {
+      this.currentUpdatePriority = ContinuousEventPriority;
+      return this.dispatch(target, event);
+    } finally {
+      this.currentUpdatePriority = previousPriority;
+    }
+  }
+}
+export {
+  Dispatcher
+};

package/dist/ink/events/emitter.js

@@ -0,0 +1,28 @@
+import { EventEmitter as NodeEventEmitter } from "events";
+import { Event } from "./event.js";
+class EventEmitter extends NodeEventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(0);
+  }
+  emit(type, ...args) {
+    if (type === "error") {
+      return super.emit(type, ...args);
+    }
+    const listeners = this.rawListeners(type);
+    if (listeners.length === 0) {
+      return false;
+    }
+    const ccEvent = args[0] instanceof Event ? args[0] : null;
+    for (const listener of listeners) {
+      listener.apply(this, args);
+      if (ccEvent?.didStopImmediatePropagation()) {
+        break;
+      }
+    }
+    return true;
+  }
+}
+export {
+  EventEmitter
+};