@mdxui/terminal 2.0.0

package/dist/index.js

@@ -0,0 +1,786 @@
+import {
+  App,
+  AppHeader,
+  Badge,
+  Box,
+  Breadcrumb,
+  Button,
+  COMPONENT_TYPES,
+  Card,
+  Dashboard,
+  Dialog,
+  FAQ,
+  Features,
+  Footer,
+  Header,
+  Hero,
+  Input,
+  LandingPage,
+  List,
+  Page,
+  Panel,
+  Pricing,
+  Select,
+  Settings,
+  Shell,
+  Sidebar,
+  SidebarItem,
+  SidebarLayout,
+  Site,
+  Spinner,
+  Table,
+  Text,
+  bgColorMap,
+  colorMap,
+  extractChildren,
+  getBgColorCode,
+  getColorCode,
+  isBadgeProps,
+  isBoxProps,
+  isBreadcrumbProps,
+  isButtonProps,
+  isCardProps,
+  isDialogProps,
+  isInputProps,
+  isListProps,
+  isPanelProps,
+  isPropsObject,
+  isSelectProps,
+  isSidebarItemProps,
+  isSidebarProps,
+  isSpinnerProps,
+  isTableProps,
+  isTerminalComponentType,
+  isTextProps,
+  renderBadge,
+  renderBox,
+  renderBreadcrumb,
+  renderButton,
+  renderCard,
+  renderComponent,
+  renderDialog,
+  renderElement,
+  renderInput,
+  renderList,
+  renderPanel,
+  renderSelect,
+  renderSidebar,
+  renderSidebarItem,
+  renderSpinner,
+  renderTable,
+  spinnerFrames
+} from "./chunk-B43KP7XJ.js";
+import {
+  APIKeySchema,
+  APIKeysCollection,
+  DBProvider,
+  TeamSchema,
+  TeamsCollection,
+  UsageCollection,
+  UsageSchema,
+  UserRoleSchema,
+  UserSchema,
+  UsersCollection,
+  WebhookSchema,
+  WebhooksCollection,
+  createCollection,
+  createDB,
+  createDOSync,
+  useDBContext,
+  useMutation,
+  useQuery,
+  useReactiveCard,
+  useReactiveData,
+  useReactiveList,
+  useReactiveMetrics,
+  useReactiveTable
+} from "./chunk-JQ5H3WXL.js";
+import {
+  ARROW_BINDINGS,
+  COMMON_BINDINGS,
+  EMACS_BINDINGS,
+  FocusContext,
+  FocusProvider,
+  KEY,
+  VIM_BINDINGS,
+  __resetFocusIdCounter,
+  attachKeyboardManager,
+  createFocusId,
+  createKeyboardManager,
+  createOpenTUIKeyHandler,
+  isFocusId,
+  keyToBindingString,
+  matchKey,
+  normalizeOpenTUIKey,
+  normalizeReadlineKey,
+  useFocus,
+  useFocusManager,
+  useKeyboard,
+  useNavigableGrid,
+  useNavigableList
+} from "./chunk-GBQ6UD6I.js";
+import {
+  ansiToCSS,
+  ansiToHTML,
+  parseAnsiToSpans,
+  renderText,
+  spanToInlineStyle
+} from "./chunk-F6A5VWUC.js";
+import {
+  TAILWIND_COLORS,
+  adaptColor,
+  applyThemeStyles,
+  bg,
+  bold,
+  boxChars,
+  colors,
+  composeThemes,
+  createTerminalTheme,
+  createTheme,
+  createThemeVariant,
+  cssVarToAnsi,
+  darkTheme,
+  defaultTheme,
+  degradeColor,
+  detectColorScheme,
+  detectColorSupport,
+  dim,
+  drawBox,
+  extendTheme,
+  fg,
+  getThemeColor,
+  highContrastTheme,
+  italic,
+  lightTheme,
+  strikethrough,
+  stripAnsi,
+  style,
+  styled,
+  tailwindToAnsi,
+  tailwindToTerminal,
+  themePresets,
+  themeTokens,
+  underline,
+  visibleLength
+} from "./chunk-KWF6WVJE.js";
+import {
+  ANSI,
+  Ansi256CodeSchema,
+  AnsiEscapeSchema,
+  ColorSupportSchema,
+  CreateTerminalThemeOptionsSchema,
+  CreateThemeInputSchema,
+  HexColorSchema,
+  LegacyTerminalThemeSchema,
+  LegacyTerminalThemeWithExtrasSchema,
+  RgbColorSchema,
+  RgbComponentSchema,
+  RgbToAnsiOptionsSchema,
+  TerminalThemeColorsSchema,
+  ThemeModeSchema,
+  ansi256,
+  ansi256Bg,
+  hex,
+  hexBg,
+  hexToAnsi,
+  hexToRgb,
+  rgb,
+  rgbBg,
+  rgbToAnsi
+} from "./chunk-MVW4Q5OP.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/index.ts
+import React2, { createContext, useContext, useState, useEffect } from "react";
+
+// src/core/compiler.ts
+import React from "react";
+var UNKNOWN_COMPONENT_TYPE = "Unknown";
+function resolveTypeName(type) {
+  if (typeof type === "string") {
+    return type;
+  }
+  return type.name || UNKNOWN_COMPONENT_TYPE;
+}
+function isFilterableChild(value) {
+  return value === null || value === void 0 || typeof value === "boolean";
+}
+function compileJSX(element) {
+  const { type, props, key } = element;
+  const typeName = resolveTypeName(type);
+  const { children: rawChildren, ...restProps } = props || {};
+  const hasChildrenArg = rawChildren !== void 0;
+  const processedChildren = processChildren(rawChildren);
+  const result = {
+    type: typeName,
+    props: restProps || {}
+  };
+  if (processedChildren.length > 0 || hasChildrenArg) {
+    result.children = processedChildren;
+  }
+  if (key !== null && key !== void 0) {
+    result.key = String(key);
+  }
+  return result;
+}
+function processChildren(children) {
+  if (children === null || children === void 0) {
+    return [];
+  }
+  if (Array.isArray(children)) {
+    return children.flatMap((child) => processChild(child));
+  }
+  return processChild(children);
+}
+function processChild(child) {
+  if (isFilterableChild(child)) {
+    return [];
+  }
+  if (typeof child === "string") {
+    return [child];
+  }
+  if (typeof child === "number") {
+    return [String(child)];
+  }
+  if (React.isValidElement(child)) {
+    const element = child;
+    if (element.type === React.Fragment) {
+      return processChildren(element.props?.children);
+    }
+    return [compileJSX(element)];
+  }
+  if (Array.isArray(child)) {
+    return child.flatMap((c) => processChild(c));
+  }
+  return [];
+}
+function compileJSXDeep(element) {
+  const root = createUINodeShell(element);
+  const rawChildren = element.props?.children;
+  if (rawChildren === void 0) {
+    return root;
+  }
+  root.children = [];
+  const workStack = [];
+  populateChildrenWork(rawChildren, root.children, workStack);
+  while (workStack.length > 0) {
+    const work = workStack.pop();
+    const node = createUINodeShell(work.element);
+    work.targetArray[work.targetIndex] = node;
+    const nodeChildren = work.element.props?.children;
+    if (nodeChildren !== void 0) {
+      node.children = [];
+      populateChildrenWork(nodeChildren, node.children, workStack);
+    }
+  }
+  return root;
+}
+function createUINodeShell(element) {
+  const { type, props, key } = element;
+  const typeName = resolveTypeName(type);
+  const { children: _rawChildren, ...restProps } = props || {};
+  const result = {
+    type: typeName,
+    props: restProps || {}
+  };
+  if (key !== null && key !== void 0) {
+    result.key = String(key);
+  }
+  return result;
+}
+function populateChildrenWork(children, targetArray, workStack) {
+  if (children === null || children === void 0) {
+    return;
+  }
+  const childList = Array.isArray(children) ? children : [children];
+  let insertIndex = targetArray.length;
+  for (const child of childList) {
+    if (isFilterableChild(child)) {
+      continue;
+    }
+    if (typeof child === "string") {
+      targetArray.push(child);
+      insertIndex++;
+      continue;
+    }
+    if (typeof child === "number") {
+      targetArray.push(String(child));
+      insertIndex++;
+      continue;
+    }
+    if (React.isValidElement(child)) {
+      const elem = child;
+      if (elem.type === React.Fragment) {
+        const fragChildren = elem.props?.children;
+        if (fragChildren !== null && fragChildren !== void 0) {
+          populateChildrenWork(fragChildren, targetArray, workStack);
+          insertIndex = targetArray.length;
+        }
+        continue;
+      }
+      targetArray.push({});
+      workStack.push({
+        element: elem,
+        targetArray,
+        targetIndex: insertIndex
+      });
+      insertIndex++;
+      continue;
+    }
+    if (Array.isArray(child)) {
+      populateChildrenWork(child, targetArray, workStack);
+      insertIndex = targetArray.length;
+      continue;
+    }
+  }
+}
+
+// src/core/types.ts
+import { z } from "zod";
+var RenderTierSchema = z.enum([
+  "text",
+  "markdown",
+  "ascii",
+  "unicode",
+  "ansi",
+  "interactive"
+]);
+var ThemeTokensSchema = z.object({
+  primary: z.string(),
+  secondary: z.string(),
+  muted: z.string(),
+  foreground: z.string(),
+  background: z.string(),
+  border: z.string(),
+  success: z.string(),
+  warning: z.string(),
+  error: z.string(),
+  info: z.string()
+});
+var UINodeSchema = z.lazy(
+  () => z.object({
+    type: z.string(),
+    props: z.record(z.string(), z.unknown()).optional(),
+    children: z.union([z.array(UINodeSchema), z.string()]).optional(),
+    text: z.string().optional(),
+    data: z.unknown().optional(),
+    key: z.string().optional()
+  })
+);
+var RenderContextSchema = z.object({
+  tier: RenderTierSchema,
+  width: z.number().nonnegative(),
+  height: z.number().nonnegative(),
+  depth: z.number().nonnegative(),
+  theme: ThemeTokensSchema,
+  interactive: z.boolean()
+});
+
+// src/core/parser.ts
+var ParseError = class _ParseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ParseError";
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+function parseUINode(input) {
+  let parsed;
+  if (typeof input === "string") {
+    if (input.trim() === "") {
+      throw new ParseError("Invalid JSON: empty string");
+    }
+    try {
+      parsed = JSON.parse(input);
+    } catch (error) {
+      throw new ParseError(
+        `Invalid JSON: ${error instanceof Error ? error.message : "parse error"}`
+      );
+    }
+  } else {
+    parsed = input;
+  }
+  if (parsed === null) {
+    throw new ParseError("Invalid UINode: expected object, got null");
+  }
+  if (Array.isArray(parsed)) {
+    throw new ParseError("Invalid UINode: expected object, got array");
+  }
+  if (typeof parsed !== "object") {
+    throw new ParseError(`Invalid UINode: expected object, got ${typeof parsed}`);
+  }
+  const result = UINodeSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues;
+    const errorMessages = issues.map((issue) => {
+      const path = issue.path.length > 0 ? ` at path "${issue.path.join(".")}"` : "";
+      return `${issue.message}${path}`;
+    });
+    const hasTypeError = issues.some(
+      (issue) => issue.path.includes("type") || issue.path.length === 0 && issue.code === "invalid_type"
+    );
+    const hasMissingType = issues.some(
+      (issue) => issue.code === "invalid_type" && issue.path.length === 1 && issue.path[0] === "type"
+    );
+    if (hasMissingType || !("type" in parsed)) {
+      if (!("type" in parsed)) {
+        throw new ParseError('Invalid UINode: missing required field "type"');
+      }
+    }
+    throw new ParseError(`Invalid UINode: ${errorMessages.join("; ")}`);
+  }
+  return result.data;
+}
+function parseUINodeFromJSON(json) {
+  return parseUINode(json);
+}
+
+// src/index.ts
+async function createCliRenderer(config) {
+  const { createCliRenderer: opentuiCreateCliRenderer } = await import("@opentui/core");
+  return opentuiCreateCliRenderer(config);
+}
+function createRoot(renderer) {
+  let rootInstance = null;
+  let initPromise = null;
+  return {
+    render: async (element) => {
+      if (!initPromise) {
+        initPromise = import("@opentui/react").then(({ createRoot: opentuiCreateRoot }) => {
+          rootInstance = opentuiCreateRoot(renderer);
+          return rootInstance;
+        });
+      }
+      const root = await initPromise;
+      root.render(element);
+    },
+    unmount: () => {
+      if (rootInstance) {
+        rootInstance.unmount();
+        rootInstance = null;
+      }
+      initPromise = null;
+    }
+  };
+}
+async function CLI(options) {
+  const colorSupport = options?.colorSupport ?? detectColorSupport();
+  const { createCliRenderer: opentuiCreateCliRenderer } = await import("@opentui/core");
+  const { createRoot: opentuiCreateRoot } = await import("@opentui/react");
+  const opentuiRenderer = await opentuiCreateCliRenderer({
+    stdin: options?.stdin,
+    stdout: options?.stdout,
+    exitOnCtrlC: options?.exitOnCtrlC,
+    targetFps: options?.targetFps,
+    useAlternateScreen: options?.useAlternateScreen,
+    useMouse: options?.useMouse,
+    backgroundColor: options?.backgroundColor
+  });
+  const root = opentuiCreateRoot(opentuiRenderer);
+  const renderer = {
+    get width() {
+      return opentuiRenderer.width;
+    },
+    get height() {
+      return opentuiRenderer.height;
+    },
+    start: () => opentuiRenderer.start(),
+    stop: () => opentuiRenderer.stop(),
+    destroy: () => opentuiRenderer.destroy(),
+    requestRender: () => opentuiRenderer.requestRender()
+  };
+  return {
+    get width() {
+      return opentuiRenderer.width;
+    },
+    get height() {
+      return opentuiRenderer.height;
+    },
+    render: (element) => {
+      root.render(element);
+    },
+    clear: () => {
+      root.render(null);
+    },
+    destroy: () => {
+      root.unmount();
+      opentuiRenderer.destroy();
+    },
+    requestRender: () => {
+      opentuiRenderer.requestRender();
+    },
+    renderer,
+    root
+  };
+}
+function useTerminalSize() {
+  const getSize = () => {
+    if (typeof process !== "undefined" && process.stdout?.columns && process.stdout?.rows) {
+      return {
+        width: process.stdout.columns,
+        height: process.stdout.rows
+      };
+    }
+    return { width: 80, height: 24 };
+  };
+  const [size, setSize] = useState(getSize);
+  useEffect(() => {
+    if (typeof process === "undefined" || !process.stdout?.on) {
+      return;
+    }
+    const handleResize = () => {
+      setSize(getSize());
+    };
+    process.stdout.on("resize", handleResize);
+    const currentSize = getSize();
+    if (currentSize.width !== size.width || currentSize.height !== size.height) {
+      setSize(currentSize);
+    }
+    return () => {
+      process.stdout.off("resize", handleResize);
+    };
+  }, []);
+  return size;
+}
+function useTerminal() {
+  const { width, height } = useTerminalSize();
+  const detected = detectColorSupport();
+  const colorSupport = detected === "16" ? "basic" : detected;
+  const isRaw = typeof process !== "undefined" && process.stdin?.isRaw === true;
+  return {
+    width,
+    height,
+    colorSupport,
+    isRaw
+  };
+}
+var ThemeContext = createContext(null);
+function useTheme() {
+  const context = useContext(ThemeContext);
+  if (!context) {
+    return {
+      theme: "dark",
+      setTheme: () => {
+      },
+      colors: {}
+    };
+  }
+  return context;
+}
+function TerminalProvider(props) {
+  return React2.createElement("terminal-provider", props);
+}
+function ThemeProvider(props) {
+  const value = {
+    theme: props.theme || "dark",
+    setTheme: () => {
+    },
+    colors: {}
+  };
+  return React2.createElement(
+    ThemeContext.Provider,
+    { value },
+    props.children
+  );
+}
+function TerminalApp(props) {
+  return React2.createElement("terminal-app", props);
+}
+export {
+  ANSI,
+  APIKeySchema,
+  APIKeysCollection,
+  ARROW_BINDINGS,
+  Ansi256CodeSchema,
+  AnsiEscapeSchema,
+  App,
+  AppHeader,
+  Badge,
+  Box,
+  Breadcrumb,
+  Button,
+  CLI,
+  COMMON_BINDINGS,
+  COMPONENT_TYPES,
+  Card,
+  ColorSupportSchema,
+  CreateTerminalThemeOptionsSchema,
+  CreateThemeInputSchema,
+  DBProvider,
+  Dashboard,
+  Dialog,
+  EMACS_BINDINGS,
+  FAQ,
+  Features,
+  FocusContext,
+  FocusProvider,
+  Footer,
+  Header,
+  Hero,
+  HexColorSchema,
+  Input,
+  KEY,
+  LandingPage,
+  LegacyTerminalThemeSchema,
+  LegacyTerminalThemeWithExtrasSchema,
+  List,
+  Page,
+  Panel,
+  ParseError,
+  Pricing,
+  RenderContextSchema,
+  RenderTierSchema,
+  RgbColorSchema,
+  RgbComponentSchema,
+  RgbToAnsiOptionsSchema,
+  Select,
+  Settings,
+  Shell,
+  Sidebar,
+  SidebarItem,
+  SidebarLayout,
+  Site,
+  Spinner,
+  TAILWIND_COLORS,
+  Table,
+  TeamSchema,
+  TeamsCollection,
+  TerminalApp,
+  TerminalProvider,
+  TerminalThemeColorsSchema,
+  Text,
+  ThemeModeSchema,
+  ThemeProvider,
+  ThemeTokensSchema,
+  UINodeSchema,
+  UsageCollection,
+  UsageSchema,
+  UserRoleSchema,
+  UserSchema,
+  UsersCollection,
+  VIM_BINDINGS,
+  WebhookSchema,
+  WebhooksCollection,
+  __resetFocusIdCounter,
+  adaptColor,
+  ansi256,
+  ansi256Bg,
+  ansiToCSS,
+  ansiToHTML,
+  applyThemeStyles,
+  attachKeyboardManager,
+  bg,
+  bgColorMap,
+  bold,
+  boxChars,
+  colorMap,
+  colors,
+  compileJSX,
+  compileJSXDeep,
+  composeThemes,
+  createCliRenderer,
+  createCollection,
+  createDB,
+  createDOSync,
+  createFocusId,
+  createKeyboardManager,
+  createOpenTUIKeyHandler,
+  createRoot,
+  createTerminalTheme,
+  createTheme,
+  createThemeVariant,
+  cssVarToAnsi,
+  darkTheme,
+  defaultTheme,
+  degradeColor,
+  detectColorScheme,
+  detectColorSupport,
+  dim,
+  drawBox,
+  extendTheme,
+  extractChildren,
+  fg,
+  getBgColorCode,
+  getColorCode,
+  getThemeColor,
+  hex,
+  hexBg,
+  hexToAnsi,
+  hexToRgb,
+  highContrastTheme,
+  isBadgeProps,
+  isBoxProps,
+  isBreadcrumbProps,
+  isButtonProps,
+  isCardProps,
+  isDialogProps,
+  isFocusId,
+  isInputProps,
+  isListProps,
+  isPanelProps,
+  isPropsObject,
+  isSelectProps,
+  isSidebarItemProps,
+  isSidebarProps,
+  isSpinnerProps,
+  isTableProps,
+  isTerminalComponentType,
+  isTextProps,
+  italic,
+  keyToBindingString,
+  lightTheme,
+  matchKey,
+  normalizeOpenTUIKey,
+  normalizeReadlineKey,
+  parseAnsiToSpans,
+  parseUINode,
+  parseUINodeFromJSON,
+  renderBadge,
+  renderBox,
+  renderBreadcrumb,
+  renderButton,
+  renderCard,
+  renderComponent,
+  renderDialog,
+  renderElement,
+  renderInput,
+  renderList,
+  renderPanel,
+  renderSelect,
+  renderSidebar,
+  renderSidebarItem,
+  renderSpinner,
+  renderTable,
+  renderText,
+  rgb,
+  rgbBg,
+  rgbToAnsi,
+  spanToInlineStyle,
+  spinnerFrames,
+  strikethrough,
+  stripAnsi,
+  style,
+  styled,
+  tailwindToAnsi,
+  tailwindToTerminal,
+  themePresets,
+  themeTokens,
+  underline,
+  useDBContext,
+  useFocus,
+  useFocusManager,
+  useKeyboard,
+  useMutation,
+  useNavigableGrid,
+  useNavigableList,
+  useQuery,
+  useReactiveCard,
+  useReactiveData,
+  useReactiveList,
+  useReactiveMetrics,
+  useReactiveTable,
+  useTerminal,
+  useTerminalSize,
+  useTheme,
+  visibleLength
+};