green-screen-react 0.3.0

package/dist/index.js

@@ -0,0 +1,1269 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GreenScreenTerminal: () => GreenScreenTerminal,
+  RestAdapter: () => RestAdapter,
+  TN5250Terminal: () => TN5250Terminal,
+  TerminalBootLoader: () => TerminalBootLoader,
+  getProtocolProfile: () => getProtocolProfile,
+  getRowColorClass: () => getRowColorClass,
+  hp6530Profile: () => hp6530Profile,
+  isFieldEntry: () => isFieldEntry,
+  parseHeaderRow: () => parseHeaderRow,
+  positionToRowCol: () => positionToRowCol,
+  tn3270Profile: () => tn3270Profile,
+  tn5250Profile: () => tn5250Profile,
+  useTN5250Connection: () => useTN5250Connection,
+  useTN5250Screen: () => useTN5250Screen,
+  useTN5250Terminal: () => useTN5250Terminal,
+  useTerminalConnection: () => useTerminalConnection,
+  useTerminalInput: () => useTerminalInput,
+  useTerminalScreen: () => useTerminalScreen,
+  useTypingAnimation: () => useTypingAnimation,
+  vtProfile: () => vtProfile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/components/GreenScreenTerminal.tsx
+var import_react4 = require("react");
+
+// src/hooks/useTN5250.ts
+var import_react = require("react");
+function useTerminalConnection(adapter) {
+  const [status, setStatus] = (0, import_react.useState)(null);
+  const [loading, setLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const fetchStatus = (0, import_react.useCallback)(async () => {
+    try {
+      const result = await adapter.getStatus();
+      setStatus(result);
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return null;
+    }
+  }, [adapter]);
+  const connect = (0, import_react.useCallback)(async (config) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await adapter.connect(config);
+      return { ...result, success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return { success: false, error: message };
+    } finally {
+      setLoading(false);
+    }
+  }, [adapter]);
+  const disconnect = (0, import_react.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      await adapter.disconnect();
+      setStatus((prev) => prev ? { ...prev, connected: false, status: "disconnected" } : null);
+      return { success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return { success: false, error: message };
+    } finally {
+      setLoading(false);
+    }
+  }, [adapter]);
+  const reconnect = (0, import_react.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await adapter.reconnect();
+      return { ...result, success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return { success: false, error: message };
+    } finally {
+      setLoading(false);
+    }
+  }, [adapter]);
+  return { status, loading, error, fetchStatus, connect, disconnect, reconnect };
+}
+function useTerminalScreen(adapter, interval = 2e3, enabled = true) {
+  const [data, setData] = (0, import_react.useState)(null);
+  const [error, setError] = (0, import_react.useState)(null);
+  const intervalRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!enabled) {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+      return;
+    }
+    const poll = async () => {
+      try {
+        const screen = await adapter.getScreen();
+        if (screen) setData(screen);
+        setError(null);
+      } catch (err) {
+        setError(err);
+      }
+    };
+    poll();
+    intervalRef.current = setInterval(poll, interval);
+    return () => {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+    };
+  }, [adapter, interval, enabled]);
+  return { data, error };
+}
+function useTerminalInput(adapter) {
+  const [loading, setLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const sendText = (0, import_react.useCallback)(async (text) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await adapter.sendText(text);
+      return { ...result, success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return { success: false, error: message };
+    } finally {
+      setLoading(false);
+    }
+  }, [adapter]);
+  const sendKey = (0, import_react.useCallback)(async (key) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await adapter.sendKey(key);
+      return { ...result, success: true };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setError(message);
+      return { success: false, error: message };
+    } finally {
+      setLoading(false);
+    }
+  }, [adapter]);
+  return { loading, error, sendText, sendKey };
+}
+var useTN5250Connection = useTerminalConnection;
+var useTN5250Screen = useTerminalScreen;
+var useTN5250Terminal = useTerminalInput;
+
+// src/hooks/useTypingAnimation.ts
+var import_react2 = require("react");
+
+// src/utils/grid.ts
+function positionToRowCol(content, position) {
+  let row = 0;
+  let col = 0;
+  for (let i = 0; i < position && i < content.length; i++) {
+    if (content[i] === "\n") {
+      row++;
+      col = 0;
+    } else {
+      col++;
+    }
+  }
+  return { row, col };
+}
+function isFieldEntry(previousContent, content) {
+  if (!previousContent || !content) return false;
+  let diffCount = 0;
+  let diffStart = -1;
+  let diffEnd = 0;
+  const maxLen = Math.max(previousContent.length, content.length);
+  for (let i = 0; i < maxLen; i++) {
+    const oldChar = previousContent[i] || " ";
+    const newChar = content[i] || " ";
+    if (oldChar !== newChar) {
+      diffCount++;
+      if (diffStart === -1) diffStart = i;
+      diffEnd = i;
+    }
+  }
+  const diffSpan = diffEnd - diffStart + 1;
+  return diffCount > 2 && diffCount < 50 && diffSpan < 100;
+}
+
+// src/hooks/useTypingAnimation.ts
+function useTypingAnimation(content, enabled = true, typingBudgetMs = 100) {
+  const FRAME_DELAY = 16;
+  const previousContentRef = (0, import_react2.useRef)("");
+  const targetContentRef = (0, import_react2.useRef)("");
+  const contentQueueRef = (0, import_react2.useRef)([]);
+  const isAnimatingRef = (0, import_react2.useRef)(false);
+  const timeoutRef = (0, import_react2.useRef)(null);
+  const rafRef = (0, import_react2.useRef)(null);
+  const [animatedContent, setAnimatedContent] = (0, import_react2.useState)("");
+  const [isAnimating, setIsAnimating] = (0, import_react2.useState)(false);
+  const [animatedCursorPos, setAnimatedCursorPos] = (0, import_react2.useState)(null);
+  const cancelAnimation = () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    if (rafRef.current) {
+      cancelAnimationFrame(rafRef.current);
+      rafRef.current = null;
+    }
+  };
+  const showInstant = (0, import_react2.useCallback)((c) => {
+    cancelAnimation();
+    setAnimatedContent(c);
+    setAnimatedCursorPos(null);
+    setIsAnimating(false);
+    isAnimatingRef.current = false;
+    previousContentRef.current = c;
+    targetContentRef.current = "";
+  }, []);
+  const processNextRef = (0, import_react2.useRef)(null);
+  const startFieldAnimation = (0, import_react2.useCallback)((fromContent, toContent) => {
+    let diffStart = -1;
+    let diffEnd = 0;
+    const maxLen = Math.max(fromContent.length, toContent.length);
+    for (let i = 0; i < maxLen; i++) {
+      if ((fromContent[i] || " ") !== (toContent[i] || " ")) {
+        if (diffStart === -1) diffStart = i;
+        diffEnd = i;
+      }
+    }
+    if (diffStart === -1) {
+      showInstant(toContent);
+      return;
+    }
+    setIsAnimating(true);
+    isAnimatingRef.current = true;
+    targetContentRef.current = toContent;
+    const diffLength = diffEnd - diffStart + 1;
+    const oldRegion = fromContent.substring(diffStart, diffEnd + 1);
+    const isCorrection = oldRegion.replace(/[_\s\n]/g, "").length > 0;
+    const finishAnimation = () => {
+      setAnimatedContent(toContent);
+      setIsAnimating(false);
+      isAnimatingRef.current = false;
+      setAnimatedCursorPos(null);
+      previousContentRef.current = toContent;
+      targetContentRef.current = "";
+      timeoutRef.current = null;
+      rafRef.current = null;
+      if (processNextRef.current) processNextRef.current();
+    };
+    if (isCorrection) {
+      const CORRECTION_BUDGET = 400;
+      const removalBudget = Math.floor(CORRECTION_BUDGET * 0.4);
+      const typingBudget = CORRECTION_BUDGET - removalBudget;
+      const removalFrames = Math.max(2, Math.floor(removalBudget / FRAME_DELAY));
+      const typingFrames = Math.max(2, Math.floor(typingBudget / FRAME_DELAY));
+      const removalCPF = Math.max(1, Math.ceil(diffLength / removalFrames));
+      const typingCPF = Math.max(1, Math.ceil(diffLength / typingFrames));
+      let removePos = diffEnd + 1;
+      let typePos = diffStart;
+      const buildRemovalContent = (erasedFrom) => {
+        const before = fromContent.substring(0, diffStart);
+        const remaining = fromContent.substring(diffStart, erasedFrom);
+        const erased = " ".repeat(Math.max(0, diffEnd + 1 - erasedFrom));
+        const after = toContent.substring(diffEnd + 1);
+        return before + remaining + erased + after;
+      };
+      const buildTypingContent = (revealedUpTo) => {
+        const before = toContent.substring(0, diffStart);
+        const revealed = toContent.substring(diffStart, revealedUpTo);
+        const hidden = toContent.substring(revealedUpTo, diffEnd + 1).replace(/[^\n]/g, " ");
+        const after = toContent.substring(diffEnd + 1);
+        return before + revealed + hidden + after;
+      };
+      const animateTyping = () => {
+        typePos += typingCPF;
+        if (typePos >= diffEnd + 1) {
+          finishAnimation();
+        } else {
+          setAnimatedContent(buildTypingContent(typePos));
+          setAnimatedCursorPos(positionToRowCol(toContent, typePos));
+          timeoutRef.current = setTimeout(() => {
+            rafRef.current = requestAnimationFrame(animateTyping);
+          }, FRAME_DELAY);
+        }
+      };
+      const animateRemoval = () => {
+        removePos -= removalCPF;
+        if (removePos <= diffStart) {
+          setAnimatedContent(buildTypingContent(diffStart));
+          setAnimatedCursorPos(positionToRowCol(toContent, diffStart));
+          timeoutRef.current = setTimeout(() => {
+            rafRef.current = requestAnimationFrame(animateTyping);
+          }, FRAME_DELAY);
+        } else {
+          setAnimatedContent(buildRemovalContent(removePos));
+          setAnimatedCursorPos(positionToRowCol(fromContent, removePos));
+          timeoutRef.current = setTimeout(() => {
+            rafRef.current = requestAnimationFrame(animateRemoval);
+          }, FRAME_DELAY);
+        }
+      };
+      setAnimatedCursorPos(positionToRowCol(fromContent, diffEnd));
+      setAnimatedContent(buildRemovalContent(diffEnd + 1));
+      timeoutRef.current = setTimeout(() => {
+        rafRef.current = requestAnimationFrame(animateRemoval);
+      }, FRAME_DELAY);
+    } else {
+      let currentPos = diffStart;
+      const totalFrames = Math.max(1, Math.floor(typingBudgetMs / FRAME_DELAY));
+      const charsPerFrame = Math.max(1, Math.ceil(diffLength / totalFrames));
+      setAnimatedCursorPos(positionToRowCol(toContent, diffStart));
+      const buildDisplayContent = (revealedUpTo) => {
+        const before = toContent.substring(0, diffStart);
+        const revealed = toContent.substring(diffStart, revealedUpTo);
+        const hidden = toContent.substring(revealedUpTo, diffEnd + 1).replace(/[^\n]/g, " ");
+        const after = toContent.substring(diffEnd + 1);
+        return before + revealed + hidden + after;
+      };
+      const animate = () => {
+        currentPos += charsPerFrame;
+        if (currentPos >= diffEnd + 1) {
+          finishAnimation();
+        } else {
+          setAnimatedContent(buildDisplayContent(currentPos));
+          setAnimatedCursorPos(positionToRowCol(toContent, currentPos));
+          timeoutRef.current = setTimeout(() => {
+            rafRef.current = requestAnimationFrame(animate);
+          }, FRAME_DELAY);
+        }
+      };
+      setAnimatedContent(buildDisplayContent(diffStart));
+      timeoutRef.current = setTimeout(() => {
+        rafRef.current = requestAnimationFrame(animate);
+      }, FRAME_DELAY);
+    }
+  }, [showInstant, typingBudgetMs]);
+  processNextRef.current = () => {
+    const queue = contentQueueRef.current;
+    if (queue.length === 0) return;
+    while (queue.length > 2) queue.shift();
+    const next = queue.shift();
+    const base = previousContentRef.current;
+    if (isFieldEntry(base, next)) {
+      startFieldAnimation(base, next);
+    } else {
+      showInstant(next);
+      if (queue.length > 0 && processNextRef.current) processNextRef.current();
+    }
+  };
+  const shouldAnimate = enabled && content && isFieldEntry(previousContentRef.current, content);
+  if (!shouldAnimate && !isAnimatingRef.current && content !== previousContentRef.current) {
+    previousContentRef.current = content || "";
+  }
+  (0, import_react2.useEffect)(() => {
+    if (!enabled || !content) {
+      cancelAnimation();
+      contentQueueRef.current = [];
+      showInstant(content || "");
+      previousContentRef.current = content || "";
+      return;
+    }
+    const currentTarget = targetContentRef.current || previousContentRef.current;
+    if (content === currentTarget) return;
+    if (isAnimatingRef.current) {
+      if (!isFieldEntry(currentTarget, content)) {
+        contentQueueRef.current = [];
+        showInstant(content);
+      } else {
+        contentQueueRef.current.push(content);
+        if (contentQueueRef.current.length > 3) {
+          contentQueueRef.current = contentQueueRef.current.slice(-2);
+        }
+      }
+      return;
+    }
+    const prev = previousContentRef.current;
+    if (!isFieldEntry(prev, content)) {
+      showInstant(content);
+      return;
+    }
+    startFieldAnimation(prev, content);
+    return cancelAnimation;
+  }, [content, enabled, showInstant, startFieldAnimation]);
+  const animationActive = isAnimatingRef.current;
+  const displayedContent = (0, import_react2.useMemo)(() => {
+    if (!enabled || !content) return content || "";
+    if (animationActive) return animatedContent;
+    return content;
+  }, [enabled, content, animationActive, animatedContent]);
+  const effectiveCursorPos = animationActive ? animatedCursorPos : null;
+  return { displayedContent, isAnimating, animatedCursorPos: effectiveCursorPos };
+}
+
+// src/protocols/tn5250.ts
+var tn5250Profile = {
+  protocol: "tn5250",
+  displayName: "IBM TN5250",
+  defaultRows: 24,
+  defaultCols: 80,
+  headerLabel: "TN5250 TERMINAL",
+  bootText: "TN5250",
+  colors: {
+    getRowColorClass(rowIndex, rowContent, totalRows) {
+      if (rowIndex === 0 && rowContent.trim().length > 0) return "gs-row-title";
+      if (rowIndex >= totalRows - 2) return "gs-row-fkey";
+      if (/F\d{1,2}=/.test(rowContent)) return "gs-row-fkey";
+      if (/Select one of the following/i.test(rowContent)) return "gs-row-subtitle";
+      return "gs-row-content";
+    },
+    parseHeaderRow(line) {
+      if (line.trim().length === 0) return null;
+      const trimmed = line.trimStart();
+      const leftMatch = trimmed.match(/^(\S+)/);
+      if (leftMatch) {
+        const leftId = leftMatch[1];
+        const leftEnd = line.indexOf(leftId) + leftId.length;
+        const rightMatch = line.trimEnd().match(/(\S+)$/);
+        if (rightMatch && rightMatch[1] !== leftId) {
+          const rightStart = line.lastIndexOf(rightMatch[1]);
+          return [
+            { text: line.substring(0, leftEnd), colorClass: "gs-row-fkey" },
+            { text: line.substring(leftEnd, rightStart), colorClass: "gs-row-title" },
+            { text: line.substring(rightStart), colorClass: "gs-row-content" }
+          ];
+        }
+      }
+      return [{ text: line, colorClass: "gs-row-title" }];
+    }
+  }
+};
+
+// src/protocols/tn3270.ts
+var tn3270Profile = {
+  protocol: "tn3270",
+  displayName: "IBM TN3270",
+  defaultRows: 24,
+  defaultCols: 80,
+  headerLabel: "TN3270 TERMINAL",
+  bootText: "TN3270",
+  colors: {
+    getRowColorClass(rowIndex, rowContent, totalRows) {
+      if (rowIndex === 0 && rowContent.trim().length > 0) return "gs-row-title";
+      if (rowIndex >= totalRows - 2) return "gs-row-fkey";
+      if (/PF\d{1,2}[=/]/.test(rowContent) || /F\d{1,2}=/.test(rowContent)) return "gs-row-fkey";
+      if (/COMMAND\s*===>/i.test(rowContent) || /===>/.test(rowContent)) return "gs-row-subtitle";
+      if (/OPTION\s*===>/i.test(rowContent)) return "gs-row-subtitle";
+      return "gs-row-content";
+    },
+    parseHeaderRow(line) {
+      if (line.trim().length === 0) return null;
+      const trimmed = line.trimStart();
+      const leftMatch = trimmed.match(/^(\S+)/);
+      if (leftMatch) {
+        const leftId = leftMatch[1];
+        const leftEnd = line.indexOf(leftId) + leftId.length;
+        const rightMatch = line.trimEnd().match(/(\S+)$/);
+        if (rightMatch && rightMatch[1] !== leftId) {
+          const rightStart = line.lastIndexOf(rightMatch[1]);
+          return [
+            { text: line.substring(0, leftEnd), colorClass: "gs-row-fkey" },
+            { text: line.substring(leftEnd, rightStart), colorClass: "gs-row-title" },
+            { text: line.substring(rightStart), colorClass: "gs-row-content" }
+          ];
+        }
+      }
+      return [{ text: line, colorClass: "gs-row-title" }];
+    }
+  }
+};
+
+// src/protocols/vt.ts
+var vtProfile = {
+  protocol: "vt",
+  displayName: "VT Terminal",
+  defaultRows: 24,
+  defaultCols: 80,
+  headerLabel: "VT TERMINAL",
+  bootText: "VT220",
+  colors: {
+    getRowColorClass(_rowIndex, _rowContent, _totalRows) {
+      return "gs-row-content";
+    },
+    parseHeaderRow(_line) {
+      return null;
+    }
+  }
+};
+
+// src/protocols/hp6530.ts
+var hp6530Profile = {
+  protocol: "hp6530",
+  displayName: "HP 6530",
+  defaultRows: 24,
+  defaultCols: 80,
+  headerLabel: "6530 TERMINAL",
+  bootText: "HP6530",
+  colors: {
+    getRowColorClass(rowIndex, rowContent, totalRows) {
+      if (rowIndex === 0 && rowContent.trim().length > 0) return "gs-row-title";
+      if (rowIndex >= totalRows - 1) return "gs-row-fkey";
+      if (/F\d{1,2}[=\-]/.test(rowContent) || /SF\d{1,2}/.test(rowContent)) return "gs-row-fkey";
+      return "gs-row-content";
+    },
+    parseHeaderRow(line) {
+      if (line.trim().length === 0) return null;
+      return [{ text: line, colorClass: "gs-row-title" }];
+    }
+  }
+};
+
+// src/protocols/registry.ts
+var profiles = {
+  tn5250: tn5250Profile,
+  tn3270: tn3270Profile,
+  vt: vtProfile,
+  hp6530: hp6530Profile
+};
+function getProtocolProfile(protocol) {
+  return profiles[protocol || "tn5250"];
+}
+
+// src/components/TerminalBootLoader.tsx
+var import_react3 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function TerminalBootLoader({
+  brandText = "TERMINAL",
+  charSpeed = 80,
+  logo,
+  height = 504
+}) {
+  const [charCount, setCharCount] = (0, import_react3.useState)(0);
+  const intervalRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useEffect)(() => {
+    intervalRef.current = setInterval(() => {
+      setCharCount((prev) => {
+        if (prev >= brandText.length) {
+          if (intervalRef.current) clearInterval(intervalRef.current);
+          return prev;
+        }
+        return prev + 1;
+      });
+    }, charSpeed);
+    return () => {
+      if (intervalRef.current) clearInterval(intervalRef.current);
+    };
+  }, [brandText, charSpeed]);
+  const displayed = brandText.substring(0, charCount);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      className: "gs-boot-loader",
+      style: {
+        height: typeof height === "number" ? `${height}px` : height,
+        backgroundColor: "var(--gs-bg, #000)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontFamily: "var(--gs-font)",
+        fontSize: "13px"
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: "16px" }, children: [
+        logo,
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+          "h1",
+          {
+            style: {
+              fontFamily: "var(--gs-font)",
+              fontSize: "1.5rem",
+              letterSpacing: "0.1em",
+              color: "var(--gs-green, #10b981)",
+              textShadow: "0 0 12px rgba(16, 185, 129, 0.4)",
+              margin: 0
+            },
+            children: [
+              displayed,
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "span",
+                {
+                  className: "tn5250-cursor",
+                  style: {
+                    display: "inline-block",
+                    width: "0.6ch",
+                    height: "1.2em",
+                    verticalAlign: "middle",
+                    marginLeft: "2px"
+                  }
+                }
+              )
+            ]
+          }
+        )
+      ] })
+    }
+  );
+}
+
+// src/components/GreenScreenTerminal.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var TerminalIcon = ({ size = 14 }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("polyline", { points: "4 17 10 11 4 5" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", y1: "19", x2: "20", y2: "19" })
+] });
+var WifiIcon = ({ size = 12, className, style: s }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className, style: s, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M5 12.55a11 11 0 0 1 14.08 0" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M1.42 9a16 16 0 0 1 21.16 0" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M8.53 16.11a6 6 0 0 1 6.95 0" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", y1: "20", x2: "12.01", y2: "20" })
+] });
+var WifiOffIcon = ({ size = 12, className, style: s }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className, style: s, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "1", y1: "1", x2: "23", y2: "23" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M10.71 5.05A16 16 0 0 1 22.56 9" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M8.53 16.11a6 6 0 0 1 6.95 0" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", y1: "20", x2: "12.01", y2: "20" })
+] });
+var AlertTriangleIcon = ({ size = 14 }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
+] });
+var RefreshIcon = ({ size = 12, className }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", className, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("polyline", { points: "23 4 23 10 17 10" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("polyline", { points: "1 20 1 14 7 14" }),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15" })
+] });
+var KeyIcon = ({ size = 12, style: s }) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: s, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4" }) });
+var MinimizeIcon = () => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("svg", { width: 14, height: 14, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { d: "M4 14h6v6M3 21l7-7M20 10h-6V4M21 3l-7 7" }) });
+var PROTOCOL_OPTIONS = [
+  { value: "tn5250", label: "TN5250 (IBM i)" },
+  { value: "tn3270", label: "TN3270 (Mainframe)" },
+  { value: "vt", label: "VT220" },
+  { value: "hp6530", label: "HP 6530 (NonStop)" }
+];
+function InlineSignIn({ defaultProtocol, loading, error, onConnect }) {
+  const [host, setHost] = (0, import_react4.useState)("");
+  const [port, setPort] = (0, import_react4.useState)("");
+  const [selectedProtocol, setSelectedProtocol] = (0, import_react4.useState)(defaultProtocol);
+  const [username, setUsername] = (0, import_react4.useState)("");
+  const [password, setPassword] = (0, import_react4.useState)("");
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    onConnect({
+      host,
+      port: port ? parseInt(port, 10) : void 0,
+      protocol: selectedProtocol,
+      username,
+      password
+    });
+  };
+  const inputStyle = {
+    width: "100%",
+    padding: "6px 8px",
+    backgroundColor: "rgba(16, 185, 129, 0.05)",
+    border: "1px solid var(--gs-card-border, #1e293b)",
+    color: "var(--gs-green, #10b981)",
+    fontFamily: "var(--gs-font)",
+    fontSize: "13px",
+    outline: "none",
+    boxSizing: "border-box"
+  };
+  const labelStyle = {
+    display: "block",
+    marginBottom: "4px",
+    fontSize: "10px",
+    letterSpacing: "0.1em",
+    textTransform: "uppercase",
+    color: "var(--gs-muted, #94a3b8)",
+    fontFamily: "var(--gs-font)"
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("form", { onSubmit: handleSubmit, className: "gs-signin", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { textAlign: "center", marginBottom: "16px" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TerminalIcon, { size: 28 }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { fontSize: "11px", letterSpacing: "0.15em", textTransform: "uppercase", color: "var(--gs-muted)", marginTop: "8px" }, children: "Connect to Host" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-signin-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { flex: 1 }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { style: labelStyle, children: "Host" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("input", { style: inputStyle, value: host, onChange: (e) => setHost(e.target.value), placeholder: "192.168.1.100", required: true, autoFocus: true })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { width: "72px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { style: labelStyle, children: "Port" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("input", { style: inputStyle, value: port, onChange: (e) => setPort(e.target.value), placeholder: "23", type: "number", min: "1", max: "65535" })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { style: labelStyle, children: "Protocol" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("select", { style: { ...inputStyle, appearance: "none" }, value: selectedProtocol, onChange: (e) => setSelectedProtocol(e.target.value), children: PROTOCOL_OPTIONS.map((o) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("option", { value: o.value, children: o.label }, o.value)) })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { style: labelStyle, children: "Username" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("input", { style: inputStyle, value: username, onChange: (e) => setUsername(e.target.value), required: true, autoComplete: "username" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { style: labelStyle, children: "Password" }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("input", { style: inputStyle, type: "password", value: password, onChange: (e) => setPassword(e.target.value), required: true, autoComplete: "current-password" })
+    ] }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { color: "#FF6B00", fontSize: "11px", fontFamily: "var(--gs-font)", display: "flex", alignItems: "center", gap: "6px" }, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AlertTriangleIcon, { size: 12 }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: error })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "submit", disabled: loading || !host || !username || !password, className: "gs-signin-btn", children: loading ? "Connecting..." : "Connect" })
+  ] });
+}
+function GreenScreenTerminal({
+  adapter,
+  protocol,
+  protocolProfile: customProfile,
+  screenData: externalScreenData,
+  connectionStatus: externalStatus,
+  readOnly = false,
+  pollInterval = 2e3,
+  autoReconnect: autoReconnectEnabled = true,
+  maxReconnectAttempts: maxAttempts = 5,
+  embedded = false,
+  showHeader = true,
+  typingAnimation = true,
+  typingBudgetMs = 60,
+  inlineSignIn = false,
+  defaultProtocol: signInDefaultProtocol,
+  onSignIn,
+  bootLoader,
+  headerRight,
+  overlay,
+  onNotification,
+  onScreenChange,
+  onMinimize,
+  className,
+  style
+}) {
+  const profile = customProfile ?? getProtocolProfile(protocol);
+  const shouldPoll = pollInterval > 0 && !externalScreenData;
+  const { data: polledScreenData, error: screenError } = useTerminalScreen(adapter, pollInterval, shouldPoll);
+  const { sendText: _sendText, sendKey: _sendKey } = useTerminalInput(adapter);
+  const { connect, reconnect, loading: reconnecting, error: connectError } = useTerminalConnection(adapter);
+  const rawScreenData = externalScreenData ?? polledScreenData;
+  const connStatus = externalStatus ?? (rawScreenData ? { connected: true, status: "authenticated" } : { connected: false, status: "disconnected" });
+  const { displayedContent, animatedCursorPos } = useTypingAnimation(
+    rawScreenData?.content,
+    typingAnimation,
+    typingBudgetMs
+  );
+  const screenData = (0, import_react4.useMemo)(() => {
+    if (!rawScreenData) return null;
+    return { ...rawScreenData, content: displayedContent };
+  }, [rawScreenData, displayedContent]);
+  const prevScreenSigRef = (0, import_react4.useRef)(void 0);
+  (0, import_react4.useEffect)(() => {
+    if (screenData && onScreenChange && screenData.screen_signature !== prevScreenSigRef.current) {
+      prevScreenSigRef.current = screenData.screen_signature;
+      onScreenChange(screenData);
+    }
+  }, [screenData, onScreenChange]);
+  const sendText = (0, import_react4.useCallback)(async (text) => _sendText(text), [_sendText]);
+  const sendKey = (0, import_react4.useCallback)(async (key) => _sendKey(key), [_sendKey]);
+  const [inputText, setInputText] = (0, import_react4.useState)("");
+  const [isFocused, setIsFocused] = (0, import_react4.useState)(false);
+  const terminalRef = (0, import_react4.useRef)(null);
+  const inputRef = (0, import_react4.useRef)(null);
+  const [syncedCursor, setSyncedCursor] = (0, import_react4.useState)(null);
+  const prevRawContentRef = (0, import_react4.useRef)("");
+  (0, import_react4.useEffect)(() => {
+    const newContent = rawScreenData?.content || "";
+    if (prevRawContentRef.current && newContent && newContent !== prevRawContentRef.current) {
+      setSyncedCursor(null);
+      setInputText("");
+    }
+    prevRawContentRef.current = newContent;
+  }, [rawScreenData?.content]);
+  const [autoReconnectAttempt, setAutoReconnectAttempt] = (0, import_react4.useState)(0);
+  const [isAutoReconnecting, setIsAutoReconnecting] = (0, import_react4.useState)(false);
+  const reconnectTimeoutRef = (0, import_react4.useRef)(null);
+  const wasConnectedRef = (0, import_react4.useRef)(false);
+  const isConnectedRef = (0, import_react4.useRef)(false);
+  (0, import_react4.useEffect)(() => {
+    isConnectedRef.current = connStatus?.connected ?? false;
+  }, [connStatus?.connected]);
+  (0, import_react4.useEffect)(() => {
+    if (!autoReconnectEnabled) return;
+    const isConnected = connStatus?.connected;
+    if (isConnected) {
+      wasConnectedRef.current = true;
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+        reconnectTimeoutRef.current = null;
+      }
+      setAutoReconnectAttempt(0);
+      setIsAutoReconnecting(false);
+    } else if (wasConnectedRef.current && !isConnected && !isAutoReconnecting && !reconnecting) {
+      if (autoReconnectAttempt < maxAttempts) {
+        setIsAutoReconnecting(true);
+        const delay = Math.pow(2, autoReconnectAttempt) * 1e3;
+        reconnectTimeoutRef.current = setTimeout(async () => {
+          if (isConnectedRef.current) {
+            setIsAutoReconnecting(false);
+            return;
+          }
+          onNotification?.(`Auto-reconnect attempt ${autoReconnectAttempt + 1}/${maxAttempts}`, "info");
+          try {
+            const result = await reconnect();
+            if (!result?.success) setAutoReconnectAttempt((prev) => prev + 1);
+          } catch {
+            onNotification?.("Auto-reconnect failed", "error");
+            setAutoReconnectAttempt((prev) => prev + 1);
+          }
+          setIsAutoReconnecting(false);
+        }, delay);
+      }
+    }
+    return () => {
+      if (reconnectTimeoutRef.current) clearTimeout(reconnectTimeoutRef.current);
+    };
+  }, [connStatus?.connected, autoReconnectAttempt, isAutoReconnecting, reconnecting, reconnect, autoReconnectEnabled, maxAttempts, onNotification]);
+  const handleSignIn = (0, import_react4.useCallback)(async (config) => {
+    onSignIn?.(config);
+    await connect(config);
+  }, [connect, onSignIn]);
+  const [showBootLoader, setShowBootLoader] = (0, import_react4.useState)(bootLoader !== false);
+  const [bootFadingOut, setBootFadingOut] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
+    if (screenData?.content && showBootLoader) {
+      setBootFadingOut(true);
+      setShowBootLoader(false);
+      const timer = setTimeout(() => setBootFadingOut(false), 400);
+      return () => clearTimeout(timer);
+    }
+  }, [screenData?.content, showBootLoader]);
+  (0, import_react4.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (terminalRef.current && !terminalRef.current.contains(event.target)) setIsFocused(false);
+    };
+    if (isFocused) document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [isFocused]);
+  (0, import_react4.useEffect)(() => {
+    if (readOnly && isFocused) {
+      setIsFocused(false);
+      inputRef.current?.blur();
+    }
+  }, [readOnly, isFocused]);
+  const handleTerminalClick = (0, import_react4.useCallback)(() => {
+    if (readOnly) return;
+    setIsFocused(true);
+    inputRef.current?.focus();
+  }, [readOnly]);
+  const getCurrentField = (0, import_react4.useCallback)(() => {
+    const fields = screenData?.fields || [];
+    const cursorRow = syncedCursor?.row ?? screenData?.cursor_row ?? 0;
+    const cursorCol = syncedCursor?.col ?? screenData?.cursor_col ?? 0;
+    for (const field of fields) {
+      if (field.is_input && field.row === cursorRow && cursorCol >= field.col && cursorCol < field.col + field.length) return field;
+    }
+    return null;
+  }, [screenData, syncedCursor]);
+  const canTypeMore = (0, import_react4.useCallback)((additionalChars = 1) => {
+    const currentField = getCurrentField();
+    if (!currentField) return true;
+    const cursorCol = (syncedCursor?.col ?? screenData?.cursor_col ?? 0) + inputText.length;
+    return cursorCol + additionalChars <= currentField.col + currentField.length;
+  }, [getCurrentField, syncedCursor, screenData, inputText]);
+  const handleKeyDown = async (e) => {
+    if (readOnly) {
+      e.preventDefault();
+      return;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      setIsFocused(false);
+      inputRef.current?.blur();
+      return;
+    }
+    if (e.key === "Backspace") {
+      e.preventDefault();
+      if (inputText.length > 0) {
+        setInputText((prev) => prev.slice(0, -1));
+      } else {
+        const keyResult = await sendKey("BACKSPACE");
+        if (keyResult.cursor_row !== void 0) setSyncedCursor({ row: keyResult.cursor_row, col: keyResult.cursor_col });
+      }
+      return;
+    }
+    const keyMap = {
+      Enter: "ENTER",
+      Tab: "TAB",
+      Delete: "DELETE",
+      ArrowUp: "UP",
+      ArrowDown: "DOWN",
+      ArrowLeft: "LEFT",
+      ArrowRight: "RIGHT",
+      PageUp: "PAGEUP",
+      PageDown: "PAGEDOWN",
+      Home: "HOME",
+      End: "END",
+      Insert: "INSERT"
+    };
+    if (e.key.startsWith("F") && e.key.length <= 3) {
+      e.preventDefault();
+      const fKey = e.key.toUpperCase();
+      if (/^F([1-9]|1[0-9]|2[0-4])$/.test(fKey)) {
+        if (inputText) {
+          const r = await sendText(inputText);
+          setInputText("");
+          if (r.cursor_row !== void 0) setSyncedCursor({ row: r.cursor_row, col: r.cursor_col });
+        }
+        const kr = await sendKey(fKey);
+        if (kr.cursor_row !== void 0) setSyncedCursor({ row: kr.cursor_row, col: kr.cursor_col });
+        return;
+      }
+    }
+    if (keyMap[e.key]) {
+      e.preventDefault();
+      if (inputText) {
+        const r = await sendText(inputText);
+        setInputText("");
+        if (r.cursor_row !== void 0) setSyncedCursor({ row: r.cursor_row, col: r.cursor_col });
+      }
+      const kr = await sendKey(keyMap[e.key]);
+      if (kr.cursor_row !== void 0) setSyncedCursor({ row: kr.cursor_row, col: kr.cursor_col });
+    }
+  };
+  const handleInput = async (e) => {
+    if (readOnly) {
+      e.target.value = "";
+      return;
+    }
+    const newText = e.target.value;
+    if (newText.includes("\n")) {
+      const textToSend = newText.replace("\n", "");
+      if (textToSend) {
+        const r = await sendText(textToSend);
+        if (r.cursor_row !== void 0) setSyncedCursor({ row: r.cursor_row, col: r.cursor_col });
+      }
+      const kr = await sendKey("ENTER");
+      if (kr.cursor_row !== void 0) setSyncedCursor({ row: kr.cursor_row, col: kr.cursor_col });
+      setInputText("");
+      e.target.value = "";
+    } else {
+      const charsToAdd = newText.length - inputText.length;
+      if (charsToAdd > 0 && !canTypeMore(charsToAdd)) {
+        e.target.value = inputText;
+        return;
+      }
+      setInputText(newText);
+    }
+  };
+  const termCols = screenData?.cols || profile.defaultCols;
+  const getCursorPos = () => {
+    if (animatedCursorPos) return animatedCursorPos;
+    let cursorRow = syncedCursor?.row ?? screenData?.cursor_row ?? 0;
+    let cursorCol = (syncedCursor?.col ?? screenData?.cursor_col ?? 0) + inputText.length;
+    while (cursorCol >= termCols) {
+      cursorCol -= termCols;
+      cursorRow += 1;
+    }
+    return { row: cursorRow, col: cursorCol };
+  };
+  const renderTextWithUnderlines = (0, import_react4.useCallback)((text, keyPrefix) => {
+    const underscoreRegex = /_{2,}/g;
+    const segments = [];
+    let lastIndex = 0;
+    let match;
+    let segmentIndex = 0;
+    while ((match = underscoreRegex.exec(text)) !== null) {
+      if (match.index > lastIndex) segments.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: text.substring(lastIndex, match.index) }, `${keyPrefix}-t-${segmentIndex}`));
+      const count = match[0].length;
+      segments.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: { borderBottom: "1px solid var(--gs-green, #10b981)", display: "inline-block", width: `${count}ch` }, children: " ".repeat(count) }, `${keyPrefix}-u-${segmentIndex}`));
+      lastIndex = match.index + match[0].length;
+      segmentIndex++;
+    }
+    if (lastIndex < text.length) segments.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: text.substring(lastIndex) }, `${keyPrefix}-e`));
+    return segments.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: segments }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: text });
+  }, []);
+  const renderRowWithFields = (0, import_react4.useCallback)((line, rowIndex, fields) => {
+    const inputFields = fields.filter((f) => f.row === rowIndex && f.is_input);
+    const highlightedFields = fields.filter((f) => f.row === rowIndex && f.is_protected && f.is_highlighted);
+    const reverseFields = fields.filter((f) => f.row === rowIndex && f.is_protected && f.is_reverse);
+    const allRowFields = [...inputFields, ...highlightedFields, ...reverseFields];
+    if (allRowFields.length === 0) return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: renderTextWithUnderlines(line, `r${rowIndex}`) });
+    const sorted = [...allRowFields].sort((a, b) => a.col - b.col);
+    const segs = [];
+    let lastEnd = 0;
+    const cols = screenData?.cols || profile.defaultCols;
+    sorted.forEach((field, idx) => {
+      const fs = field.col;
+      const fe = Math.min(field.col + field.length, cols);
+      if (fs > lastEnd) segs.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: renderTextWithUnderlines(line.substring(lastEnd, fs), `r${rowIndex}p${idx}`) }, `t${idx}`));
+      const fc = line.substring(fs, fe);
+      if (field.is_input) {
+        const w = field.length >= 30 ? Math.max(field.length, 40) : field.length;
+        segs.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-input-field", style: { borderBottom: "2px solid var(--gs-green, #10b981)", display: "inline-block", minWidth: `${w}ch` }, children: fc }, `f${idx}`));
+      } else if (field.is_reverse) {
+        segs.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: { color: "#ef4444", fontWeight: "bold" }, children: fc }, `v${idx}`));
+      } else {
+        segs.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: { color: "var(--gs-white, #FFFFFF)" }, children: fc }, `h${idx}`));
+      }
+      lastEnd = fe;
+    });
+    if (lastEnd < line.length) segs.push(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: renderTextWithUnderlines(line.substring(lastEnd), `r${rowIndex}e`) }, "te"));
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: segs });
+  }, [renderTextWithUnderlines, screenData?.cols, profile.defaultCols]);
+  const renderScreen = () => {
+    if (showBootLoader && !screenData?.content) {
+      if (bootLoader === false) return null;
+      if (bootLoader) return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: bootLoader });
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TerminalBootLoader, { brandText: profile.bootText });
+    }
+    if (bootFadingOut && screenData?.content) return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gs-fade-in", children: renderScreenContent() });
+    if (!screenData?.content) {
+      if (inlineSignIn && !connStatus?.connected) {
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { width: `${screenData?.cols || profile.defaultCols}ch`, height: `${(screenData?.rows || profile.defaultRows) * 21}px`, display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(InlineSignIn, { defaultProtocol: signInDefaultProtocol || protocol || "tn5250", loading: reconnecting, error: connectError, onConnect: handleSignIn }) });
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { width: `${screenData?.cols || profile.defaultCols}ch`, height: `${(screenData?.rows || profile.defaultRows) * 21}px`, display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { textAlign: "center" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: { color: "#808080", marginBottom: "12px" }, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TerminalIcon, { size: 40 }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { style: { fontFamily: "var(--gs-font)", fontSize: "12px", color: "#808080" }, children: connStatus?.connected ? "Waiting for screen data..." : "Not connected" })
+      ] }) });
+    }
+    return renderScreenContent();
+  };
+  const renderScreenContent = () => {
+    if (!screenData?.content) return null;
+    const termRows = screenData.rows || profile.defaultRows;
+    const cols = screenData.cols || profile.defaultCols;
+    const lines = screenData.content.split("\n");
+    const rows = [];
+    for (let i = 0; i < termRows; i++) rows.push((lines[i] || "").padEnd(cols, " "));
+    const fields = screenData.fields || [];
+    const ROW_HEIGHT = 21;
+    const cursor = getCursorPos();
+    const hasInputFields = fields.some((f) => f.is_input);
+    const hasCursor = screenData.cursor_row !== void 0 && screenData.cursor_col !== void 0 && (hasInputFields || screenData.cursor_row !== 0 || screenData.cursor_col !== 0);
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: { fontFamily: "var(--gs-font)", fontSize: "13px", position: "relative", width: `${cols}ch` }, children: [
+      rows.map((line, index) => {
+        let displayLine = line;
+        if (hasCursor && index === cursor.row && inputText && !animatedCursorPos) {
+          const baseCol = syncedCursor?.col ?? screenData.cursor_col ?? 0;
+          displayLine = (line.substring(0, baseCol) + inputText + line.substring(baseCol + inputText.length)).substring(0, cols).padEnd(cols, " ");
+        }
+        const headerSegments = index === 0 ? profile.colors.parseHeaderRow(displayLine) : null;
+        return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: headerSegments ? "" : profile.colors.getRowColorClass(index, displayLine, termRows), style: { height: `${ROW_HEIGHT}px`, lineHeight: `${ROW_HEIGHT}px`, whiteSpace: "pre", position: "relative" }, children: [
+          headerSegments ? headerSegments.map((seg, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: seg.colorClass, children: seg.text }, i)) : renderRowWithFields(displayLine, index, fields),
+          hasCursor && index === cursor.row && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-cursor", style: { position: "absolute", left: `${cursor.col}ch`, width: "1ch", height: `${ROW_HEIGHT}px`, top: 0, pointerEvents: "none" } })
+        ] }, index);
+      }),
+      screenData.cursor_row !== void 0 && screenData.cursor_col !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: { position: "absolute", bottom: 0, right: 0, fontFamily: "var(--gs-font)", fontSize: "10px", color: "var(--gs-green, #10b981)", pointerEvents: "none", opacity: 0.6 }, children: [
+        String(screenData.cursor_row + 1).padStart(2, "0"),
+        "/",
+        String(screenData.cursor_col + 1).padStart(3, "0")
+      ] })
+    ] });
+  };
+  const handleReconnect = async () => {
+    setAutoReconnectAttempt(0);
+    setIsAutoReconnecting(false);
+    if (reconnectTimeoutRef.current) {
+      clearTimeout(reconnectTimeoutRef.current);
+      reconnectTimeoutRef.current = null;
+    }
+    await reconnect();
+  };
+  const getStatusColor = (status) => {
+    switch (status) {
+      case "authenticated":
+        return "var(--gs-green, #10b981)";
+      case "connected":
+        return "#F59E0B";
+      case "connecting":
+        return "#64748b";
+      case "error":
+        return "#EF4444";
+      default:
+        return "#64748b";
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: `gs-terminal ${isFocused ? "gs-terminal-focused" : ""} ${className || ""}`, style, children: [
+    showHeader && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gs-header", children: embedded ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gs-header-left", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TerminalIcon, { size: 14 }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: "TERMINAL" }),
+        isFocused && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-badge-focused", children: "FOCUSED" }),
+        screenData?.timestamp && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-timestamp", children: new Date(screenData.timestamp).toLocaleTimeString() }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-hint", children: readOnly ? "Read-only" : isFocused ? "ESC to exit focus" : "Click to control" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-header-right", children: [
+        connStatus?.status && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(KeyIcon, { size: 12, style: { color: getStatusColor(connStatus.status) } }),
+        connStatus && (connStatus.connected ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WifiIcon, { size: 12, style: { color: "var(--gs-green, #10b981)" } }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WifiOffIcon, { size: 12, style: { color: "#FF6B00" } })),
+        onMinimize && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { onClick: (e) => {
+          e.stopPropagation();
+          onMinimize();
+        }, className: "gs-btn-icon", title: "Minimize terminal", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MinimizeIcon, {}) }),
+        headerRight
+      ] })
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gs-header-left", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TerminalIcon, { size: 14 }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: profile.headerLabel }),
+        isFocused && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-badge-focused", children: "FOCUSED" }),
+        screenData?.timestamp && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-timestamp", children: new Date(screenData.timestamp).toLocaleTimeString() }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-hint", children: readOnly ? "Read-only mode" : isFocused ? "ESC to exit focus" : "Click terminal to control" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-header-right", children: [
+        connStatus && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gs-status-group", children: connStatus.connected ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WifiIcon, { size: 12, style: { color: "var(--gs-green, #10b981)" } }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-host", children: connStatus.host })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WifiOffIcon, { size: 12, style: { color: "#FF6B00" } }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-disconnected-text", children: isAutoReconnecting || reconnecting ? `RECONNECTING${autoReconnectAttempt > 0 ? ` (${autoReconnectAttempt}/${maxAttempts})` : "..."}` : autoReconnectAttempt >= maxAttempts ? "DISCONNECTED (auto-retry exhausted)" : "DISCONNECTED" }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { onClick: handleReconnect, disabled: reconnecting || isAutoReconnecting, className: "gs-btn-icon", title: "Reconnect", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RefreshIcon, { size: 12, className: reconnecting || isAutoReconnecting ? "gs-spin" : "" }) })
+        ] }) }),
+        connStatus?.status && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-status-group", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(KeyIcon, { size: 12, style: { color: getStatusColor(connStatus.status) } }),
+          connStatus.username && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gs-host", children: connStatus.username })
+        ] }),
+        headerRight
+      ] })
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gs-body", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+      "div",
+      {
+        ref: terminalRef,
+        onClick: handleTerminalClick,
+        className: `gs-screen ${embedded ? "gs-screen-embedded" : ""}`,
+        style: !embedded ? { width: `calc(${screenData?.cols || profile.defaultCols}ch + 24px)`, fontSize: (screenData?.cols ?? profile.defaultCols) > 80 ? "11px" : "13px", fontFamily: "var(--gs-font)" } : void 0,
+        children: [
+          screenError != null && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-error-banner", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AlertTriangleIcon, { size: 14 }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: String(screenError) })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gs-screen-content", children: renderScreen() }),
+          overlay,
+          connStatus && !connStatus.connected && screenData && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gs-overlay", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WifiOffIcon, { size: 28 }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: isAutoReconnecting || reconnecting ? "Reconnecting..." : "Disconnected" })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "input",
+            {
+              ref: inputRef,
+              type: "text",
+              value: inputText,
+              onChange: handleInput,
+              onKeyDown: handleKeyDown,
+              style: { position: "absolute", opacity: 0, pointerEvents: "none" },
+              autoComplete: "off",
+              autoCorrect: "off",
+              autoCapitalize: "off",
+              spellCheck: false
+            }
+          )
+        ]
+      }
+    ) })
+  ] });
+}
+var TN5250Terminal = GreenScreenTerminal;
+
+// src/adapters/RestAdapter.ts
+var RestAdapter = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.staticHeaders = options.headers || {};
+    this.getHeaders = options.getHeaders;
+  }
+  async buildHeaders() {
+    const dynamic = this.getHeaders ? await this.getHeaders() : {};
+    return {
+      "Content-Type": "application/json",
+      ...this.staticHeaders,
+      ...dynamic
+    };
+  }
+  async request(method, path, body) {
+    const headers = await this.buildHeaders();
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const detail = await response.json().catch(() => ({}));
+      throw new Error(detail?.detail || `HTTP ${response.status}`);
+    }
+    return response.json();
+  }
+  async getScreen() {
+    try {
+      return await this.request("GET", "/screen");
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      if (message.includes("503") || message.includes("404")) {
+        return null;
+      }
+      throw e;
+    }
+  }
+  async getStatus() {
+    return this.request("GET", "/status");
+  }
+  async sendText(text) {
+    return this.request("POST", "/send-text", { text });
+  }
+  async sendKey(key) {
+    return this.request("POST", "/send-key", { key });
+  }
+  async connect(config) {
+    return this.request("POST", "/connect", config);
+  }
+  async disconnect() {
+    return this.request("POST", "/disconnect");
+  }
+  async reconnect() {
+    return this.request("POST", "/reconnect");
+  }
+};
+
+// src/utils/rendering.ts
+function getRowColorClass(rowIndex, rowContent) {
+  return getProtocolProfile("tn5250").colors.getRowColorClass(rowIndex, rowContent, 24);
+}
+function parseHeaderRow(line) {
+  return getProtocolProfile("tn5250").colors.parseHeaderRow(line);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GreenScreenTerminal,
+  RestAdapter,
+  TN5250Terminal,
+  TerminalBootLoader,
+  getProtocolProfile,
+  getRowColorClass,
+  hp6530Profile,
+  isFieldEntry,
+  parseHeaderRow,
+  positionToRowCol,
+  tn3270Profile,
+  tn5250Profile,
+  useTN5250Connection,
+  useTN5250Screen,
+  useTN5250Terminal,
+  useTerminalConnection,
+  useTerminalInput,
+  useTerminalScreen,
+  useTypingAnimation,
+  vtProfile
+});
+//# sourceMappingURL=index.js.map