@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/reconciler-gfmqURLy.js

@@ -0,0 +1,680 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const process = __cjs_getProcess;
+import { version, createContext } from 'react';
+import createReconciler from 'react-reconciler';
+import { NoEventPriority, DefaultEventPriority } from 'react-reconciler/constants.js';
+import { unstable_shouldYield, unstable_scheduleCallback, unstable_now, unstable_cancelCallback } from 'scheduler';
+import Yoga from 'yoga-layout';
+import { b as insertBeforeNode, d as appendChildNode, s as setTextNodeValue, e as emitLayoutListeners, r as removeChildNode, f as createTextNode, c as createNode, h as setStyle, j as setAttribute } from './dom-DvzhsAez.js';
+
+const positionEdges = [
+  ["top", Yoga.EDGE_TOP],
+  ["right", Yoga.EDGE_RIGHT],
+  ["bottom", Yoga.EDGE_BOTTOM],
+  ["left", Yoga.EDGE_LEFT]
+];
+const applyPositionStyles = (node, style) => {
+  if ("position" in style) {
+    let positionType = Yoga.POSITION_TYPE_RELATIVE;
+    if (style.position === "absolute") {
+      positionType = Yoga.POSITION_TYPE_ABSOLUTE;
+    } else if (style.position === "static") {
+      positionType = Yoga.POSITION_TYPE_STATIC;
+    }
+    node.setPositionType(positionType);
+  }
+  for (const [property, edge] of positionEdges) {
+    if (!(property in style)) {
+      continue;
+    }
+    const value = style[property];
+    if (typeof value === "string") {
+      node.setPositionPercent(edge, Number.parseFloat(value));
+      continue;
+    }
+    node.setPosition(edge, value);
+  }
+};
+const applyMarginStyles = (node, style) => {
+  if ("margin" in style) {
+    node.setMargin(Yoga.EDGE_ALL, style.margin ?? 0);
+  }
+  if ("marginX" in style) {
+    node.setMargin(Yoga.EDGE_HORIZONTAL, style.marginX ?? 0);
+  }
+  if ("marginY" in style) {
+    node.setMargin(Yoga.EDGE_VERTICAL, style.marginY ?? 0);
+  }
+  if ("marginLeft" in style) {
+    node.setMargin(Yoga.EDGE_START, style.marginLeft || 0);
+  }
+  if ("marginRight" in style) {
+    node.setMargin(Yoga.EDGE_END, style.marginRight || 0);
+  }
+  if ("marginTop" in style) {
+    node.setMargin(Yoga.EDGE_TOP, style.marginTop || 0);
+  }
+  if ("marginBottom" in style) {
+    node.setMargin(Yoga.EDGE_BOTTOM, style.marginBottom || 0);
+  }
+};
+const applyPaddingStyles = (node, style) => {
+  if ("padding" in style) {
+    node.setPadding(Yoga.EDGE_ALL, style.padding ?? 0);
+  }
+  if ("paddingX" in style) {
+    node.setPadding(Yoga.EDGE_HORIZONTAL, style.paddingX ?? 0);
+  }
+  if ("paddingY" in style) {
+    node.setPadding(Yoga.EDGE_VERTICAL, style.paddingY ?? 0);
+  }
+  if ("paddingLeft" in style) {
+    node.setPadding(Yoga.EDGE_LEFT, style.paddingLeft || 0);
+  }
+  if ("paddingRight" in style) {
+    node.setPadding(Yoga.EDGE_RIGHT, style.paddingRight || 0);
+  }
+  if ("paddingTop" in style) {
+    node.setPadding(Yoga.EDGE_TOP, style.paddingTop || 0);
+  }
+  if ("paddingBottom" in style) {
+    node.setPadding(Yoga.EDGE_BOTTOM, style.paddingBottom || 0);
+  }
+};
+const applyFlexStyles = (node, style) => {
+  if ("flexGrow" in style) {
+    node.setFlexGrow(style.flexGrow ?? 0);
+  }
+  if ("flexShrink" in style) {
+    node.setFlexShrink(typeof style.flexShrink === "number" ? style.flexShrink : 1);
+  }
+  if ("flexWrap" in style) {
+    if (style.flexWrap === "nowrap") {
+      node.setFlexWrap(Yoga.WRAP_NO_WRAP);
+    }
+    if (style.flexWrap === "wrap") {
+      node.setFlexWrap(Yoga.WRAP_WRAP);
+    }
+    if (style.flexWrap === "wrap-reverse") {
+      node.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
+    }
+  }
+  if ("flexDirection" in style) {
+    if (style.flexDirection === "row") {
+      node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
+    }
+    if (style.flexDirection === "row-reverse") {
+      node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW_REVERSE);
+    }
+    if (style.flexDirection === "column") {
+      node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN);
+    }
+    if (style.flexDirection === "column-reverse") {
+      node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN_REVERSE);
+    }
+  }
+  if ("flexBasis" in style) {
+    if (typeof style.flexBasis === "number") {
+      node.setFlexBasis(style.flexBasis);
+    } else if (typeof style.flexBasis === "string") {
+      node.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
+    } else {
+      node.setFlexBasis(Number.NaN);
+    }
+  }
+  if ("alignItems" in style) {
+    if (style.alignItems === "stretch" || !style.alignItems) {
+      node.setAlignItems(Yoga.ALIGN_STRETCH);
+    }
+    if (style.alignItems === "flex-start") {
+      node.setAlignItems(Yoga.ALIGN_FLEX_START);
+    }
+    if (style.alignItems === "center") {
+      node.setAlignItems(Yoga.ALIGN_CENTER);
+    }
+    if (style.alignItems === "flex-end") {
+      node.setAlignItems(Yoga.ALIGN_FLEX_END);
+    }
+    if (style.alignItems === "baseline") {
+      node.setAlignItems(Yoga.ALIGN_BASELINE);
+    }
+  }
+  if ("alignSelf" in style) {
+    if (style.alignSelf === "auto" || !style.alignSelf) {
+      node.setAlignSelf(Yoga.ALIGN_AUTO);
+    }
+    if (style.alignSelf === "flex-start") {
+      node.setAlignSelf(Yoga.ALIGN_FLEX_START);
+    }
+    if (style.alignSelf === "center") {
+      node.setAlignSelf(Yoga.ALIGN_CENTER);
+    }
+    if (style.alignSelf === "flex-end") {
+      node.setAlignSelf(Yoga.ALIGN_FLEX_END);
+    }
+    if (style.alignSelf === "stretch") {
+      node.setAlignSelf(Yoga.ALIGN_STRETCH);
+    }
+    if (style.alignSelf === "baseline") {
+      node.setAlignSelf(Yoga.ALIGN_BASELINE);
+    }
+  }
+  if ("alignContent" in style) {
+    if (style.alignContent === "flex-start" || !style.alignContent) {
+      node.setAlignContent(Yoga.ALIGN_FLEX_START);
+    }
+    if (style.alignContent === "center") {
+      node.setAlignContent(Yoga.ALIGN_CENTER);
+    }
+    if (style.alignContent === "flex-end") {
+      node.setAlignContent(Yoga.ALIGN_FLEX_END);
+    }
+    if (style.alignContent === "space-between") {
+      node.setAlignContent(Yoga.ALIGN_SPACE_BETWEEN);
+    }
+    if (style.alignContent === "space-around") {
+      node.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
+    }
+    if (style.alignContent === "space-evenly") {
+      node.setAlignContent(Yoga.ALIGN_SPACE_EVENLY);
+    }
+    if (style.alignContent === "stretch") {
+      node.setAlignContent(Yoga.ALIGN_STRETCH);
+    }
+  }
+  if ("justifyContent" in style) {
+    if (style.justifyContent === "flex-start" || !style.justifyContent) {
+      node.setJustifyContent(Yoga.JUSTIFY_FLEX_START);
+    }
+    if (style.justifyContent === "center") {
+      node.setJustifyContent(Yoga.JUSTIFY_CENTER);
+    }
+    if (style.justifyContent === "flex-end") {
+      node.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
+    }
+    if (style.justifyContent === "space-between") {
+      node.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
+    }
+    if (style.justifyContent === "space-around") {
+      node.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
+    }
+    if (style.justifyContent === "space-evenly") {
+      node.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
+    }
+  }
+};
+const applyDimensionStyles = (node, style) => {
+  if ("width" in style) {
+    if (typeof style.width === "number") {
+      node.setWidth(style.width);
+    } else if (typeof style.width === "string") {
+      node.setWidthPercent(Number.parseInt(style.width, 10));
+    } else {
+      node.setWidthAuto();
+    }
+  }
+  if ("height" in style) {
+    if (typeof style.height === "number") {
+      node.setHeight(style.height);
+    } else if (typeof style.height === "string") {
+      node.setHeightPercent(Number.parseInt(style.height, 10));
+    } else {
+      node.setHeightAuto();
+    }
+  }
+  if ("minWidth" in style) {
+    if (typeof style.minWidth === "string") {
+      node.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
+    } else {
+      node.setMinWidth(style.minWidth ?? 0);
+    }
+  }
+  if ("minHeight" in style) {
+    if (typeof style.minHeight === "string") {
+      node.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
+    } else {
+      node.setMinHeight(style.minHeight ?? 0);
+    }
+  }
+  if ("maxWidth" in style) {
+    if (typeof style.maxWidth === "string") {
+      node.setMaxWidthPercent(Number.parseInt(style.maxWidth, 10));
+    } else {
+      node.setMaxWidth(style.maxWidth);
+    }
+  }
+  if ("maxHeight" in style) {
+    if (typeof style.maxHeight === "string") {
+      node.setMaxHeightPercent(Number.parseInt(style.maxHeight, 10));
+    } else {
+      node.setMaxHeight(style.maxHeight);
+    }
+  }
+  if ("aspectRatio" in style) {
+    node.setAspectRatio(style.aspectRatio);
+  }
+};
+const applyDisplayStyles = (node, style) => {
+  if ("display" in style) {
+    node.setDisplay(style.display === "flex" ? Yoga.DISPLAY_FLEX : Yoga.DISPLAY_NONE);
+  }
+};
+const applyBorderStyles = (node, style, currentStyle) => {
+  const hasBorderChanges = "borderStyle" in style || "borderTop" in style || "borderBottom" in style || "borderLeft" in style || "borderRight" in style;
+  if (!hasBorderChanges) {
+    return;
+  }
+  const borderWidth = currentStyle.borderStyle ? 1 : 0;
+  node.setBorder(Yoga.EDGE_TOP, currentStyle.borderTop === false ? 0 : borderWidth);
+  node.setBorder(Yoga.EDGE_BOTTOM, currentStyle.borderBottom === false ? 0 : borderWidth);
+  node.setBorder(Yoga.EDGE_LEFT, currentStyle.borderLeft === false ? 0 : borderWidth);
+  node.setBorder(Yoga.EDGE_RIGHT, currentStyle.borderRight === false ? 0 : borderWidth);
+};
+const applyGapStyles = (node, style) => {
+  if ("gap" in style) {
+    node.setGap(Yoga.GUTTER_ALL, style.gap ?? 0);
+  }
+  if ("columnGap" in style) {
+    node.setGap(Yoga.GUTTER_COLUMN, style.columnGap ?? 0);
+  }
+  if ("rowGap" in style) {
+    node.setGap(Yoga.GUTTER_ROW, style.rowGap ?? 0);
+  }
+};
+const applyOverflowStyles = (node, style) => {
+  const overflow = style.overflow ?? "visible";
+  const overflowX = style.overflowX ?? overflow;
+  const overflowY = style.overflowY ?? overflow;
+  if (overflowX === "scroll" || overflowY === "scroll") {
+    node.setOverflow(Yoga.OVERFLOW_SCROLL);
+  } else if (overflowX === "hidden" || overflowY === "hidden") {
+    node.setOverflow(Yoga.OVERFLOW_HIDDEN);
+  } else {
+    node.setOverflow(Yoga.OVERFLOW_VISIBLE);
+  }
+};
+const styles = (node, style = {}, currentStyle = style) => {
+  applyPositionStyles(node, style);
+  applyMarginStyles(node, style);
+  applyPaddingStyles(node, style);
+  applyFlexStyles(node, style);
+  applyDimensionStyles(node, style);
+  applyDisplayStyles(node, style);
+  applyBorderStyles(node, style, currentStyle);
+  applyGapStyles(node, style);
+  applyOverflowStyles(node, currentStyle);
+};
+
+if (process.env["DEV"] === "true") {
+  let isDevtoolsInstalled = false;
+  try {
+    import.meta.resolve("react-devtools-core");
+    isDevtoolsInstalled = true;
+  } catch {
+  }
+  if (isDevtoolsInstalled) {
+    await import('../packem_chunks/devtools.js');
+  }
+}
+const diff = (before, after) => {
+  if (before === after) {
+    return;
+  }
+  if (!before) {
+    return after;
+  }
+  const changed = {};
+  let isChanged = false;
+  for (const key of Object.keys(before)) {
+    const isDeleted = after ? !Object.hasOwn(after, key) : true;
+    if (isDeleted) {
+      changed[key] = void 0;
+      isChanged = true;
+    }
+  }
+  if (after) {
+    for (const key of Object.keys(after)) {
+      if (after[key] !== before[key]) {
+        changed[key] = after[key];
+        isChanged = true;
+      }
+    }
+  }
+  return isChanged ? changed : void 0;
+};
+const cleanupNodeTree = (node) => {
+  if (!node) {
+    return;
+  }
+  node.yogaNode?.unsetMeasureFunc();
+  if ("resizeObservers" in node) {
+    node.resizeObservers?.clear();
+  }
+  if ("childNodes" in node && node.childNodes) {
+    for (const child of node.childNodes) {
+      cleanupNodeTree(child);
+    }
+  }
+  node.yogaNode?.free();
+  if ("cachedRender" in node) {
+    node.cachedRender = void 0;
+  }
+  if ("childNodes" in node) {
+    node.childNodes = [];
+  }
+  node.parentNode = void 0;
+};
+let currentUpdatePriority = NoEventPriority;
+let currentRootNode;
+async function loadPackageJson() {
+  const fs = await import('node:fs');
+  const content = fs.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  const parsedContent = JSON.parse(content);
+  return {
+    name: parsedContent?.name,
+    version: parsedContent?.version
+  };
+}
+let packageInfo = {
+  name: "ink",
+  version: version
+};
+if (process.env["DEV"] === "true") {
+  try {
+    const loaded = await loadPackageJson();
+    packageInfo = {
+      name: loaded.name || packageInfo.name,
+      version: loaded.version || packageInfo.version
+    };
+  } catch (error) {
+    console.warn("Failed to load package.json in development mode. Falling back to default renderer metadata.", error);
+  }
+}
+const reconcilerInstance = createReconciler({
+  afterActiveInstanceBlur() {
+  },
+  appendChild: appendChildNode,
+  appendChildToContainer: appendChildNode,
+  appendInitialChild: appendChildNode,
+  beforeActiveInstanceBlur() {
+  },
+  // @ts-expect-error cancelCallback is not in @types/react-reconciler but required at runtime
+  cancelCallback: unstable_cancelCallback,
+  cancelTimeout: clearTimeout,
+  clearContainer: () => false,
+  commitTextUpdate(node, _oldText, newText) {
+    setTextNodeValue(node, newText);
+  },
+  commitUpdate(node, _type, oldProps, newProps) {
+    if (currentRootNode && node.internal_static) {
+      currentRootNode.isStaticDirty = true;
+    }
+    const props = diff(oldProps, newProps);
+    const style = diff(oldProps["style"], newProps["style"]);
+    if (!props && !style) {
+      return;
+    }
+    if (props) {
+      for (const [key, value] of Object.entries(props)) {
+        if (key === "style") {
+          setStyle(node, value);
+          continue;
+        }
+        if (key === "internal_transform") {
+          node.internal_transform = value;
+          continue;
+        }
+        if (key === "internal_cursor") {
+          node.internal_cursor = value;
+          continue;
+        }
+        if (key === "internal_static") {
+          node.internal_static = true;
+          continue;
+        }
+        if (key === "sticky") {
+          node.internal_sticky = value;
+          continue;
+        }
+        if (key === "internalStickyAlternate") {
+          node.internal_stickyAlternate = value;
+          continue;
+        }
+        if (key === "opaque") {
+          node.internal_opaque = value;
+          continue;
+        }
+        if (key === "scrollbar") {
+          node.internal_scrollbar = value;
+          continue;
+        }
+        if (key === "internal_terminalCursorFocus") {
+          node.internal_terminalCursorFocus = value;
+          continue;
+        }
+        if (key === "internal_terminalCursorPosition") {
+          node.internal_terminalCursorPosition = value;
+          continue;
+        }
+        if (key === "internal_static") {
+          node.internal_static = true;
+          continue;
+        }
+        if (key === "cachedRender") {
+          node.cachedRender = value;
+          continue;
+        }
+        setAttribute(node, key, value);
+      }
+    }
+    if (style && node.yogaNode) {
+      styles(node.yogaNode, style, newProps["style"] ?? {});
+    }
+  },
+  createInstance(originalType, newProps, rootNode, hostContext) {
+    if (hostContext.isInsideText && originalType === "ink-box") {
+      throw new Error(`<Box> can’t be nested inside <Text> component`);
+    }
+    if (hostContext.isInsideText && originalType === "ink-cursor") {
+      throw new Error(`<Cursor> can’t be nested inside <Text> component`);
+    }
+    const type = originalType === "ink-text" && hostContext.isInsideText ? "ink-virtual-text" : originalType;
+    const node = createNode(type);
+    for (const [key, value] of Object.entries(newProps)) {
+      if (key === "children") {
+        continue;
+      }
+      if (key === "style") {
+        setStyle(node, value);
+        if (node.yogaNode) {
+          styles(node.yogaNode, value);
+        }
+        continue;
+      }
+      if (key === "internal_transform") {
+        node.internal_transform = value;
+        continue;
+      }
+      if (key === "internal_cursor") {
+        node.internal_cursor = value;
+        continue;
+      }
+      if (key === "internal_static") {
+        currentRootNode = rootNode;
+        node.internal_static = true;
+        rootNode.isStaticDirty = true;
+        rootNode.staticNode = node;
+        continue;
+      }
+      if (key === "sticky") {
+        node.internal_sticky = value;
+        continue;
+      }
+      if (key === "internalStickyAlternate") {
+        node.internal_stickyAlternate = value;
+        continue;
+      }
+      if (key === "opaque") {
+        node.internal_opaque = value;
+        continue;
+      }
+      if (key === "scrollbar") {
+        node.internal_scrollbar = value;
+        continue;
+      }
+      if (key === "internal_terminalCursorFocus") {
+        node.internal_terminalCursorFocus = value;
+        continue;
+      }
+      if (key === "internal_terminalCursorPosition") {
+        node.internal_terminalCursorPosition = value;
+        continue;
+      }
+      if (key === "internal_static") {
+        node.internal_static = true;
+        continue;
+      }
+      if (key === "cachedRender") {
+        node.cachedRender = value;
+        continue;
+      }
+      setAttribute(node, key, value);
+    }
+    return node;
+  },
+  createTextInstance(text, _root, hostContext) {
+    if (!hostContext.isInsideText) {
+      throw new Error(`Text string "${text}" must be rendered inside <Text> component`);
+    }
+    return createTextNode(text);
+  },
+  detachDeletedInstance() {
+  },
+  finalizeInitialChildren() {
+    return false;
+  },
+  getChildHostContext(parentHostContext, type) {
+    const previousIsInsideText = parentHostContext.isInsideText;
+    const isInsideText = type === "ink-text" || type === "ink-virtual-text";
+    if (previousIsInsideText === isInsideText) {
+      return parentHostContext;
+    }
+    return { isInsideText };
+  },
+  getCurrentUpdatePriority: () => currentUpdatePriority,
+  getInstanceFromNode: () => null,
+  getInstanceFromScope: () => null,
+  getPublicInstance: (instance) => instance,
+  getRootHostContext: () => {
+    return {
+      isInsideText: false
+    };
+  },
+  hideInstance(node) {
+    node.internal_hidden = true;
+    node.yogaNode?.setDisplay(Yoga.DISPLAY_NONE);
+  },
+  hideTextInstance(node) {
+    setTextNodeValue(node, "");
+  },
+  HostTransitionContext: createContext(null),
+  insertBefore: insertBeforeNode,
+  insertInContainerBefore: insertBeforeNode,
+  isPrimaryRenderer: true,
+  maySuspendCommit() {
+    return true;
+  },
+  noTimeout: -1,
+  NotPendingTransition: void 0,
+  now: unstable_now,
+  preloadInstance() {
+    return true;
+  },
+  prepareForCommit: () => null,
+  preparePortalMount: () => null,
+  prepareScopeUpdate() {
+  },
+  removeChild(node, removeNode) {
+    removeChildNode(node, removeNode);
+    cleanupNodeTree(removeNode);
+  },
+  removeChildFromContainer(node, removeNode) {
+    removeChildNode(node, removeNode);
+    cleanupNodeTree(removeNode);
+  },
+  rendererPackageName: packageInfo.name,
+  rendererVersion: packageInfo.version,
+  requestPostPaintCallback() {
+  },
+  resetAfterCommit(rootNode) {
+    if (typeof rootNode.onComputeLayout === "function") {
+      rootNode.onComputeLayout();
+    }
+    emitLayoutListeners(rootNode);
+    if (rootNode.isStaticDirty) {
+      rootNode.isStaticDirty = false;
+      if (typeof rootNode.onImmediateRender === "function") {
+        rootNode.onImmediateRender();
+      }
+      return;
+    }
+    if (typeof rootNode.onRender === "function") {
+      rootNode.onRender();
+    }
+  },
+  resetFormInstance() {
+  },
+  resetTextContent() {
+  },
+  resolveEventTimeStamp() {
+    return -1.1;
+  },
+  resolveEventType() {
+    return null;
+  },
+  resolveUpdatePriority() {
+    if (currentUpdatePriority !== NoEventPriority) {
+      return currentUpdatePriority;
+    }
+    return DefaultEventPriority;
+  },
+  scheduleCallback: unstable_scheduleCallback,
+  scheduleMicrotask: queueMicrotask,
+  scheduleTimeout: setTimeout,
+  setCurrentUpdatePriority(newPriority) {
+    currentUpdatePriority = newPriority;
+  },
+  shouldAttemptEagerTransition() {
+    return false;
+  },
+  shouldSetTextContent: () => false,
+  shouldYield: unstable_shouldYield,
+  startSuspendingCommit() {
+  },
+  supportsHydration: false,
+  // Scheduler integration for concurrent mode
+  supportsMicrotasks: true,
+  supportsMutation: true,
+  supportsPersistence: false,
+  suspendInstance() {
+  },
+  trackSchedulerEvent() {
+  },
+  unhideInstance(node) {
+    node.internal_hidden = false;
+    node.yogaNode?.setDisplay(Yoga.DISPLAY_FLEX);
+  },
+  unhideTextInstance(node, text) {
+    setTextNodeValue(node, text);
+  },
+  waitForCommitToBeReady() {
+    return null;
+  }
+});
+
+export { reconcilerInstance as r, styles as s };