@arcanejs/toolkit 8.0.0 → 9.0.1

package/dist/index.mjs

@@ -1,38 +1,38 @@
 import {
   Tab,
   Tabs
-} from "./chunk-R5OA7LLZ.mjs";
+} from "./chunk-5K7DK7CW.mjs";
 import {
   TextInput
-} from "./chunk-GXJ3JRRK.mjs";
+} from "./chunk-VD6S32ED.mjs";
 import {
   Timeline
-} from "./chunk-6PS3Q66F.mjs";
+} from "./chunk-Y3NPWW27.mjs";
 import {
   IDMap
 } from "./chunk-RGHJEMWG.mjs";
 import {
   Button
-} from "./chunk-7MQHRTBE.mjs";
+} from "./chunk-RGLKNCJ3.mjs";
 import {
   Group,
   GroupHeader
-} from "./chunk-TULW7CRV.mjs";
+} from "./chunk-NJW4ZG4X.mjs";
 import {
   Label
-} from "./chunk-JHWFQLLE.mjs";
+} from "./chunk-MNEFCU3M.mjs";
 import {
   Rect
-} from "./chunk-RJLYYTZ6.mjs";
+} from "./chunk-7WTSYZOS.mjs";
 import {
   SliderButton
-} from "./chunk-K6V55JTG.mjs";
+} from "./chunk-KO24S32V.mjs";
 import {
   Switch
-} from "./chunk-MHSAHTVN.mjs";
+} from "./chunk-QBZB56TQ.mjs";
 import {
   EventEmitter
-} from "./chunk-GONHNB6V.mjs";
+} from "./chunk-UTTTCTUQ.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
@@ -69,15 +69,26 @@ var distDir = () => {
       throw new Error(`Server running from unknown location: ${__dirname}`);
   }
 };
+var UPLOAD_URL = /^\/upload\/([0-9a-f]+)$/;
+var DOWNLOAD_URL = /^\/download\/([0-9a-f]+)$/;
 var Server = class {
-  constructor(options, onNewConnection, onClosedConnection, onMessage, log) {
+  constructor(options, onNewConnection, onClosedConnection, onMessage, onUpload, onDownload, log) {
     this.options = options;
     this.onNewConnection = onNewConnection;
     this.onClosedConnection = onClosedConnection;
     this.onMessage = onMessage;
+    this.onUpload = onUpload;
+    this.onDownload = onDownload;
     this.log = log;
     this.title = options.title ?? "@arcanejs";
   }
+  options;
+  onNewConnection;
+  onClosedConnection;
+  onMessage;
+  onUpload;
+  onDownload;
+  log;
   staticFiles = null;
   htmlContext = null;
   staticFilesInitPromise = null;
@@ -273,8 +284,45 @@ var Server = class {
         }
       }
     }
-    res.writeHead(404, { "Content-Type": "text/plain" });
-    res.end("not found", "utf-8");
+    const [uploadMatch, downloadMatch] = [
+      UPLOAD_URL.exec(pathname),
+      DOWNLOAD_URL.exec(pathname)
+    ];
+    if (uploadMatch?.[1]) {
+      const id = uploadMatch[1];
+      this.log?.debug("Upload request for id: %s", id);
+      this.onUpload(id, req).then(() => {
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end("Upload successful", "utf-8");
+      }).catch((cause) => {
+        const error = new Error(`Error handling upload for id ${id}`, {
+          cause
+        });
+        this.log?.error(error);
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Error handling upload", "utf-8");
+      });
+    } else if (downloadMatch?.[1]) {
+      const id = downloadMatch[1];
+      this.log?.debug("Download request for id: %s", id);
+      this.onDownload(id).then((handler) => handler()).then(({ stream, headers }) => {
+        res.writeHead(200, {
+          "Content-Type": "application/octet-stream",
+          ...headers
+        });
+        stream.pipe(res);
+      }).catch((cause) => {
+        const error = new Error(`Error handling download for id ${id}`, {
+          cause
+        });
+        this.log?.error(error);
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("Error handling download", "utf-8");
+      });
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("not found", "utf-8");
+    }
   };
   parsePathname = (url) => {
     if (!url) return "";
@@ -327,6 +375,7 @@ var Server = class {
 import { WebSocketServer } from "ws";
 import { createServer } from "http";
 import { v4 as uuidv4 } from "uuid";
+import { randomBytes } from "crypto";
 var normalizeClockSyncOptions = (clockSync) => {
   if (!clockSync) {
     return null;
@@ -353,6 +402,8 @@ var Toolkit = class {
   /** @hidden */
   events = new EventEmitter();
   server;
+  uploads = /* @__PURE__ */ new Map();
+  downloads = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.options = {
       ...DEFAULT_LIGHT_DESK_OPTIONS,
@@ -369,6 +420,8 @@ var Toolkit = class {
       this.onNewConnection,
       this.onClosedConnection,
       this.onMessage,
+      this.onUpload,
+      this.onDownload,
       this.options.log
     );
   }
@@ -502,6 +555,25 @@ var Toolkit = class {
     const con = this.connections.get(connection);
     this.connections.delete(connection);
     if (con) {
+      let inProgressUploads = 0;
+      let inProgressDownloads = 0;
+      for (const [id, upload] of this.uploads.entries()) {
+        if (upload.connection === connection) {
+          this.uploads.delete(id);
+          inProgressUploads++;
+        }
+      }
+      for (const [id, download] of this.downloads.entries()) {
+        if (download.connection === connection) {
+          this.downloads.delete(id);
+          inProgressDownloads++;
+        }
+      }
+      if (inProgressUploads > 0 || inProgressDownloads > 0) {
+        this.log()?.info(
+          `Connection closed with ${inProgressUploads} in-progress uploads and ${inProgressDownloads} in-progress downloads`
+        );
+      }
       this.events.emit("closed-connection", con.publicConnection);
     }
   };
@@ -509,12 +581,32 @@ var Toolkit = class {
     try {
       const rg = this.rootGroup;
       if (rg) {
-        const returnValue = await new Promise(
+        const handlerValue = await new Promise(
           (resolve2, reject) => rg.routeCall(this.componentIDMap, call, publicConnection, {
             resolve: resolve2,
             reject
           })
         );
+        let returnValue;
+        if (call.type === "component-call") {
+          returnValue = handlerValue;
+        } else if (call.type === "component-call-upload") {
+          const uploadHandler = handlerValue;
+          const secureId = randomBytes(32).toString("hex");
+          this.uploads.set(secureId, {
+            connection,
+            handler: uploadHandler
+          });
+          returnValue = secureId;
+        } else if (call.type === "component-call-download") {
+          const downloadHandler = handlerValue;
+          const secureId = randomBytes(32).toString("hex");
+          this.downloads.set(secureId, {
+            connection,
+            handler: downloadHandler
+          });
+          returnValue = secureId;
+        }
         connection.sendMessage({
           type: "call-response",
           namespace: call.namespace,
@@ -525,13 +617,15 @@ var Toolkit = class {
       } else {
         throw new Error("No root group set");
       }
-    } catch (err) {
+    } catch (cause) {
+      const error = new Error(`Error handling call`, { cause });
+      this.log()?.error(error);
       connection.sendMessage({
         type: "call-response",
         namespace: call.namespace,
         requestId: call.requestId,
         success: false,
-        errorMessage: `${err}`
+        errorMessage: `${cause}`
       });
     }
   };
@@ -547,25 +641,57 @@ var Toolkit = class {
       message,
       publicConnection.uuid
     );
-    switch (message.type) {
-      case "component-message":
-        if (this.rootGroup)
-          this.rootGroup.routeMessage(
-            this.componentIDMap,
-            message,
-            publicConnection
-          );
-        break;
-      case "component-call":
-        this.handleCall(connection, publicConnection, message);
-        break;
-      case "ping": {
-        connection.sendMessage({
-          type: "pong",
-          pingId: message.pingId,
-          serverTimeMillis: Date.now()
-        });
-        break;
+    try {
+      switch (message.type) {
+        case "component-message":
+          if (this.rootGroup)
+            this.rootGroup.routeMessage(
+              this.componentIDMap,
+              message,
+              publicConnection
+            );
+          break;
+        case "component-call":
+        case "component-call-upload":
+        case "component-call-download":
+          this.handleCall(connection, publicConnection, message);
+          break;
+        case "ping": {
+          connection.sendMessage({
+            type: "pong",
+            pingId: message.pingId,
+            serverTimeMillis: Date.now()
+          });
+          break;
+        }
+      }
+    } catch (cause) {
+      const error = new Error(
+        `Error handling message: ${JSON.stringify(message)}`,
+        { cause }
+      );
+      this.log()?.error(error);
+    }
+  };
+  onUpload = async (id, data) => {
+    const upload = this.uploads.get(id);
+    if (!upload) {
+      throw new Error(`No upload handler found for id: ${id}`);
+    }
+    await upload.handler(data);
+    this.uploads.delete(id);
+  };
+  onDownload = async (id) => {
+    const download = this.downloads.get(id);
+    if (!download) {
+      throw new Error(`No download handler found for id: ${id}`);
+    }
+    return download.handler;
+  };
+  sendNotification = (notification, filter) => {
+    for (const [connection, meta] of this.connections.entries()) {
+      if (!filter || filter(meta.publicConnection)) {
+        connection.sendMessage(notification);
       }
     }
   };

package/dist/{toolkit-Bglbv3ix.d.ts → toolkit-0nxr5FpP.d.ts}

@@ -4,10 +4,115 @@ import _ from 'lodash';
 import * as http from 'http';
 import { Application } from 'express';
 import { WebSocket } from 'ws';
-import { ClientMessage, ServerMessage, BaseComponentProto, AnyClientComponentMessage, AnyClientComponentCall, ReturnForPair } from '@arcanejs/protocol';
+import { BaseComponentProto, AnyClientComponentMessage, AnyClientComponentCall, AnyClientComponentCallUpload, AnyClientComponentCallDownload, ReturnForPair, ServerMessage, ClientMessage, BaseNotificationMessage } from '@arcanejs/protocol';
+import { Readable } from 'node:stream';
+import { I as IDMap } from './id-map-DxQ3_gyA.js';
 import * as proto from '@arcanejs/protocol/core';
 import { GroupComponentStyle } from '@arcanejs/protocol/styles';
-import { I as IDMap } from './id-map-DxQ3_gyA.js';
+
+type CallUploadResponse = (data: Readable) => Promise<void>;
+type CallDownloadResponse = () => Promise<{
+    stream: Readable;
+    headers: Record<string, string>;
+}>;
+declare abstract class Base<Namespace extends string, Proto extends BaseComponentProto<Namespace, string>, Props, CallPairs = any, CallActions extends string & keyof CallPairs = any> {
+    /** @hidden */
+    private parent;
+    /** @hidden */
+    private readonly defaultProps;
+    /** @hidden */
+    private _props;
+    /** @hidden */
+    private _onPropsUpdated;
+    constructor(defaultProps: Props, props?: Partial<Props>, options?: {
+        onPropsUpdated?: (oldProps: Props) => void;
+    });
+    /**
+     * Call if
+     */
+    triggerInitialPropsUpdate: () => void;
+    log: () => Logger | null;
+    get props(): Props;
+    set props(props: Partial<Props>);
+    setProps: (props: Partial<Props>) => void;
+    updateProps: (updates: Partial<Props>) => void;
+    /** @hidden */
+    setParent(parent: Parent | null): void;
+    /** @hidden */
+    updateTree(): void;
+    /** @hidden */
+    abstract getProtoInfo(idMap: IDMap, context: ToolkitRenderContext): Proto;
+    /** @hidden */
+    handleMessage(_message: AnyClientComponentMessage, _connection: ToolkitConnection): void;
+    /** @hidden */
+    handleAnyCall(message: AnyClientComponentCall | AnyClientComponentCallUpload | AnyClientComponentCallDownload, _connection: ToolkitConnection): Promise<ReturnForPair<CallPairs, CallActions> | CallUploadResponse | CallDownloadResponse>;
+    /** @hidden */
+    handleCall(_call: AnyClientComponentCall, _connection: ToolkitConnection): Promise<ReturnForPair<CallPairs, CallActions>>;
+    /** @hidden */
+    handleCallUpload(_call: AnyClientComponentCallUpload, _connection: ToolkitConnection): Promise<CallUploadResponse>;
+    /** @hidden */
+    handleCallDownload(_call: AnyClientComponentCallDownload, _connection: ToolkitConnection): Promise<CallDownloadResponse>;
+    routeMessage(_idMap: IDMap, _message: AnyClientComponentMessage, _connection: ToolkitConnection): void;
+    routeCall(_idMap: IDMap, _call: AnyClientComponentCall | AnyClientComponentCallUpload | AnyClientComponentCallDownload, _connection: ToolkitConnection, _callbacks: {
+        resolve: (result: unknown) => void;
+        reject: (error: unknown) => void;
+    }): void;
+}
+type AnyComponent = Base<string, BaseComponentProto<string, string>, any>;
+/** @hidden */
+interface Parent {
+    updateTree(): void;
+    removeChild(component: AnyComponent): void;
+    log(): Logger | null;
+}
+declare abstract class BaseParent<Namespace extends string, Proto extends BaseComponentProto<Namespace, string>, T, CallPairs = any, CallActions extends string & keyof CallPairs = any> extends Base<Namespace, Proto, T, CallPairs, CallActions> implements Parent {
+    /** @hidden */
+    private children;
+    abstract validateChildren(children: AnyComponent[]): void;
+    appendChildren: <CS extends AnyComponent[]>(...children: CS) => CS;
+    appendChild: <C extends AnyComponent>(child: C) => C;
+    removeChild: (component: AnyComponent) => void;
+    removeAllChildren: () => void;
+    /**
+     * Return all children components that messages need to be routed to
+     */
+    getChildren: () => readonly AnyComponent[];
+    /**
+     * TODO: we can do this better, right now it broadcasts the message to all
+     * components of the tree
+     *
+     * @hidden
+     */
+    routeMessage(idMap: IDMap, message: AnyClientComponentMessage, connection: ToolkitConnection): void;
+    routeCall(idMap: IDMap, call: AnyClientComponentCall | AnyClientComponentCallUpload | AnyClientComponentCallDownload, connection: ToolkitConnection, callbacks: {
+        resolve: (result: unknown) => void;
+        reject: (error: unknown) => void;
+    }): Promise<void>;
+    insertBefore(child: AnyComponent, beforeChild: AnyComponent): void;
+}
+interface Listenable<Map extends Record<string, (...args: any[]) => void>> {
+    addListener<T extends keyof Map>(type: T, listener: Map[T]): void;
+    removeListener<T extends keyof Map>(type: T, listener: Map[T]): void;
+}
+declare class EventEmitter<Map extends Record<string, (...args: any[]) => void>> implements Listenable<Map> {
+    private readonly listeners;
+    addListener: <T extends keyof Map>(type: T, listener: Map[T]) => void;
+    removeListener: <T extends keyof Map>(type: T, listener: Map[T]) => void;
+    emit: <T extends keyof Map>(type: T, ...args: Parameters<Map[T]>) => Promise<ReturnType<Map[T]>[]>;
+    /**
+     * Like {@link emit},
+     * but ensures only a single listener exists and returns its result.
+     */
+    call: <T extends keyof Map>(type: T, ...args: Parameters<Map[T]>) => Promise<ReturnType<Map[T]>>;
+    /**
+     * Process prop changes to update listeners
+     */
+    processPropChanges: <Mapping extends Record<string, keyof Map>, Props extends { [key in keyof Mapping]?: Map[Mapping[key]] | null | undefined; }>(
+    /**
+     * Mapping from prop key to event name
+     */
+    mapping: Mapping, oldProps: Props, newProps: Props) => void;
+}
 
 interface Connection {
     sendMessage(msg: ServerMessage): void;
@@ -17,12 +122,14 @@ declare class Server<TAdditionalFiles extends ToolkitAdditionalFiles = Record<ne
     private readonly onNewConnection;
     private readonly onClosedConnection;
     private readonly onMessage;
+    private readonly onUpload;
+    private readonly onDownload;
     private readonly log?;
     private staticFiles;
     private htmlContext;
     private staticFilesInitPromise;
     private readonly title;
-    constructor(options: ToolkitOptions<TAdditionalFiles>, onNewConnection: (connection: Connection) => void, onClosedConnection: (connection: Connection) => void, onMessage: (connection: Connection, message: ClientMessage) => void, log?: Logger | undefined);
+    constructor(options: ToolkitOptions<TAdditionalFiles>, onNewConnection: (connection: Connection) => void, onClosedConnection: (connection: Connection) => void, onMessage: (connection: Connection, message: ClientMessage) => void, onUpload: (id: string, data: Readable) => Promise<void>, onDownload: (id: string) => Promise<CallDownloadResponse>, log?: Logger | undefined);
     private getEntrypointPaths;
     private fileExists;
     private ensureStaticFilesInitialized;
@@ -147,95 +254,6 @@ type InitializationOptions<TAdditionalFiles extends ToolkitAdditionalFiles = Rec
     setup: (server: Server<TAdditionalFiles>) => void;
 };
 
-declare abstract class Base<Namespace extends string, Proto extends BaseComponentProto<Namespace, string>, Props, CallPairs = any, CallActions extends string & keyof CallPairs = any> {
-    /** @hidden */
-    private parent;
-    /** @hidden */
-    private readonly defaultProps;
-    /** @hidden */
-    private _props;
-    /** @hidden */
-    private _onPropsUpdated;
-    constructor(defaultProps: Props, props?: Partial<Props>, options?: {
-        onPropsUpdated?: (oldProps: Props) => void;
-    });
-    /**
-     * Call if
-     */
-    triggerInitialPropsUpdate: () => void;
-    log: () => Logger | null;
-    get props(): Props;
-    set props(props: Partial<Props>);
-    setProps: (props: Partial<Props>) => void;
-    updateProps: (updates: Partial<Props>) => void;
-    /** @hidden */
-    setParent(parent: Parent | null): void;
-    /** @hidden */
-    updateTree(): void;
-    /** @hidden */
-    abstract getProtoInfo(idMap: IDMap, context: ToolkitRenderContext): Proto;
-    /** @hidden */
-    handleMessage(_message: AnyClientComponentMessage, _connection: ToolkitConnection): void;
-    /** @hidden */
-    handleCall(_call: AnyClientComponentCall, _connection: ToolkitConnection): Promise<ReturnForPair<CallPairs, CallActions>>;
-    routeMessage(_idMap: IDMap, _message: AnyClientComponentMessage, _connection: ToolkitConnection): void;
-    routeCall(_idMap: IDMap, _call: AnyClientComponentCall, _connection: ToolkitConnection, _callbacks: {
-        resolve: (result: unknown) => void;
-        reject: (error: unknown) => void;
-    }): void;
-}
-type AnyComponent = Base<string, BaseComponentProto<string, string>, any>;
-/** @hidden */
-interface Parent {
-    updateTree(): void;
-    removeChild(component: AnyComponent): void;
-    log(): Logger | null;
-}
-declare abstract class BaseParent<Namespace extends string, Proto extends BaseComponentProto<Namespace, string>, T, CallPairs = any, CallActions extends string & keyof CallPairs = any> extends Base<Namespace, Proto, T, CallPairs, CallActions> implements Parent {
-    /** @hidden */
-    private children;
-    abstract validateChildren(children: AnyComponent[]): void;
-    appendChildren: <CS extends AnyComponent[]>(...children: CS) => CS;
-    appendChild: <C extends AnyComponent>(child: C) => C;
-    removeChild: (component: AnyComponent) => void;
-    removeAllChildren: () => void;
-    /**
-     * Return all children components that messages need to be routed to
-     */
-    getChildren: () => readonly AnyComponent[];
-    /**
-     * TODO: we can do this better, right now it broadcasts the message to all
-     * components of the tree
-     *
-     * @hidden
-     */
-    routeMessage(idMap: IDMap, message: AnyClientComponentMessage, connection: ToolkitConnection): void;
-    routeCall(idMap: IDMap, call: AnyClientComponentCall, connection: ToolkitConnection, callbacks: {
-        resolve: (result: unknown) => void;
-        reject: (error: unknown) => void;
-    }): Promise<void>;
-    insertBefore(child: AnyComponent, beforeChild: AnyComponent): void;
-}
-interface Listenable<Map extends Record<string, (...args: any[]) => void>> {
-    addListener<T extends keyof Map>(type: T, listener: Map[T]): void;
-    removeListener<T extends keyof Map>(type: T, listener: Map[T]): void;
-}
-declare class EventEmitter<Map extends Record<string, (...args: any[]) => void>> implements Listenable<Map> {
-    private readonly listeners;
-    addListener: <T extends keyof Map>(type: T, listener: Map[T]) => void;
-    removeListener: <T extends keyof Map>(type: T, listener: Map[T]) => void;
-    emit: <T extends keyof Map>(type: T, ...args: Parameters<Map[T]>) => Promise<ReturnType<Map[T]>[]>;
-    /**
-     * Like {@link emit},
-     * but ensures only a single listener exists and returns its result.
-     */
-    call: <T extends keyof Map>(type: T, ...args: Parameters<Map[T]>) => Promise<ReturnType<Map[T]>>;
-    /**
-     * Process prop changes to update listeners
-     */
-    processPropChanges: <Mapping extends Record<string, keyof Map>, Props extends { [key in keyof Mapping]?: Map[Mapping[key]] | null | undefined; }>(mapping: Mapping, oldProps: Props, newProps: Props) => void;
-}
-
 type Events$2 = {
     click: (connection: ToolkitConnection) => void | Promise<void>;
 };
@@ -338,6 +356,8 @@ declare class Toolkit<TAdditionalFiles extends ToolkitAdditionalFiles = Record<n
     /** @hidden */
     private readonly events;
     private readonly server;
+    private readonly uploads;
+    private readonly downloads;
     constructor(options?: Partial<ToolkitOptions<TAdditionalFiles>>);
     addListener: <T extends keyof Events>(type: T, listener: Events[T]) => void;
     removeListener: <T extends keyof Events>(type: T, listener: Events[T]) => void;
@@ -352,6 +372,9 @@ declare class Toolkit<TAdditionalFiles extends ToolkitAdditionalFiles = Record<n
     private onClosedConnection;
     private handleCall;
     private onMessage;
+    private onUpload;
+    private onDownload;
+    sendNotification: (notification: BaseNotificationMessage<string, string>, filter?: (connection: ToolkitConnection) => boolean) => void;
 }
 
-export { type AnyComponent as A, Button as B, EventEmitter as E, Group as G, type InternalProps$1 as I, type Listenable as L, type Parent as P, Toolkit as T, type ToolkitConnection as a, type ToolkitRenderContext as b, type ToolkitServerListenerOptions as c, type ToolkitServerListener as d, type ToolkitAdditionalFiles as e, type ToolkitClockSyncOptions as f, type ToolkitCoreAssetRelativePath as g, type ToolkitHtmlPageContext as h, type ToolkitOptions as i, type ToolkitStaticFile as j, type ToolkitStaticFileResolver as k, GroupHeader as l, Base as m, BaseParent as n, type Events$2 as o, type ButtonMode as p, type Props$1 as q, type Events$1 as r, type InternalProps as s, type Props as t };
+export { type AnyComponent as A, Button as B, type CallDownloadResponse as C, EventEmitter as E, Group as G, type InternalProps$1 as I, type Listenable as L, type Parent as P, Toolkit as T, GroupHeader as a, type ToolkitAdditionalFiles as b, type ToolkitClockSyncOptions as c, type ToolkitConnection as d, type ToolkitCoreAssetRelativePath as e, type ToolkitHtmlPageContext as f, type ToolkitOptions as g, type ToolkitRenderContext as h, type ToolkitServerListener as i, type ToolkitServerListenerOptions as j, type ToolkitStaticFile as k, type ToolkitStaticFileResolver as l, Base as m, BaseParent as n, type CallUploadResponse as o, type ButtonMode as p, type Events$2 as q, type Props$1 as r, type Events$1 as s, type InternalProps as t, type Props as u };