@arcanewizards/sigil 0.1.0

package/dist/index.cjs

@@ -0,0 +1,492 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _class;
+
+
+
+var _chunkCAYKPJIXcjs = require('./chunk-CAYKPJIX.cjs');
+
+// src/app-shell.tsx
+var _react = require('react');
+
+// src/backend/app-root.ts
+
+
+
+var _base = require('@arcanejs/toolkit/components/base');
+var _reacttoolkit = require('@arcanejs/react-toolkit');
+var DEFAULT_PROPS = {
+  lastLog: -1,
+  system: {
+    version: "unknown",
+    appPath: "unknown",
+    cwd: "unknown",
+    os: "unknown",
+    dataDirectory: "unknown"
+  }
+};
+var AppRoot = (_class = class extends _base.BaseParent {
+  __init() {this.events = new (0, _base.EventEmitter)()}
+  constructor(props) {
+    super(DEFAULT_PROPS, props, {
+      onPropsUpdated: (oldProps) => this.events.processPropChanges(
+        {
+          onGetLogs: "getLogs"
+        },
+        oldProps,
+        this.props
+      )
+    });_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);;
+    this.triggerInitialPropsUpdate();
+  }
+  __init2() {this.addListener = this.events.addListener}
+  __init3() {this.removeListener = this.events.removeListener}
+  __init4() {this.validateChildren = (children) => {
+    if (children.length > 1) {
+      throw new Error("Sigil AppRoot can only have one child");
+    }
+  }}
+  getProtoInfo(idMap, context) {
+    return {
+      namespace: _chunkCAYKPJIXcjs.SIGIL_NAMESPACE,
+      component: "app-root",
+      key: idMap.getId(this),
+      child: _nullishCoalesce(this.getChildren().slice(0, 1).map((child) => child.getProtoInfo(idMap, context))[0], () => ( null)),
+      lastLog: this.props.lastLog,
+      system: this.props.system
+    };
+  }
+  __init5() {this.handleCall = async (call) => {
+    if (_chunkCAYKPJIXcjs.isSigilComponentCall.call(void 0, call, "app-root-get-logs")) {
+      return this.events.call("getLogs", { after: call.after });
+    }
+    throw new Error(`Unhandled call action: ${call.action}`);
+  }}
+}, _class);
+var SIGIL_COMPONENTS = _reacttoolkit.prepareComponents.call(void 0, _chunkCAYKPJIXcjs.SIGIL_NAMESPACE, {
+  AppRoot
+});
+
+// src/context.tsx
+
+var AppInformationContext = _react.createContext.call(void 0, {
+  version: "",
+  title: ""
+});
+var ShutdownContext = _react.createContext.call(void 0, 
+  new Proxy({}, {
+    get() {
+      throw new Error(
+        "ShutdownContext is not available outside of the Sigil application environment"
+      );
+    }
+  })
+);
+var useShutdownHandler = (handler) => {
+  const { addShutdownListener, removeShutdownListener } = _react.useContext.call(void 0, ShutdownContext);
+  _react.useEffect.call(void 0, () => {
+    addShutdownListener(handler);
+    return () => {
+      removeShutdownListener(handler);
+    };
+  }, [addShutdownListener, removeShutdownListener, handler]);
+};
+var LoggerContext = _react.createContext.call(void 0, {
+  get logger() {
+    throw new Error("Logger not initialized");
+  }
+});
+var useLogger = () => {
+  return _react.useContext.call(void 0, LoggerContext).logger;
+};
+
+// src/runtime.tsx
+var _data = require('@arcanejs/react-toolkit/data');
+
+var _toolkit = require('@arcanejs/toolkit');
+var _events = require('events');
+var MAX_LOG_ENTRIES = 1e3;
+var getStackFramesFromError = (error) => {
+  if (typeof error === "string") {
+    return { message: error, stack: null, cause: null };
+  }
+  if (!(error instanceof Error)) {
+    return { message: String(error), stack: null, cause: null };
+  }
+  const frame = {
+    message: error.message,
+    stack: _nullishCoalesce(error.stack, () => ( null)),
+    cause: error.cause ? getStackFramesFromError(error.cause) : null
+  };
+  if (error instanceof _data.ArcaneDataFileError) {
+    frame.filePath = error.path;
+    frame.operation = error.operation;
+    frame.contents = error.contents;
+  }
+  return frame;
+};
+var createSystemInformation = ({
+  dataDirectory,
+  version
+}) => {
+  return {
+    appPath: process.execPath,
+    cwd: process.cwd(),
+    os: process.platform,
+    version,
+    dataDirectory
+  };
+};
+var runSigilApp = ({
+  logger: upstreamLogger,
+  title,
+  version,
+  appProps,
+  toolkitOptions,
+  createApp,
+  componentNamespaces = [_reacttoolkit.CoreComponents, SIGIL_COMPONENTS]
+}) => {
+  let logs = [];
+  const logEventEmitter = new (0, _events.EventEmitter)();
+  const addLogEntry = (entry) => {
+    const index = (_nullishCoalesce(_optionalChain([logs, 'access', _ => _[logs.length - 1], 'optionalAccess', _2 => _2.index]), () => ( -1))) + 1;
+    const trimEntries = Math.max(0, logs.length - MAX_LOG_ENTRIES + 1);
+    logs = [...logs.slice(trimEntries), { index, ...entry }];
+    logEventEmitter.emit("logsUpdated", { logs });
+  };
+  const logError = (level, rootMsg) => {
+    upstreamLogger[level](rootMsg);
+    let error = rootMsg instanceof Error ? rootMsg : null;
+    let message = typeof rootMsg === "string" ? rootMsg : rootMsg.message;
+    while (error) {
+      if (error !== rootMsg) {
+        message += `: ${error.message}`;
+      }
+      error = error.cause instanceof Error ? error.cause : null;
+    }
+    addLogEntry({
+      level,
+      message,
+      timestamp: Date.now(),
+      stack: getStackFramesFromError(rootMsg)
+    });
+  };
+  const logMessage = (level, message) => {
+    upstreamLogger[level](message);
+    addLogEntry({
+      level,
+      message,
+      timestamp: Date.now()
+    });
+  };
+  const logger = {
+    debug: (message) => logMessage("debug", message),
+    info: (message) => logMessage("info", message),
+    warn: (message) => logError("warn", message),
+    error: (message) => logError("error", message)
+  };
+  const toolkit = new (0, _toolkit.Toolkit)({
+    log: {
+      ...logger,
+      debug: upstreamLogger.debug.bind(upstreamLogger)
+    },
+    title,
+    ...toolkitOptions
+  });
+  toolkit.start({
+    mode: "manual",
+    setup: () => {
+      logger.info(`${title} ready to start listening`);
+    }
+  });
+  let api = null;
+  const apiListeners = /* @__PURE__ */ new Set();
+  const setAppApi = (value) => {
+    api = value;
+    for (const listener of apiListeners) {
+      listener(value);
+    }
+  };
+  let windowUrl = null;
+  const windowUrlListeners = /* @__PURE__ */ new Set();
+  const setWindowUrl = (value) => {
+    windowUrl = value;
+    for (const listener of windowUrlListeners) {
+      listener(value);
+    }
+  };
+  const shutdownListeners = /* @__PURE__ */ new Set();
+  const shutdownContext = {
+    addShutdownListener: (listener) => {
+      shutdownListeners.add(listener);
+    },
+    removeShutdownListener: (listener) => {
+      shutdownListeners.delete(listener);
+    }
+  };
+  const shutdown = async () => {
+    logger.info(`Shutting down ${title}...`);
+    await Promise.all(
+      Array.from(shutdownListeners).map((listener) => listener())
+    );
+    logger.info(`${title} shutdown complete`);
+  };
+  _reacttoolkit.ToolkitRenderer.render(
+    createApp({
+      title,
+      version,
+      toolkit,
+      logger,
+      logEventEmitter,
+      setAppApi,
+      setWindowUrl,
+      shutdownContext,
+      ...appProps
+    }),
+    toolkit,
+    {},
+    {
+      componentNamespaces
+    }
+  );
+  return {
+    addEventListener: (event, listener) => {
+      if (event === "apiChange") {
+        const apiListener = listener;
+        apiListeners.add(apiListener);
+        if (api) {
+          apiListener(api);
+        }
+        return;
+      }
+      const windowUrlListener = listener;
+      windowUrlListeners.add(windowUrlListener);
+      if (windowUrl) {
+        windowUrlListener(windowUrl);
+      }
+    },
+    shutdown
+  };
+};
+
+// src/app-shell.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var AppShell = ({
+  title,
+  version,
+  dataDirectory,
+  logger,
+  logEventEmitter,
+  shutdownContext,
+  children
+}) => {
+  const [logs, setLogs] = _react.useState.call(void 0, []);
+  const lastLogIndex = _nullishCoalesce(_optionalChain([logs, 'access', _3 => _3[logs.length - 1], 'optionalAccess', _4 => _4.index]), () => ( -1));
+  _react.useEffect.call(void 0, () => {
+    const listener = ({ logs: logs2 }) => setImmediate(() => setLogs(logs2));
+    logEventEmitter.addListener("logsUpdated", listener);
+    return () => {
+      logEventEmitter.removeListener("logsUpdated", listener);
+    };
+  }, [logEventEmitter]);
+  const system = _react.useMemo.call(void 0, 
+    () => createSystemInformation({ dataDirectory, version }),
+    [dataDirectory, version]
+  );
+  const appInformation = _react.useMemo.call(void 0, 
+    () => ({ version, title }),
+    [version, title]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ShutdownContext.Provider, { value: shutdownContext, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AppInformationContext.Provider, { value: appInformation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LoggerContext.Provider, { value: { logger }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    SIGIL_COMPONENTS.AppRoot,
+    {
+      lastLog: lastLogIndex,
+      system,
+      onGetLogs: async ({ after }) => {
+        return {
+          logs: logs.filter((log) => log.index > after)
+        };
+      },
+      children
+    }
+  ) }) }) });
+};
+
+// src/listener.tsx
+
+
+var _netutils = require('@arcanewizards/net-utils');
+var _isEqual = require('lodash/isEqual'); var _isEqual2 = _interopRequireDefault(_isEqual);
+
+var connectionDescription = (listener) => {
+  return `${_nullishCoalesce(listener.host, () => ( "0.0.0.0"))}:${listener.port}`;
+};
+var AppListenerManager = ({
+  appRegistration,
+  listenerConfig,
+  toolkit,
+  setWindowUrl
+}) => {
+  const logger = useLogger();
+  const listenerStateRef = _react.useRef.call(void 0, {});
+  const [listenerState, setListenerState] = _react.useState.call(void 0, listenerStateRef.current);
+  const updateReactState = _react.useCallback.call(void 0, () => {
+    setListenerState({ ...listenerStateRef.current });
+  }, []);
+  _react.useEffect.call(void 0, () => {
+    Object.entries(listenerStateRef.current).forEach(([key, state]) => {
+      if (!listenerConfig[key] || !_isEqual2.default.call(void 0, listenerConfig[key], state.config)) {
+        if (state.state === "connected") {
+          const delay = 500;
+          setTimeout(() => {
+            state.listener.close();
+            logger.info(`Closing listener: ${key}`);
+          }, delay);
+          logger.info(
+            `Will close listener ${key} on ${connectionDescription(state)} in ${delay}ms`
+          );
+          _optionalChain([appRegistration, 'optionalAccess', _5 => _5.removeConnection, 'call', _6 => _6(key)]);
+        }
+        delete listenerStateRef.current[key];
+      }
+    });
+    _netutils.getNetworkInterfaces.call(void 0, ).then(async (interfaces) => {
+      listenerLoop: for (const [key, config] of Object.entries(
+        listenerConfig
+      )) {
+        const basePortInformation = {
+          direction: "input",
+          target: config.interface ? {
+            type: "interface",
+            interface: config.interface
+          } : {
+            type: "host",
+            host: "0.0.0.0"
+          },
+          port: config.port
+        };
+        if (!listenerStateRef.current[key]) {
+          let host = void 0;
+          if (config.interface) {
+            const iface = interfaces[config.interface];
+            if (!iface) {
+              const error = new Error(
+                `Network interface ${config.interface} not found`
+              );
+              _optionalChain([appRegistration, 'optionalAccess', _7 => _7.setConnection, 'call', _8 => _8(key, {
+                ...basePortInformation,
+                status: "error",
+                errors: [error.message]
+              })]);
+              logger.error(error);
+              listenerStateRef.current[key] = {
+                state: "error",
+                config,
+                error: error.message
+              };
+              continue listenerLoop;
+            }
+            host = iface.address;
+          }
+          listenerStateRef.current[key] = { state: "connecting", config };
+          const from = typeof config.port === "number" ? config.port : config.port.from;
+          const to = typeof config.port === "number" ? config.port : config.port.to;
+          portRange: for (let port = from; port <= to; port++) {
+            const resolvedConnectionDetails = {
+              config,
+              host,
+              port
+            };
+            try {
+              const listener = await toolkit.listen({
+                port,
+                host
+              });
+              if (!listenerStateRef.current[key]) {
+                listener.close();
+              } else {
+                listenerStateRef.current[key] = {
+                  state: "connected",
+                  listener,
+                  ...resolvedConnectionDetails
+                };
+                _optionalChain([appRegistration, 'optionalAccess', _9 => _9.setConnection, 'call', _10 => _10(key, {
+                  ...basePortInformation,
+                  port,
+                  status: "active"
+                })]);
+                logger.info(
+                  `App listener ${key} started on ${connectionDescription(resolvedConnectionDetails)}`
+                );
+                break portRange;
+              }
+            } catch (err) {
+              if (port === to) {
+                const error = new Error(
+                  `Failed to start listener on ${connectionDescription(
+                    resolvedConnectionDetails
+                  )}${from !== to ? ` (for port range ${from}-${to}) latest error` : ""}`,
+                  { cause: err }
+                );
+                listenerStateRef.current[key] = {
+                  state: "error",
+                  config,
+                  error: `${error}`
+                };
+                _optionalChain([appRegistration, 'optionalAccess', _11 => _11.setConnection, 'call', _12 => _12(key, {
+                  ...basePortInformation,
+                  status: "error",
+                  errors: [error.message]
+                })]);
+                logger.error(error);
+              }
+            } finally {
+              updateReactState();
+            }
+          }
+        }
+      }
+    }).catch((err) => {
+      const error = new Error("Failed to get network interfaces:", {
+        cause: err
+      });
+      logger.error(error);
+      Object.entries(listenerConfig).forEach(([key, config]) => {
+        if (!listenerStateRef.current[key]) {
+          listenerStateRef.current[key] = {
+            state: "error",
+            config,
+            error: `Failed to get network interfaces: ${error}`
+          };
+        }
+      });
+      updateReactState();
+    });
+    updateReactState();
+  }, [appRegistration, listenerConfig, logger, toolkit, updateReactState]);
+  _react.useEffect.call(void 0, () => {
+    for (const state of Object.values(listenerState)) {
+      if (state.state === "connected") {
+        setWindowUrl(
+          new URL(`http://${_nullishCoalesce(state.host, () => ( "localhost"))}:${state.port}/`)
+        );
+        return;
+      }
+    }
+  });
+  return null;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AppInformationContext = AppInformationContext; exports.AppListenerManager = AppListenerManager; exports.AppRoot = AppRoot; exports.AppShell = AppShell; exports.LoggerContext = LoggerContext; exports.SIGIL_COMPONENTS = SIGIL_COMPONENTS; exports.SIGIL_NAMESPACE = _chunkCAYKPJIXcjs.SIGIL_NAMESPACE; exports.ShutdownContext = ShutdownContext; exports.createSystemInformation = createSystemInformation; exports.isSigilComponent = _chunkCAYKPJIXcjs.isSigilComponent; exports.isSigilComponentCall = _chunkCAYKPJIXcjs.isSigilComponentCall; exports.runSigilApp = runSigilApp; exports.useLogger = useLogger; exports.useShutdownHandler = useShutdownHandler;

package/dist/index.d.cts

@@ -0,0 +1,134 @@
+import * as react from 'react';
+import { JSX, ReactNode, FC } from 'react';
+import { Logger } from '@arcanejs/protocol/logging';
+import { ToolkitRenderer } from '@arcanejs/react-toolkit';
+import { Toolkit, ToolkitOptions, ToolkitRenderContext } from '@arcanejs/toolkit';
+import { EventEmitter } from 'node:events';
+import pino from 'pino';
+import { A as AppRootLogEntry, S as SystemInformation } from './types-X8O95zmC.cjs';
+export { a as AppRootLogEntryStackFrame } from './types-X8O95zmC.cjs';
+import { AnyClientComponentCall } from '@arcanejs/protocol';
+import { BaseParent, AnyComponent } from '@arcanejs/toolkit/components/base';
+import { IDMap } from '@arcanejs/toolkit/util';
+import { g as SigilNamespace, S as SigilAppRootComponent, a as AppRootGetLogsArgs, b as AppRootGetLogsReturn, e as SigilComponentCalls } from './proto-B-WcMUOE.cjs';
+export { A as AppRootGetLogs, c as SIGIL_NAMESPACE, d as SigilComponent, h as SigilComponentMessage, i as isSigilComponent, f as isSigilComponentCall } from './proto-B-WcMUOE.cjs';
+import { NetworkPortStatus } from '@arcanewizards/net-utils';
+import '@arcanejs/diff';
+
+type AppInformationContextData = {
+    version: string;
+    title: string;
+};
+declare const AppInformationContext: react.Context<AppInformationContextData>;
+type ShutdownContextData = {
+    addShutdownListener: (listener: () => Promise<void>) => void;
+    removeShutdownListener: (listener: () => Promise<void>) => void;
+};
+declare const ShutdownContext: react.Context<ShutdownContextData>;
+declare const useShutdownHandler: (handler: () => Promise<void>) => void;
+declare const LoggerContext: react.Context<{
+    logger: Logger;
+}>;
+declare const useLogger: () => Logger;
+
+type SigilLogEventEmitter = EventEmitter<{
+    logsUpdated: [{
+        logs: AppRootLogEntry[];
+    }];
+}>;
+type SigilRuntimeAppProps<TAppApi, TExtraAppProps extends object> = TExtraAppProps & {
+    title: string;
+    version: string;
+    toolkit: Toolkit;
+    logger: Logger;
+    logEventEmitter: SigilLogEventEmitter;
+    setAppApi: (api: TAppApi | null) => void;
+    setWindowUrl: (windowUrl: URL) => void;
+    shutdownContext: ShutdownContextData;
+};
+type SigilRuntimeEventMap<TAppApi> = {
+    apiChange: (api: TAppApi | null) => void;
+    windowUrlChange: (url: URL) => void;
+};
+type SigilAppInstance<TAppApi> = {
+    addEventListener<K extends keyof SigilRuntimeEventMap<TAppApi>>(event: K, listener: SigilRuntimeEventMap<TAppApi>[K]): void;
+    shutdown: () => Promise<void>;
+};
+type SigilRuntimeOptions<TAppApi, TExtraAppProps extends object> = {
+    logger: pino.Logger;
+    title: string;
+    version: string;
+    appProps: TExtraAppProps;
+    toolkitOptions?: Omit<Partial<ToolkitOptions>, 'logger'>;
+    createApp: (props: SigilRuntimeAppProps<TAppApi, TExtraAppProps>) => JSX.Element;
+    componentNamespaces?: NonNullable<Parameters<typeof ToolkitRenderer.render>[3]>['componentNamespaces'];
+};
+declare const createSystemInformation: ({ dataDirectory, version, }: {
+    dataDirectory: string;
+    version: string;
+}) => SystemInformation;
+declare const runSigilApp: <TAppApi, TExtraAppProps extends object>({ logger: upstreamLogger, title, version, appProps, toolkitOptions, createApp, componentNamespaces, }: SigilRuntimeOptions<TAppApi, TExtraAppProps>) => SigilAppInstance<TAppApi>;
+
+type AppShellProps = {
+    title: string;
+    version: string;
+    dataDirectory: string;
+    logger: Logger;
+    logEventEmitter: SigilLogEventEmitter;
+    shutdownContext: ShutdownContextData;
+    children: ReactNode;
+};
+declare const AppShell: ({ title, version, dataDirectory, logger, logEventEmitter, shutdownContext, children, }: AppShellProps) => JSX.Element;
+
+type AppRootEvents = {
+    getLogs: (args: AppRootGetLogsArgs) => Promise<AppRootGetLogsReturn>;
+};
+type AppRootProps = Pick<SigilAppRootComponent, 'lastLog' | 'system'> & {
+    onGetLogs?: AppRootEvents['getLogs'];
+};
+type SupportedCalls = 'app-root-get-logs';
+declare class AppRoot extends BaseParent<SigilNamespace, SigilAppRootComponent, AppRootProps, SigilComponentCalls, SupportedCalls> {
+    private readonly events;
+    constructor(props: AppRootProps);
+    addListener: <T extends "getLogs">(type: T, listener: AppRootEvents[T]) => void;
+    removeListener: <T extends "getLogs">(type: T, listener: AppRootEvents[T]) => void;
+    validateChildren: (children: AnyComponent[]) => void;
+    getProtoInfo(idMap: IDMap, context: ToolkitRenderContext): SigilAppRootComponent;
+    handleCall: (call: AnyClientComponentCall) => Promise<AppRootGetLogsReturn>;
+}
+declare const SIGIL_COMPONENTS: {
+    _namespace: string;
+    _creators: {
+        AppRoot: (props: {
+            [key: string]: any;
+        }) => AnyComponent;
+    };
+} & {
+    AppRoot: react.ForwardRefExoticComponent<Pick<SigilAppRootComponent, "lastLog" | "system"> & {
+        onGetLogs?: AppRootEvents["getLogs"];
+    } & {
+        children?: react.ReactNode;
+    } & react.RefAttributes<AppRoot>>;
+};
+
+type ListenerConfig = {
+    port: number | {
+        from: number;
+        to: number;
+    };
+    interface?: string | undefined;
+};
+type AllListenerConfig = Record<string, ListenerConfig>;
+type AppListenerManagerAppRegistration = {
+    removeConnection: (uuid: string) => void;
+    setConnection: (uuid: string, details: NetworkPortStatus) => void;
+};
+type AppListenerManagerProps = {
+    appRegistration?: AppListenerManagerAppRegistration;
+    listenerConfig: AllListenerConfig;
+    toolkit: Toolkit;
+    setWindowUrl: (windowUrl: URL) => void;
+};
+declare const AppListenerManager: FC<AppListenerManagerProps>;
+
+export { type AllListenerConfig, AppInformationContext, type AppInformationContextData, AppListenerManager, type AppListenerManagerAppRegistration, AppRoot, AppRootGetLogsArgs, AppRootGetLogsReturn, AppRootLogEntry, AppShell, type AppShellProps, type ListenerConfig, LoggerContext, SIGIL_COMPONENTS, ShutdownContext, type ShutdownContextData, type SigilAppInstance, SigilAppRootComponent, SigilComponentCalls, type SigilRuntimeAppProps, type SigilRuntimeEventMap, type SigilRuntimeOptions, SystemInformation, createSystemInformation, runSigilApp, useLogger, useShutdownHandler };