@arcanewizards/sigil 0.1.0

package/dist/frontend/styling.d.ts

@@ -0,0 +1,32 @@
+import { CSSProperties } from 'react';
+import { z } from 'zod';
+
+declare const SIGIL_COLOR: z.ZodEnum<["purple", "blue", "teal", "red", "green", "yellow", "brown", "orange", "gray"]>;
+type SigilColor = z.infer<typeof SIGIL_COLOR>;
+type SigilUsageColor = SigilColor | 'unknown';
+type SigilUsageColorUsage = {
+    text: string;
+    foreground: string;
+    background: string;
+    border: string;
+    dragBorder: string;
+    selectedBackground: string;
+    selectedBorder: string;
+    selectedText: string;
+    dimmedBackground: string;
+    dimmedBorder: string;
+    gradientLight: string;
+    gradientDark: string;
+};
+declare const sigilColorUsage: (color: SigilUsageColor) => SigilUsageColorUsage;
+declare const cssSigilColorUsageVariables: (prefix: string, usage: SigilUsageColorUsage) => CSSProperties;
+declare const cssHintColorVariables: (color: SigilColor) => CSSProperties;
+/**
+ * Hook that will adjust the root hint color based on the given color.
+ */
+declare const useRootHintVariables: (color: SigilColor) => void;
+declare const cssVariables: (variables: Partial<Record<`--${string}`, string | number>>) => CSSProperties;
+declare function cnd<T extends string>(condition: unknown, truthyClassName: T): T | undefined;
+declare function cnd<T extends string, F extends string>(condition: unknown, truthyClassName: T, falseyClassName: F): T | F;
+
+export { SIGIL_COLOR, type SigilColor, type SigilUsageColor, type SigilUsageColorUsage, cnd, cssHintColorVariables, cssSigilColorUsageVariables, cssVariables, sigilColorUsage, useRootHintVariables };

package/dist/frontend/styling.js

@@ -0,0 +1,18 @@
+import {
+  SIGIL_COLOR,
+  cnd,
+  cssHintColorVariables,
+  cssSigilColorUsageVariables,
+  cssVariables,
+  sigilColorUsage,
+  useRootHintVariables
+} from "../chunk-H4U4Z4GM.js";
+export {
+  SIGIL_COLOR,
+  cnd,
+  cssHintColorVariables,
+  cssSigilColorUsageVariables,
+  cssVariables,
+  sigilColorUsage,
+  useRootHintVariables
+};

package/dist/frontend/toolbars.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunkA5LYYZERcjs = require('../chunk-A5LYYZER.cjs');
+
+
+
+
+
+
+
+
+exports.ToolbarDivider = _chunkA5LYYZERcjs.ToolbarDivider; exports.ToolbarGrow = _chunkA5LYYZERcjs.ToolbarGrow; exports.ToolbarRow = _chunkA5LYYZERcjs.ToolbarRow; exports.ToolbarRowTall = _chunkA5LYYZERcjs.ToolbarRowTall; exports.ToolbarSegment = _chunkA5LYYZERcjs.ToolbarSegment; exports.ToolbarSpacer = _chunkA5LYYZERcjs.ToolbarSpacer; exports.ToolbarWrapper = _chunkA5LYYZERcjs.ToolbarWrapper;

package/dist/frontend/toolbars.d.cts

@@ -0,0 +1,11 @@
+import * as react from 'react';
+
+declare const ToolbarWrapper: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarRow: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarRowTall: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarSegment: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarDivider: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarSpacer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarGrow: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+export { ToolbarDivider, ToolbarGrow, ToolbarRow, ToolbarRowTall, ToolbarSegment, ToolbarSpacer, ToolbarWrapper };

package/dist/frontend/toolbars.d.ts

@@ -0,0 +1,11 @@
+import * as react from 'react';
+
+declare const ToolbarWrapper: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarRow: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarRowTall: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarSegment: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarDivider: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarSpacer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+declare const ToolbarGrow: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+export { ToolbarDivider, ToolbarGrow, ToolbarRow, ToolbarRowTall, ToolbarSegment, ToolbarSpacer, ToolbarWrapper };

package/dist/frontend/toolbars.js

@@ -0,0 +1,18 @@
+import {
+  ToolbarDivider,
+  ToolbarGrow,
+  ToolbarRow,
+  ToolbarRowTall,
+  ToolbarSegment,
+  ToolbarSpacer,
+  ToolbarWrapper
+} from "../chunk-FHXT3DAL.js";
+export {
+  ToolbarDivider,
+  ToolbarGrow,
+  ToolbarRow,
+  ToolbarRowTall,
+  ToolbarSegment,
+  ToolbarSpacer,
+  ToolbarWrapper
+};

package/dist/frontend/tooltip.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkPEARNJ5Gcjs = require('../chunk-PEARNJ5G.cjs');
+
+
+
+
+exports.TooltipBoundary = _chunkPEARNJ5Gcjs.TooltipBoundary; exports.TooltipWrapper = _chunkPEARNJ5Gcjs.TooltipWrapper; exports.keyboardShortcutTooltip = _chunkPEARNJ5Gcjs.keyboardShortcutTooltip;

package/dist/frontend/tooltip.d.cts

@@ -0,0 +1,16 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { FC, ComponentPropsWithoutRef, ReactNode } from 'react';
+import { RegisteredBinding, KeyboardBinding } from './input.cjs';
+
+type TooltipBoundaryProps = ComponentPropsWithoutRef<'div'>;
+declare const TooltipBoundary: FC<TooltipBoundaryProps>;
+type TooltipProps = {
+    tooltip: string | ReactNode | null;
+    children: ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+};
+declare const TooltipWrapper: FC<TooltipProps>;
+declare const keyboardShortcutTooltip: (label: ReactNode, keyboardBinding?: RegisteredBinding, extraBindings?: KeyboardBinding[]) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+export { TooltipBoundary, type TooltipBoundaryProps, type TooltipProps, TooltipWrapper, keyboardShortcutTooltip };

package/dist/frontend/tooltip.d.ts

@@ -0,0 +1,16 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { FC, ComponentPropsWithoutRef, ReactNode } from 'react';
+import { RegisteredBinding, KeyboardBinding } from './input.js';
+
+type TooltipBoundaryProps = ComponentPropsWithoutRef<'div'>;
+declare const TooltipBoundary: FC<TooltipBoundaryProps>;
+type TooltipProps = {
+    tooltip: string | ReactNode | null;
+    children: ReactNode;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+};
+declare const TooltipWrapper: FC<TooltipProps>;
+declare const keyboardShortcutTooltip: (label: ReactNode, keyboardBinding?: RegisteredBinding, extraBindings?: KeyboardBinding[]) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+export { TooltipBoundary, type TooltipBoundaryProps, type TooltipProps, TooltipWrapper, keyboardShortcutTooltip };

package/dist/frontend/tooltip.js

@@ -0,0 +1,10 @@
+import {
+  TooltipBoundary,
+  TooltipWrapper,
+  keyboardShortcutTooltip
+} from "../chunk-BIY5HAXP.js";
+export {
+  TooltipBoundary,
+  TooltipWrapper,
+  keyboardShortcutTooltip
+};

package/dist/frontend.cjs

@@ -0,0 +1,359 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkA5LYYZERcjs = require('./chunk-A5LYYZER.cjs');
+
+
+
+
+var _chunkCAYKPJIXcjs = require('./chunk-CAYKPJIX.cjs');
+
+
+
+
+
+var _chunkVZ4A6RRTcjs = require('./chunk-VZ4A6RRT.cjs');
+
+
+var _chunkMXDDIFIOcjs = require('./chunk-MXDDIFIO.cjs');
+require('./chunk-PEARNJ5G.cjs');
+require('./chunk-RI33QVOD.cjs');
+
+
+var _chunk5DRI7C4Ucjs = require('./chunk-5DRI7C4U.cjs');
+
+// src/frontend/app-root.tsx
+var _toolkitfrontend = require('@arcanejs/toolkit-frontend');
+var _radixui = require('radix-ui');
+var _react = require('react');
+
+// src/frontend/browser-context.tsx
+
+
+// src/frontend/media-session.ts
+var NOOP_MEDIA_SESSION = {
+  setMetaData: () => {
+  },
+  setHandler: () => {
+  }
+};
+var createBrowserMediaSession = () => {
+  if (typeof navigator === "undefined" || !("mediaSession" in navigator) || !navigator.mediaSession) {
+    return NOOP_MEDIA_SESSION;
+  }
+  let handler = null;
+  const setMetaData = (data) => {
+    if (!data) {
+      navigator.mediaSession.metadata = null;
+      navigator.mediaSession.playbackState = "none";
+      return;
+    }
+    const { title, artist, durationMillis, state } = data;
+    navigator.mediaSession.metadata = new MediaMetadata({
+      title,
+      artist
+    });
+    if (state.state === "playing") {
+      navigator.mediaSession.playbackState = "playing";
+      navigator.mediaSession.setPositionState({
+        duration: durationMillis / 1e3,
+        position: Math.max(0, (Date.now() - state.effectiveStartTime) * state.speed) / 1e3,
+        playbackRate: state.speed
+      });
+      return;
+    }
+    navigator.mediaSession.playbackState = "paused";
+    navigator.mediaSession.setPositionState({
+      duration: durationMillis / 1e3,
+      position: state.currentTimeMillis / 1e3
+    });
+  };
+  const setHandler = (value) => {
+    handler = value;
+  };
+  navigator.mediaSession.setActionHandler("play", () => {
+    _optionalChain([handler, 'optionalCall', _ => _({ action: "play" })]);
+  });
+  navigator.mediaSession.setActionHandler("pause", () => {
+    _optionalChain([handler, 'optionalCall', _2 => _2({ action: "pause" })]);
+  });
+  const handleSeekAction = (action) => {
+    if (action.action === "seekto") {
+      _optionalChain([handler, 'optionalCall', _3 => _3({
+        action: "seekto",
+        seekTimeMillis: (_nullishCoalesce(action.seekTime, () => ( 0))) * 1e3
+      })]);
+      return;
+    }
+    if (action.action === "seekbackward" || action.action === "seekforward") {
+      _optionalChain([handler, 'optionalCall', _4 => _4({
+        action: action.action,
+        seekOffsetMillis: (_nullishCoalesce(action.seekOffset, () => ( 0))) * 1e3
+      })]);
+    }
+  };
+  navigator.mediaSession.setActionHandler("seekto", handleSeekAction);
+  navigator.mediaSession.setActionHandler("seekbackward", handleSeekAction);
+  navigator.mediaSession.setActionHandler("seekforward", handleSeekAction);
+  return {
+    setMetaData,
+    setHandler
+  };
+};
+
+// src/frontend/browser-context.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var createDefaultBrowserContext = (browser) => {
+  const defaults = {
+    openExternalLink: (url) => {
+      window.open(url, "_blank", "noopener,noreferrer");
+    },
+    openNewWidow: (url) => {
+      window.open(url, "_blank", "noopener,noreferrer");
+    },
+    selectDirectory: null,
+    openDevTools: null,
+    confirmClose: () => {
+    },
+    mediaSession: createBrowserMediaSession()
+  };
+  return {
+    ...defaults,
+    ...browser
+  };
+};
+var BrowserContext = _react.createContext.call(void 0, 
+  new Proxy({}, {
+    get: () => {
+      throw new Error("BrowserContext not provided.");
+    }
+  })
+);
+var BrowserContextProvider = ({
+  browser,
+  children
+}) => {
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, BrowserContext.Provider, { value: browser, children });
+};
+var useBrowserContext = () => _react.useContext.call(void 0, BrowserContext);
+
+// src/frontend/app-root.tsx
+
+var AppRoot = ({
+  info,
+  browser
+}) => {
+  const { child, lastLog } = info;
+  const { renderComponent, call } = _react.useContext.call(void 0, _toolkitfrontend.StageContext);
+  const [logs, setLogs] = _react.useState.call(void 0, { lastLog: -1, logs: [] });
+  const [debugMode, setDebugMode] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!debugMode || !call) return;
+    const lastLogId = _nullishCoalesce(_optionalChain([logs, 'access', _5 => _5.logs, 'access', _6 => _6[logs.logs.length - 1], 'optionalAccess', _7 => _7.index]), () => ( -1));
+    call({
+      namespace: "sigil",
+      type: "component-call",
+      componentKey: info.key,
+      action: "app-root-get-logs",
+      after: lastLogId
+    }).then(({ logs: newLogs }) => {
+      if (newLogs.length === 0) return;
+      setLogs({
+        lastLog,
+        logs: [...logs.logs, ...newLogs]
+      });
+    });
+  }, [call, debugMode, info.key, lastLog, logs]);
+  const debuggerContext = _react.useMemo.call(void 0, 
+    () => ({
+      logs: logs.logs,
+      setDebugMode
+    }),
+    [logs.logs]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkVZ4A6RRTcjs.SystemInformationContext.Provider, { value: info.system, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, BrowserContextProvider, { browser, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkVZ4A6RRTcjs.DebuggerContext.Provider, { value: debuggerContext, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _radixui.Tooltip.Provider, { children: child && renderComponent(child) }) }) }) });
+};
+
+// src/frontend/debugger.tsx
+
+var _util = require('@arcanejs/toolkit-frontend/util');
+
+var TIME_FORMATTER = new Intl.DateTimeFormat("en-US", {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  fractionalSecondDigits: 3
+});
+var unwrapErrorStack = (error) => {
+  let stack = `${error.message}
+${_nullishCoalesce(error.stack, () => ( ""))}`;
+  if (error.cause) {
+    stack += `
+Caused by: ${unwrapErrorStack(error.cause)}`;
+  }
+  return stack;
+};
+var Debugger = ({ title, className }) => {
+  const scrollRef = _react.useRef.call(void 0, null);
+  const shouldScrollToBottom = _react.useRef.call(void 0, true);
+  const { openDevTools } = useBrowserContext();
+  const { setDebugMode, logs } = _chunkVZ4A6RRTcjs.useDebuggerContext.call(void 0, );
+  const system = _chunkVZ4A6RRTcjs.useSystemInformation.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    setDebugMode(true);
+    return () => {
+      setDebugMode(false);
+    };
+  }, [setDebugMode]);
+  const handleScroll = () => {
+    if (!scrollRef.current) return;
+    const { scrollTop, scrollHeight, clientHeight } = scrollRef.current;
+    shouldScrollToBottom.current = scrollTop + clientHeight >= scrollHeight - 10;
+  };
+  const scrollToBottomIfRequired = _react.useCallback.call(void 0, () => {
+    if (shouldScrollToBottom.current && scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+    }
+  }, []);
+  _react.useEffect.call(void 0, scrollToBottomIfRequired, [logs, scrollToBottomIfRequired]);
+  _react.useEffect.call(void 0, () => {
+    window.addEventListener("resize", scrollToBottomIfRequired);
+    return () => {
+      window.removeEventListener("resize", scrollToBottomIfRequired);
+    };
+  }, [scrollToBottomIfRequired]);
+  const exportLogs = _react.useCallback.call(void 0, () => {
+    const logText = JSON.stringify({ system, logs }, null, 2);
+    const blob = new Blob([logText], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `sigil-logs-${(/* @__PURE__ */ new Date()).toISOString()}.json`;
+    link.click();
+    URL.revokeObjectURL(url);
+  }, [system, logs]);
+  const handleRequestScrollToBottom = _react.useCallback.call(void 0, () => {
+    shouldScrollToBottom.current = true;
+    scrollToBottomIfRequired();
+  }, [scrollToBottomIfRequired]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _util.cn.call(void 0, "flex flex-col", className), children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkA5LYYZERcjs.ToolbarWrapper, { children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _chunkA5LYYZERcjs.ToolbarRow, { children: [
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "grow px-1", children: title }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkA5LYYZERcjs.ToolbarDivider, {}),
+      openDevTools && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _chunkMXDDIFIOcjs.ControlButton,
+        {
+          onClick: openDevTools,
+          variant: "toolbar",
+          icon: "build",
+          children: "Open Dev Tools"
+        }
+      ),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _chunkMXDDIFIOcjs.ControlButton,
+        {
+          onClick: handleRequestScrollToBottom,
+          variant: "toolbar",
+          icon: "south",
+          children: "Scroll to Bottom"
+        }
+      ),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkMXDDIFIOcjs.ControlButton, { onClick: exportLogs, variant: "toolbar", icon: "publish", children: "Export Logs" })
+    ] }) }),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "pre",
+      {
+        className: "\n          m-0 overflow-x-auto border-b border-sigil-border bg-sigil-bg-dark p-2\n          scrollbar-sigil\n        ",
+        children: `OS: ${system.os}
+Version: ${system.version}
+App Path: ${system.appPath}
+CWD: ${system.cwd}
+Data Directory: ${system.dataDirectory}`
+      }
+    ),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        ref: scrollRef,
+        onScroll: handleScroll,
+        className: "flex-1 overflow-auto scrollbar-sigil",
+        children: logs.map((log) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "px-arcane whitespace-pre-wrap", children: [
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "p", { children: [
+            TIME_FORMATTER.format(log.timestamp),
+            " - ",
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "span",
+              {
+                className: _util.cn.call(void 0, 
+                  _chunk5DRI7C4Ucjs.cnd.call(void 0, log.level === "error", "text-sigil-usage-red-foreground"),
+                  _chunk5DRI7C4Ucjs.cnd.call(void 0, 
+                    log.level === "warn",
+                    "text-sigil-usage-yellow-foreground"
+                  ),
+                  _chunk5DRI7C4Ucjs.cnd.call(void 0, log.level === "info", "text-sigil-usage-blue-foreground")
+                ),
+                children: log.level
+              }
+            ),
+            " - ",
+            log.message
+          ] }),
+          log.stack && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "pre", { className: "m-0 ml-2", children: unwrapErrorStack(log.stack) })
+        ] }, log.index))
+      }
+    )
+  ] });
+};
+
+// src/frontend/index.tsx
+var _frontend = require('@arcanejs/toolkit/frontend');
+
+
+var createSigilFrontendRenderer = (browser) => ({
+  namespace: _chunkCAYKPJIXcjs.SIGIL_NAMESPACE,
+  render: (info) => {
+    if (!_chunkCAYKPJIXcjs.isSigilComponent.call(void 0, info)) {
+      throw new Error(`Cannot render component ${info.namespace}`);
+    }
+    switch (info.component) {
+      case "app-root":
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AppRoot, { browser, info });
+    }
+  }
+});
+var defaultLoadingState = () => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { style: { width: "100%", textAlign: "center", padding: "2rem" }, children: "Loading..." });
+var startSigilFrontend = ({
+  browser,
+  appRenderers,
+  loadingState = defaultLoadingState
+}) => {
+  const resolvedBrowser = createDefaultBrowserContext(browser);
+  _frontend.startArcaneFrontend.call(void 0, {
+    renderers: [
+      _toolkitfrontend.CORE_FRONTEND_COMPONENT_RENDERER,
+      createSigilFrontendRenderer(resolvedBrowser),
+      ...appRenderers
+    ],
+    loadingState
+  });
+  return resolvedBrowser;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BrowserContext = BrowserContext; exports.BrowserContextProvider = BrowserContextProvider; exports.Debugger = Debugger; exports.DebuggerContext = _chunkVZ4A6RRTcjs.DebuggerContext; exports.SIGIL_NAMESPACE = _chunkCAYKPJIXcjs.SIGIL_NAMESPACE; exports.SigilAppRoot = AppRoot; exports.SystemInformationContext = _chunkVZ4A6RRTcjs.SystemInformationContext; exports.createBrowserMediaSession = createBrowserMediaSession; exports.createDefaultBrowserContext = createDefaultBrowserContext; exports.createSigilFrontendRenderer = createSigilFrontendRenderer; exports.isSigilComponent = _chunkCAYKPJIXcjs.isSigilComponent; exports.isSigilComponentCall = _chunkCAYKPJIXcjs.isSigilComponentCall; exports.startSigilFrontend = startSigilFrontend; exports.useBrowserContext = useBrowserContext; exports.useDebuggerContext = _chunkVZ4A6RRTcjs.useDebuggerContext; exports.useSystemInformation = _chunkVZ4A6RRTcjs.useSystemInformation;

package/dist/frontend.d.cts

@@ -0,0 +1,90 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { S as SigilAppRootComponent } from './proto-B-WcMUOE.cjs';
+export { A as AppRootGetLogs, a as AppRootGetLogsArgs, b as AppRootGetLogsReturn, c as SIGIL_NAMESPACE, d as SigilComponent, e as SigilComponentCalls, i as isSigilComponent, f as isSigilComponentCall } from './proto-B-WcMUOE.cjs';
+import * as react from 'react';
+import { PropsWithChildren, FC, ReactNode } from 'react';
+import { FrontendComponentRenderer } from '@arcanejs/toolkit-frontend/types';
+export { DebuggerContext, SystemInformationContext, useDebuggerContext, useSystemInformation } from './frontend/context.cjs';
+export { A as AppRootLogEntry, a as AppRootLogEntryStackFrame, S as SystemInformation } from './types-X8O95zmC.cjs';
+import '@arcanejs/protocol';
+import '@arcanejs/diff';
+
+type MediaSessionAction = {
+    action: 'play' | 'pause' | 'playpause';
+} | {
+    action: 'seekto';
+    seekTimeMillis: number;
+} | {
+    action: 'seekbackward' | 'seekforward';
+    seekOffsetMillis?: number;
+};
+type MediaSessionHandler = (action: MediaSessionAction) => void;
+type MediaPlayState = {
+    state: 'playing';
+    effectiveStartTime: number;
+    speed: number;
+} | {
+    state: 'stopped';
+    speed: number;
+    currentTimeMillis: number;
+};
+type MediaMetadata = {
+    title?: string;
+    artist?: string;
+    durationMillis: number;
+    state: MediaPlayState;
+};
+type MediaSessionControl = {
+    setMetaData: (metadata: MediaMetadata | null) => void;
+    setHandler: (handler: MediaSessionHandler | null) => void;
+};
+type NewWindowOptions = {
+    /**
+     * If true, try and find an existing window with the same URL,
+     * and just bring it into focus instead of opening a new one.
+     */
+    canUseExisting?: boolean;
+    /**
+     * If supported by the the electron environment,
+     * specify a string mode identifier to configure the window behavior.
+     */
+    mode?: string;
+};
+type BaseBrowserContext = {
+    openExternalLink: (url: string) => void;
+    openNewWidow: (url: string, options?: NewWindowOptions) => void;
+    selectDirectory: (() => Promise<string | null>) | null;
+    openDevTools: (() => Promise<null>) | null;
+    confirmClose: (message: string) => void;
+    mediaSession: MediaSessionControl;
+};
+declare const createDefaultBrowserContext: <TBrowserContext extends BaseBrowserContext = BaseBrowserContext>(browser?: Partial<TBrowserContext> | null) => TBrowserContext;
+declare const BrowserContext: react.Context<BaseBrowserContext>;
+declare const BrowserContextProvider: <TBrowserContext extends BaseBrowserContext>({ browser, children, }: PropsWithChildren<{
+    browser: TBrowserContext;
+}>) => react_jsx_runtime.JSX.Element;
+declare const useBrowserContext: <TBrowserContext extends BaseBrowserContext = BaseBrowserContext>() => TBrowserContext;
+
+type Props<TBrowserContext extends BaseBrowserContext> = {
+    info: SigilAppRootComponent;
+    browser: TBrowserContext;
+};
+declare const AppRoot: <TBrowserContext extends BaseBrowserContext>({ info, browser, }: Props<TBrowserContext>) => react_jsx_runtime.JSX.Element;
+
+type DebuggerProps = {
+    title: ReactNode;
+    className?: string;
+};
+declare const Debugger: FC<DebuggerProps>;
+
+declare const createSigilFrontendRenderer: <TBrowserContext extends BaseBrowserContext>(browser: TBrowserContext) => FrontendComponentRenderer;
+type StartSigilFrontendOptions<TBrowserContext extends BaseBrowserContext> = {
+    browser?: Partial<TBrowserContext> | null;
+    appRenderers: FrontendComponentRenderer[];
+    loadingState?: () => ReactNode;
+};
+declare const startSigilFrontend: <TBrowserContext extends BaseBrowserContext>({ browser, appRenderers, loadingState, }: StartSigilFrontendOptions<TBrowserContext>) => TBrowserContext;
+
+declare const createBrowserMediaSession: () => MediaSessionControl;
+
+export { type BaseBrowserContext, BrowserContext, BrowserContextProvider, Debugger, type MediaMetadata, type MediaPlayState, type MediaSessionAction, type MediaSessionControl, type MediaSessionHandler, type NewWindowOptions, AppRoot as SigilAppRoot, SigilAppRootComponent, type StartSigilFrontendOptions, createBrowserMediaSession, createDefaultBrowserContext, createSigilFrontendRenderer, startSigilFrontend, useBrowserContext };