@adcops/autocore-react 3.3.9 → 3.3.14

package/src/hub/HubSimulate.ts

@@ -1,124 +1,124 @@
-/*
- * Copyright (C) 2023 Automated Design Corp. All Rights Reserved.
- * Created Date: 2023-12-17 10:38:21
- * -----
- * Last Modified: 2026-01-29 09:34:15
- * Modified By: ADC
- * -----
- *
- */
-
-import { HubBase } from './HubBase';
-import type { CommandMessage } from "./CommandMessage";
-import { MessageType } from "./CommandMessage";
-
-/**
- * Hub for simulating backend functionality when no actual backend is present.
- *
- * Useful for development, testing, and demos without a running autocore-server.
- * The simulator echoes back requests as successful responses after a configurable delay.
- *
- * ## Usage Examples
- *
- * ```typescript
- * const { hub } = useContext(EventEmitterContext);
- *
- * // Read returns the topic as the "value"
- * const result = await hub.read("ads.plc1.gio.bControlPowerOk");
- * console.log(result.data); // { value: "ads.plc1.gio.bControlPowerOk" }
- *
- * // Write echoes back the written value
- * await hub.write("ads.plc1.gio.nSetpoint", 100);
- * ```
- */
-export class HubSimulate extends HubBase {
-
-    private responseDelay: number;
-
-    /**
-     * Constructor
-     * @param responseDelay Simulated response delay in milliseconds (default: 20ms)
-     */
-    constructor(responseDelay: number = 20) {
-        super();
-        this.responseDelay = responseDelay;
-        this.setIsConnected(true); // Simulator is always "connected"
-    }
-
-    /**
-     * Simulate sending a message to a backend.
-     *
-     * For Read operations, returns the topic as the value.
-     * For Write operations, echoes back the payload.
-     * For all operations, returns a successful response after the configured delay.
-     *
-     * @param topic The FQDN of the resource
-     * @param messageType The action to perform
-     * @param payload Optional data payload
-     * @returns Promise<CommandMessage> A simulated successful response
-     */
-    invoke(topic: string, messageType: MessageType, payload?: object): Promise<CommandMessage> {
-        return new Promise((resolve) => {
-            setTimeout(() => {
-                let responseData: any;
-
-                // Simulate appropriate responses based on message type
-                switch (messageType) {
-                    case MessageType.Read:
-                        // Simulate reading - return the topic as a "value"
-                        responseData = { value: topic, simulated: true };
-                        break;
-
-                    case MessageType.Write:
-                        // Simulate writing - echo back the payload
-                        responseData = { written: true, ...payload };
-                        break;
-
-                    case MessageType.Subscribe:
-                        // Simulate subscribing - acknowledge
-                        responseData = { subscribed: true, topic: topic };
-                        break;
-
-                    case MessageType.Unsubscribe:
-                        // Simulate unsubscribing - acknowledge
-                        responseData = { unsubscribed: true, topic: topic };
-                        break;
-
-                    default:
-                        // Echo back the payload for other message types
-                        responseData = payload ?? {};
-                        break;
-                }
-
-                const response: CommandMessage = {
-                    transaction_id: 0,
-                    timecode: Date.now(),
-                    topic: topic,
-                    message_type: MessageType.Response,
-                    data: responseData,
-                    success: true,
-                    error_message: ''
-                };
-
-                resolve(response);
-            }, this.responseDelay);
-        });
-    }
-
-    /**
-     * Simulate a broadcast from the "backend".
-     *
-     * This is useful for testing subscription handlers.
-     *
-     * @param topic The topic to broadcast on
-     * @param data The data to broadcast
-     * @param delay Optional delay before broadcasting (default: 0ms)
-     */
-    simulateBroadcast(topic: string, data: any, delay: number = 0): void {
-        setTimeout(() => {
-            this.publish(topic, data);
-        }, delay);
-    }
-}
-
-export default HubSimulate;
+/*
+ * Copyright (C) 2023 Automated Design Corp. All Rights Reserved.
+ * Created Date: 2023-12-17 10:38:21
+ * -----
+ * Last Modified: 2026-01-29 09:34:15
+ * Modified By: ADC
+ * -----
+ *
+ */
+
+import { HubBase } from './HubBase';
+import type { CommandMessage } from "./CommandMessage";
+import { MessageType } from "./CommandMessage";
+
+/**
+ * Hub for simulating backend functionality when no actual backend is present.
+ *
+ * Useful for development, testing, and demos without a running autocore-server.
+ * The simulator echoes back requests as successful responses after a configurable delay.
+ *
+ * ## Usage Examples
+ *
+ * ```typescript
+ * const { hub } = useContext(EventEmitterContext);
+ *
+ * // Read returns the topic as the "value"
+ * const result = await hub.read("ads.plc1.gio.bControlPowerOk");
+ * console.log(result.data); // { value: "ads.plc1.gio.bControlPowerOk" }
+ *
+ * // Write echoes back the written value
+ * await hub.write("ads.plc1.gio.nSetpoint", 100);
+ * ```
+ */
+export class HubSimulate extends HubBase {
+
+    private responseDelay: number;
+
+    /**
+     * Constructor
+     * @param responseDelay Simulated response delay in milliseconds (default: 20ms)
+     */
+    constructor(responseDelay: number = 20) {
+        super();
+        this.responseDelay = responseDelay;
+        this.setIsConnected(true); // Simulator is always "connected"
+    }
+
+    /**
+     * Simulate sending a message to a backend.
+     *
+     * For Read operations, returns the topic as the value.
+     * For Write operations, echoes back the payload.
+     * For all operations, returns a successful response after the configured delay.
+     *
+     * @param topic The FQDN of the resource
+     * @param messageType The action to perform
+     * @param payload Optional data payload
+     * @returns Promise<CommandMessage> A simulated successful response
+     */
+    invoke(topic: string, messageType: MessageType, payload?: object): Promise<CommandMessage> {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                let responseData: any;
+
+                // Simulate appropriate responses based on message type
+                switch (messageType) {
+                    case MessageType.Read:
+                        // Simulate reading - return the topic as a "value"
+                        responseData = { value: topic, simulated: true };
+                        break;
+
+                    case MessageType.Write:
+                        // Simulate writing - echo back the payload
+                        responseData = { written: true, ...payload };
+                        break;
+
+                    case MessageType.Subscribe:
+                        // Simulate subscribing - acknowledge
+                        responseData = { subscribed: true, topic: topic };
+                        break;
+
+                    case MessageType.Unsubscribe:
+                        // Simulate unsubscribing - acknowledge
+                        responseData = { unsubscribed: true, topic: topic };
+                        break;
+
+                    default:
+                        // Echo back the payload for other message types
+                        responseData = payload ?? {};
+                        break;
+                }
+
+                const response: CommandMessage = {
+                    transaction_id: 0,
+                    timecode: Date.now(),
+                    topic: topic,
+                    message_type: MessageType.Response,
+                    data: responseData,
+                    success: true,
+                    error_message: ''
+                };
+
+                resolve(response);
+            }, this.responseDelay);
+        });
+    }
+
+    /**
+     * Simulate a broadcast from the "backend".
+     *
+     * This is useful for testing subscription handlers.
+     *
+     * @param topic The topic to broadcast on
+     * @param data The data to broadcast
+     * @param delay Optional delay before broadcasting (default: 0ms)
+     */
+    simulateBroadcast(topic: string, data: any, delay: number = 0): void {
+        setTimeout(() => {
+            this.publish(topic, data);
+        }, delay);
+    }
+}
+
+export default HubSimulate;

package/src/hub/HubTauri.ts

@@ -1,140 +1,140 @@
-/*
- * Copyright (C) 2023 Automated Design Corp. All Rights Reserved.
- * Created Date: 2023-12-17 09:50:23
- * Author: Thomas C. Bitsky Jr.
- * -----
- * Last Modified: 2026-01-29 09:34:21
- * Modified By: ADC
- * -----
- *
- */
-
-import { HubBase } from './HubBase';
-import { invoke as tauriInvoke } from '@tauri-apps/api/core';
-import { listen } from '@tauri-apps/api/event';
-import type { CommandMessage } from "./CommandMessage";
-import { MessageType } from "./CommandMessage";
-
-type InvokeArgs = Record<string, unknown>;
-
-/**
- * Hub for integrating with the Tauri backend.
- *
- * The Tauri backend is expected to broadcast messages on the event
- * name: 'autocore://broadcast_event'
- *
- * This hub will capture those messages and dispatch them globally to any
- * listeners in the web app.
- *
- * ## Usage Examples
- *
- * ```typescript
- * const { hub } = useContext(EventEmitterContext);
- *
- * // Read a value
- * const result = await hub.read("ads.plc1.gio.bControlPowerOk");
- *
- * // Write a value
- * await hub.write("ads.plc1.gio.nSetpoint", 100);
- *
- * // Subscribe to changes
- * await hub.subscribe("modbus.holding_registers.5");
- * ```
- *
- * The hub can also publish/subscribe to frontend-only events:
- *
- * ```typescript
- * hub.publish("ui/panel-opened", { panelId: "settings" });
- * ```
- */
-export class HubTauri extends HubBase {
-
-    /**
-     * Constructor
-     */
-    constructor() {
-        super();
-
-        // Mark as connected since Tauri IPC is always available
-        this.setIsConnected(true);
-
-        /**
-         * Receive broadcasts from the Tauri backend. Data is received as a payload object,
-         * {topic: string, payload: any | null}
-         * From here, we extract into a form HubBase can use, then pass on to the
-         * dispatcher.
-         *
-         * Events without a topic are ignored.
-         */
-        listen('autocore://broadcast_event', (ev: any) => {
-            let objPayload = JSON.parse(ev.payload);
-
-            if (objPayload.topic !== undefined && objPayload.topic !== null) {
-                if (objPayload.payload !== undefined && objPayload.payload !== null) {
-                    this.publish(objPayload.topic, objPayload.payload);
-                }
-                else {
-                    this.publish(objPayload.topic, undefined);
-                }
-            }
-        });
-    }
-
-    /**
-     * Send a message to the Tauri backend.
-     *
-     * The topic and messageType are passed to a generic Tauri command handler
-     * that routes the request appropriately.
-     *
-     * @param topic The FQDN of the resource (e.g., "ads.plc1.gio.bControlPowerOk")
-     * @param messageType The action to perform (Read, Write, Subscribe, etc.)
-     * @param payload Optional data payload (e.g., value to write)
-     * @returns Promise<CommandMessage> The response from the backend
-     */
-    invoke(topic: string, messageType: MessageType, payload?: object): Promise<CommandMessage> {
-        console.log(`HubTauri.invoke: topic=${topic}, type=${MessageType[messageType]}`);
-
-        // Build the command arguments
-        const args: InvokeArgs = {
-            topic: topic,
-            message_type: messageType,
-            ...(payload ?? {})
-        };
-
-        // Call the generic autocore handler in Tauri backend
-        return new Promise((resolve, reject) => {
-            tauriInvoke('autocore_invoke', args)
-                .then((result: any) => {
-                    // If the result is already a CommandMessage, use it directly
-                    if (result && typeof result === 'object' && 'topic' in result) {
-                        resolve(result as CommandMessage);
-                    } else {
-                        // Wrap raw result in CommandMessage
-                        const response: CommandMessage = {
-                            transaction_id: 0,
-                            timecode: Date.now(),
-                            topic: topic,
-                            message_type: MessageType.Response,
-                            data: result,
-                            success: true,
-                            error_message: ''
-                        };
-                        resolve(response);
-                    }
-                })
-                .catch((error: any) => {
-                    // Wrap error in CommandMessage
-                    const response: CommandMessage = {
-                        transaction_id: 0,
-                        timecode: Date.now(),
-                        topic: topic,
-                        message_type: MessageType.Response,
-                        data: null,
-                        success: false,
-                        error_message: error?.toString() || 'Unknown error'
-                    };
-                    reject(response);
-                });
-        });
-    }
-}
+/*
+ * Copyright (C) 2023 Automated Design Corp. All Rights Reserved.
+ * Created Date: 2023-12-17 09:50:23
+ * Author: Thomas C. Bitsky Jr.
+ * -----
+ * Last Modified: 2026-01-29 09:34:21
+ * Modified By: ADC
+ * -----
+ *
+ */
+
+import { HubBase } from './HubBase';
+import { invoke as tauriInvoke } from '@tauri-apps/api/core';
+import { listen } from '@tauri-apps/api/event';
+import type { CommandMessage } from "./CommandMessage";
+import { MessageType } from "./CommandMessage";
+
+type InvokeArgs = Record<string, unknown>;
+
+/**
+ * Hub for integrating with the Tauri backend.
+ *
+ * The Tauri backend is expected to broadcast messages on the event
+ * name: 'autocore://broadcast_event'
+ *
+ * This hub will capture those messages and dispatch them globally to any
+ * listeners in the web app.
+ *
+ * ## Usage Examples
+ *
+ * ```typescript
+ * const { hub } = useContext(EventEmitterContext);
+ *
+ * // Read a value
+ * const result = await hub.read("ads.plc1.gio.bControlPowerOk");
+ *
+ * // Write a value
+ * await hub.write("ads.plc1.gio.nSetpoint", 100);
+ *
+ * // Subscribe to changes
+ * await hub.subscribe("modbus.holding_registers.5");
+ * ```
+ *
+ * The hub can also publish/subscribe to frontend-only events:
+ *
+ * ```typescript
+ * hub.publish("ui/panel-opened", { panelId: "settings" });
+ * ```
+ */
+export class HubTauri extends HubBase {
+
+    /**
+     * Constructor
+     */
+    constructor() {
+        super();
+
+        // Mark as connected since Tauri IPC is always available
+        this.setIsConnected(true);
+
+        /**
+         * Receive broadcasts from the Tauri backend. Data is received as a payload object,
+         * {topic: string, payload: any | null}
+         * From here, we extract into a form HubBase can use, then pass on to the
+         * dispatcher.
+         *
+         * Events without a topic are ignored.
+         */
+        listen('autocore://broadcast_event', (ev: any) => {
+            let objPayload = JSON.parse(ev.payload);
+
+            if (objPayload.topic !== undefined && objPayload.topic !== null) {
+                if (objPayload.payload !== undefined && objPayload.payload !== null) {
+                    this.publish(objPayload.topic, objPayload.payload);
+                }
+                else {
+                    this.publish(objPayload.topic, undefined);
+                }
+            }
+        });
+    }
+
+    /**
+     * Send a message to the Tauri backend.
+     *
+     * The topic and messageType are passed to a generic Tauri command handler
+     * that routes the request appropriately.
+     *
+     * @param topic The FQDN of the resource (e.g., "ads.plc1.gio.bControlPowerOk")
+     * @param messageType The action to perform (Read, Write, Subscribe, etc.)
+     * @param payload Optional data payload (e.g., value to write)
+     * @returns Promise<CommandMessage> The response from the backend
+     */
+    invoke(topic: string, messageType: MessageType, payload?: object): Promise<CommandMessage> {
+        console.log(`HubTauri.invoke: topic=${topic}, type=${MessageType[messageType]}`);
+
+        // Build the command arguments
+        const args: InvokeArgs = {
+            topic: topic,
+            message_type: messageType,
+            ...(payload ?? {})
+        };
+
+        // Call the generic autocore handler in Tauri backend
+        return new Promise((resolve, reject) => {
+            tauriInvoke('autocore_invoke', args)
+                .then((result: any) => {
+                    // If the result is already a CommandMessage, use it directly
+                    if (result && typeof result === 'object' && 'topic' in result) {
+                        resolve(result as CommandMessage);
+                    } else {
+                        // Wrap raw result in CommandMessage
+                        const response: CommandMessage = {
+                            transaction_id: 0,
+                            timecode: Date.now(),
+                            topic: topic,
+                            message_type: MessageType.Response,
+                            data: result,
+                            success: true,
+                            error_message: ''
+                        };
+                        resolve(response);
+                    }
+                })
+                .catch((error: any) => {
+                    // Wrap error in CommandMessage
+                    const response: CommandMessage = {
+                        transaction_id: 0,
+                        timecode: Date.now(),
+                        topic: topic,
+                        message_type: MessageType.Response,
+                        data: null,
+                        success: false,
+                        error_message: error?.toString() || 'Unknown error'
+                    };
+                    reject(response);
+                });
+        });
+    }
+}