@adcops/autocore-react 3.1.1 → 3.3.5

package/dist/core/EventEmitterContext.d.ts

@@ -7,521 +7,164 @@
  *
  * ## Core Features
  *
- * - **Global Event Bus**: Publish and subscribe to events across all components
- * - **Backend Integration**: Direct communication with AutoCore server via Hub abstraction
- * - **Type-Safe Subscriptions**: Strongly-typed event handling with automatic cleanup
- * - **Connection Management**: Automatic reconnection and state synchronization
- * - **Development Tools**: Built-in debugging and subscription introspection
+ * - **Global Event Bus**: Publish and subscribe to events across all components.
+ * - **Backend Integration**: Direct communication with AutoCore server via Hub abstraction.
+ * - **Type-Safe Subscriptions**: Strongly-typed event handling with automatic cleanup.
+ * - **Performance Optimized**: Uses stable context values and direct callbacks to avoid global re-renders.
+ * - **Connection Management**: Automatic reconnection and state synchronization.
  *
  * ## Architecture
  *
  * The system consists of three main components:
- * 1. **EventEmitterProvider**: React context provider that manages global state
- * 2. **Hub**: Abstraction layer for backend communication (WebSocket, HTTP, etc.)
- * 3. **Subscription Manager**: Handles event routing and lifecycle management
+ * 1. **EventEmitterProvider**: React context provider that manages global state and event routing.
+ * 2. **Hub**: Abstraction layer for backend communication (WebSocket, HTTP, etc.).
+ * 3. **Subscription Manager**: Handles event routing and lifecycle management.
  *
- * ## Basic Usage
+ * ## Performance Notes
  *
- * ### 1. Application Setup
- *
- * Wrap your entire application with the EventEmitterProvider:
- *
- * ```tsx
- * // App.tsx
- * import React from 'react';
- * import { EventEmitterProvider } from '@adcops/autocore-react/core/EventEmitterContext';
- * import { PrimeReactProvider } from 'primereact/api';
- * import { MainView } from './MainView';
- *
- * export default function App() {
- *   return (
- *     <EventEmitterProvider>
- *       <PrimeReactProvider>
- *         <MainView />
- *       </PrimeReactProvider>
- *     </EventEmitterProvider>
- *   );
- * }
- * ```
- *
- * ### 2. Component Communication
- *
- * Use the context for inter-component communication:
- *
- * ```tsx
- * // PublisherComponent.tsx
- * import React, { useContext } from 'react';
- * import { EventEmitterContext } from '@adcops/autocore-react/core/EventEmitterContext';
- * import { Button } from 'primereact/button';
- *
- * export const PublisherComponent: React.FC = () => {
- *   const { dispatch } = useContext(EventEmitterContext);
- *
- *   const handleButtonClick = () => {
- *     dispatch({
- *       topic: 'user-action/button-clicked',
- *       payload: { timestamp: Date.now(), buttonId: 'main-action' }
- *     });
- *   };
- *
- *   return <Button label="Trigger Event" onClick={handleButtonClick} />;
- * };
- *
- * // SubscriberComponent.tsx
- * import React, { useContext, useEffect, useState } from 'react';
- * import { EventEmitterContext } from '@adcops/autocore-react/core/EventEmitterContext';
- *
- * export const SubscriberComponent: React.FC = () => {
- *   const { subscribe, unsubscribe } = useContext(EventEmitterContext);
- *   const [lastAction, setLastAction] = useState<any>(null);
- *
- *   useEffect(() => {
- *     const subscriptionId = subscribe('user-action/button-clicked', (payload) => {
- *       setLastAction(payload);
- *       console.log('Button clicked at:', payload.timestamp);
- *     });
- *
- *     return () => unsubscribe(subscriptionId);
- *   }, [subscribe, unsubscribe]);
- *
- *   return (
- *     <div>
- *       {lastAction && (
- *         <p>Last action: {new Date(lastAction.timestamp).toLocaleTimeString()}</p>
- *       )}
- *     </div>
- *   );
- * };
- * ```
- *
- * ### 3. Backend Integration
- *
- * Communicate with AutoCore server through the integrated Hub:
- *
- * ```tsx
- * // ControlPanel.tsx
- * import React, { useContext, useEffect, useState } from 'react';
- * import { EventEmitterContext } from '@adcops/autocore-react/core/EventEmitterContext';
- * import { Button } from 'primereact/button';
- * import { InputNumber } from 'primereact/inputnumber';
- *
- * export const ControlPanel: React.FC = () => {
- *   const { invoke, subscribe, unsubscribe, isConnected } = useContext(EventEmitterContext);
- *   const [motorSpeed, setMotorSpeed] = useState<number>(0);
- *   const [targetSpeed, setTargetSpeed] = useState<number>(100);
- *   const [connected, setConnected] = useState<boolean>(false);
- *
- *   // Monitor connection status
- *   useEffect(() => {
- *     setConnected(isConnected());
- *
- *     const connectionSub = subscribe('HUB/connected', () => setConnected(true));
- *     const disconnectionSub = subscribe('HUB/disconnected', () => setConnected(false));
- *
- *     return () => {
- *       unsubscribe(connectionSub);
- *       unsubscribe(disconnectionSub);
- *     };
- *   }, [subscribe, unsubscribe, isConnected]);
- *
- *   // Subscribe to real-time motor speed updates
- *   useEffect(() => {
- *     const speedSub = subscribe('ADS/MAIN.motor.speed', (data) => {
- *       setMotorSpeed(data.value);
- *     });
- *
- *     return () => unsubscribe(speedSub);
- *   }, [subscribe, unsubscribe]);
- *
- *   // Send commands to backend
- *   const handleSpeedChange = async () => {
- *     try {
- *       const result = await invoke('ADS', 'write_value', {
- *         symbol_name: 'MAIN.motor.setpoint',
- *         value: targetSpeed
- *       });
- *
- *       if (!result.success) {
- *         console.error('Failed to set motor speed:', result.error_message);
- *       }
- *     } catch (error) {
- *       console.error('Communication error:', error);
- *     }
- *   };
- *
- *   const handleEmergencyStop = async () => {
- *     try {
- *       await invoke('ADS', 'emergency_stop', {});
- *     } catch (error) {
- *       console.error('Emergency stop failed:', error);
- *     }
- *   };
- *
- *   return (
- *     <div className="control-panel">
- *       <div className="status">
- *         Connection: {connected ? '🟢 Connected' : '🔴 Disconnected'}
- *       </div>
- *
- *       <div className="motor-control">
- *         <p>Current Speed: {motorSpeed} RPM</p>
- *
- *         <InputNumber
- *           value={targetSpeed}
- *           onValueChange={(e) => setTargetSpeed(e.value || 0)}
- *           min={0}
- *           max={1000}
- *           suffix=" RPM"
- *         />
- *
- *         <Button
- *           label="Set Speed"
- *           onClick={handleSpeedChange}
- *           disabled={!connected}
- *         />
- *
- *         <Button
- *           label="Emergency Stop"
- *           onClick={handleEmergencyStop}
- *           severity="danger"
- *           disabled={!connected}
- *         />
- *       </div>
- *     </div>
- *   );
- * };
- * ```
- *
- * ### 4. Advanced Pattern: State Management Hook
- *
- * Create reusable hooks for common patterns:
- *
- * ```tsx
- * // hooks/useRealtimeValue.ts
- * import { useContext, useEffect, useState } from 'react';
- * import { EventEmitterContext } from '@adcops/autocore-react/core/EventEmitterContext';
- *
- * export function useRealtimeValue<T>(topic: string, initialValue?: T) {
- *   const { subscribe, unsubscribe } = useContext(EventEmitterContext);
- *   const [value, setValue] = useState<T | undefined>(initialValue);
- *   const [lastUpdate, setLastUpdate] = useState<Date | null>(null);
- *
- *   useEffect(() => {
- *     const subscriptionId = subscribe(topic, (data) => {
- *       setValue(data.value);
- *       setLastUpdate(new Date());
- *     });
- *
- *     return () => unsubscribe(subscriptionId);
- *   }, [topic, subscribe, unsubscribe]);
- *
- *   return { value, lastUpdate };
- * }
- *
- * // Usage in component
- * export const SensorDisplay: React.FC = () => {
- *   const { value: temperature } = useRealtimeValue<number>('ADS/sensors.temperature');
- *   const { value: pressure } = useRealtimeValue<number>('ADS/sensors.pressure');
- *
- *   return (
- *     <div>
- *       <p>Temperature: {temperature?.toFixed(1)}°C</p>
- *       <p>Pressure: {pressure?.toFixed(2)} bar</p>
- *     </div>
- *   );
- * };
- * ```
- *
- * ## Integration with AutoCore Systems
- *
- * The EventEmitterContext is designed to work seamlessly with other AutoCore React components:
- *
- * ```tsx
- * // Complete AutoCore application setup
- * import React from 'react';
- * import { EventEmitterProvider } from '@adcops/autocore-react/core/EventEmitterContext';
- * import { AutoCoreTagProvider } from '@adcops/autocore-react/core/AutoCoreTagContext';
- * import { PrimeReactProvider } from 'primereact/api';
- * import { tagSpec } from './config/tags';
- * import { MainInterface } from './components/MainInterface';
- *
- * export default function App() {
- *   return (
- *     <EventEmitterProvider>
- *       <AutoCoreTagProvider tags={tagSpec} eagerRead>
- *         <PrimeReactProvider>
- *           <MainInterface />
- *         </PrimeReactProvider>
- *       </AutoCoreTagProvider>
- *     </EventEmitterProvider>
- *   );
- * }
- * ```
- *
- * ## Best Practices
- *
- * 1. **Always Cleanup Subscriptions**: Use the cleanup function returned by useEffect
- * 2. **Use Meaningful Topic Names**: Follow a hierarchical naming convention (e.g., 'domain/category/specific')
- * 3. **Handle Connection States**: Always check connection status before invoking backend functions
- * 4. **Error Handling**: Wrap invoke calls in try-catch blocks
- * 5. **Type Safety**: Use TypeScript interfaces for payload structures
- * 6. **Performance**: Avoid subscribing to high-frequency events in render-heavy components
- *
- * ## Debugging
- *
- * Use the built-in debugging features:
- *
- * ```tsx
- * const { getSubscriptions, state } = useContext(EventEmitterContext);
- *
- * // View all subscriptions
- * console.log('All subscriptions:', getSubscriptions());
- *
- * // View subscriptions for specific topic
- * console.log('Motor subscriptions:', getSubscriptions('ADS/MAIN.motor.speed'));
- *
- * // View current state
- * console.log('EventEmitter state:', state);
- * ```
+ * To ensure high performance with high-frequency data (e.g., 50Hz sensor updates):
+ * 1. **No State Updates on Dispatch**: The `dispatch` function does NOT update React state. It calls listeners directly.
+ *    This prevents the entire component tree from re-rendering on every message.
+ * 2. **Stable Context Value**: The `contextValue` object is memoized and rarely changes.
+ * 3. **Direct Subscriptions**: Components subscribe via `useEffect` and receive updates via callbacks, not props.
  *
  * @module core/EventEmitterContext
- * @version 3.0.41
+ * @version 3.0.42
  * @author Automated Design Corp.
- * @since 1.0.0
  */
 import React from "react";
 import type { ReactNode } from "react";
 import { Hub } from "../hub";
-import type { CommandMessageResult } from "../hub/CommandMessage";
+import type { CommandMessage } from "../hub";
+import { MessageType } from "../hub/CommandMessage";
 export { Hub };
 /**
- * Represents an event subsription.
+ * Represents an active event subscription.
  */
 export interface Subscription {
-    /** ID of the subscription used for unsubscription. */
+    /** Unique ID of the subscription used for unsubscription. */
     id: number;
-    /** Callback function. */
+    /** Callback function to execute when the event fires. */
     callback: React.Dispatch<any>;
 }
 /**
- * Represents the payload data associated with an event.
+ * Represents the internal state of the EventEmitter.
+ * Mostly used for debugging and dev tools inspection.
  */
 export interface State {
     /**
-     * The optional data payload of the event.
+     * The optional data payload of the last event (DEBUGGING ONLY).
+     * Note: This is no longer updated in production for performance reasons.
      */
     eventData?: any;
-    /** Callback subscription. A list of callback subscriptions matched to a topic. */
+    /** Active subscriptions grouped by topic. */
     subscriptions: Record<string, Subscription[]>;
     /** Tracks the next subscription ID that will be assigned. */
     nextSubscriptionId: number;
 }
 /**
- * An action event published by the EventEmitterContext. Contains
- * the topic identifying the event and the optional payload, which is
- * a value of any type.
+ * An action event published by the EventEmitterContext.
  */
 export interface Action {
-    /**
-     * The topic or identifier of the event.
-     */
+    /** The topic or identifier of the event. */
     topic: string;
-    /**
-     * The optional data payload associated with the event.
-     */
+    /** The optional data payload associated with the event. */
     payload?: any;
 }
-/**
- * Type declaration for the EventEmitter dispatch function, which
- * publishes an Action globally throughout the EventEmitterContext.
- */
 export type EmitterDispatchFunction = (action: Action) => void;
 /**
- * Type declaration for the EventEmitter dispatch function, which
- * receives an Action on a specific topic broadcast through the EventEmitterContext.
- */
-export type EmitterSubscribeFunction = (action: Action) => void;
-/**
- * Type declaration for the EventEmitter unsubscribe function, which
- * receives an Action on a specific topic broadcast through the EventEmitterContext.
- */
-export type EmitterUnsubscribeFunction = (action: Action) => void;
-/**
- * Defines the context for an event emitter used throughout a front-end application to manage and dispatch events.
- * This interface includes methods for managing the application's state, handling global actions, communicating with the back end,
- * subscribing to and unsubscribing from events, and accessing a global hub for event publishing and subscription management.
- * It serves as a central point for event-driven interactions within the application, facilitating communication between
- * components and the back end, as well as among components themselves.
+ * Defines the context for the global event emitter.
+ * Provides methods for dispatching events, subscribing to topics, and communicating with the backend.
  */
 export interface EventEmitterContextType {
     /**
-     * The current state of the event emitter, containing the latest event data.
+     * The current state of the event emitter (mostly for debugging).
      */
     state: State;
     /**
-     * A function to dispatch actions globally throughout the front-end,
-     * triggering state updates and events.
+     * Dispatch an action globally throughout the front-end.
+     * Triggers callbacks for all subscribers of the topic.
+     *
+     * @param action The action to dispatch.
+     */
+    dispatch: EmitterDispatchFunction;
+    /**
+     * Send a message to the backend (Low-level).
+     *
+     * @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
+     * @returns Promise resolving to the CommandMessage response
+     */
+    invoke(topic: string, messageType: MessageType, payload?: object): Promise<CommandMessage>;
+    /**
+     * Read a value from the backend.
+     *
+     * @param topic The FQDN of the resource to read
+     * @param payload Optional additional parameters
+     * @returns Promise resolving to the CommandMessage response with the value in `data`
+     */
+    read(topic: string, payload?: object): Promise<CommandMessage>;
+    /**
+     * Write a value to the backend.
      *
-     * @param action The action to dispatch, containing topic and optional payload.
+     * @param topic The FQDN of the resource to write
+     * @param value The value to write
+     * @returns Promise resolving to the CommandMessage response
      */
-    dispatch: (action: Action) => void;
+    write(topic: string, value: any): Promise<CommandMessage>;
     /**
-     * Invoke/send a message to the back end.
-     * This does NOT get published to the front end.
+     * Subscribe to value changes on the backend.
+     *
+     * Tells the server to start broadcasting updates for a specific topic.
+     * Also registers a mapping between the local `tagName` and the remote `topic` (FQDN)
+     * in the Hub, so that incoming broadcasts are routed correctly.
+     *
+     * @param tagName The local tag name to map the topic to
+     * @param topic The FQDN of the resource to watch
+     * @param payload Optional subscription parameters (e.g., update rate)
+     * @returns Promise resolving to the CommandMessage response
      */
-    invoke(domain: string, fname: string, payload?: object): Promise<CommandMessageResult>;
+    serverSubscribe(tagName: string, topic: string, payload?: object): Promise<CommandMessage>;
     /**
-     * Subscribe to events identified by the topic.
-     * @param topic The subscription topic.
+     * Unsubscribe from value changes on the backend.
+     *
+     * @param tagName The local tag name to stop watching
+     * @param payload Optional parameters
+     * @returns Promise resolving to the CommandMessage response
+     */
+    serverUnsubscribe(tagName: string, payload?: object): Promise<CommandMessage>;
+    /**
+     * Subscribe to **local** frontend events.
+     *
+     * This registers a callback to listen for events dispatched on the local event bus.
+     * This includes both locally dispatched events AND broadcast messages received
+     * from the server (which the Hub dispatches to the local bus).
+     *
+     * @param topic The subscription topic (or tagName).
      * @param callback The callback to signal.
      * @returns number Subscription ID used to unsubscribe later.
      */
     subscribe: (topic: string, callback: React.Dispatch<any>) => number;
     /**
-     * Unsubscribe to events.
-     * @param subscriptionId The id of the subscription returned by the subscribe method.
-     * @returns
+     * Unsubscribe from **local** frontend events.
+     *
+     * @param subscriptionId The id returned by the subscribe method.
      */
     unsubscribe: (subscriptionId: number) => void;
     /**
-     * Global hub for publishing and receiving events throughout the interface, and for exchanging
-     * data with the backend.
+     * Global hub instance for backend communication.
      */
     hub: Hub | null;
     /**
      * Retrieves the current subscriptions. Used for debugging purposes.
-     * @param topic Optional. The topic to retrieve subscriptions for. If omitted, returns all subscriptions.
-     * @returns An object containing the current subscriptions, optionally filtered by topic.
      */
     getSubscriptions: (topic?: string) => Record<string, Subscription[]> | Subscription[];
     /**
-     * Returns true if the Hub in use is connected to its source.
-     * @returns boolean
+     * Returns true if the Hub is connected to the backend.
      */
     isConnected: () => boolean;
 }
-/**
- * A global context for managing event emission and subscription.
- *
- * Creates a React context for the EventEmitter system, providing a structured way to manage events and data flow
- * in a React application. It serves as a global event bus that components can subscribe to or emit events, allowing for
- * a loosely coupled architecture. Additionally, it provides a mechanism for invoking backend functions and managing
- * subscriptions, making it easier to integrate React components with backend services.
- *
- * The context includes several key functionalities:
- * - `state`: Maintains the current state of subscriptions and their identifiers.
- * - `dispatch`: Allows components to emit events with specific topics and payloads, which can be listened to by other components.
- * - `subscribe`: Enables components to listen to specific topics and react to those events by providing a callback function.
- * - `unsubscribe`: Provides a way for components to stop listening to events, helping prevent memory leaks and unnecessary updates.
- * - `invoke`: Facilitates calling backend functions with specific arguments and handling their responses asynchronously.
- * - `getSubscriptions`: Offers insight into current active subscriptions, useful for debugging purposes.
- *
- * This context is essential for applications that require a high degree of inter-component communication or need to
- * interact with a backend efficiently.
- *
- * For more information, see [Additional Documentation](../additional-docs/GlobalEventEmitter.md).
- *
- * ## Usage
- *
- * The entire application should be wrapped in the EventEmitterProvider.
- *
- * App.tsx
- * ```
- * import { EventEmitterProvider } from "@adcops/autocore-react/core/EventEmitterContext.js";
- * function App() {
- *
- *      return(
- *          <EventEmitterProvider>
- *              <PrimeReactProvider>
- *                  <main>
- *                      <section>
- *                          <ContentView />
- *                      </section>
- *                  </main>
- *              </PrimeReactProvider>
- *          </EventEmitterProvider>
- *      );
- *
- * }
- *
- * ```
- *
- * ### Catching and receiving events
- * The EventEmitterContext creates an appropriate instance of the hub, which is derived from HubBase.
- * That hub can be used to publish and subscribe to
- * topics globally in the front-end, regardless of being connected to any backend.
- * Usage within a component is simple.
- *
- * ```
- * const {dispatch, subscribe, unsubscribe} = useContext(EventEmitterContext);
- * const [controlPower, setControlPower] = useState(false);
- * useEffect(() => {
- *      const unsubscribeControlPower = subscribe('value-simulator-bBit1', (value) => {
- *          setControlPower(value);
- *      });
- *
- *
- *      return () => {
- *           unsubscribe(unsubscribeControlPower);
- *      }
- * }, [] );
- *
- * const onPbPressed = () => {
- *      let count = 1;
- *      dispatch({
- *          topic: "my-awesome-topic",
- *          payload: count
- *      });
- * }
- *
- * ```
- * The hub should also be used for invoking events in the backend.
- * This example will call the function "update_count" in the backend, passing
- * the expected argument "count". Details of the interaction between the Hub and
- * the backend will be handled by the appropriate HubBase sub-class, and should
- * be transparent to the front end.
- *
- * ```
- * const {invoke} = useContext(EventEmitterContext);
- * const incrementCount = () => {
- *    count += 1;
- *    invoke('update_count', {"count": count});
- * };
- *
- * Subscribing to a topic is simple. The type of value received is specific
- * to the topic.
- *
- * Example: Listen to an event 'xarm-position':
- * ```
- * const {subscribe, unsubscribe} = useContext(EventEmitterContext);
- * useEffect(() => {
- *         const unsubscripeMp = subscribe('xarm-position', (value) => {
- *            // The publisher sent a JSON object of 3D position values.
- *            setX(value.x);
- *            setY(value.y);
- *            setZ(value.z);
- *            setA(value.roll);
- *            setB(value.yaw);
- *            setC(value.pitch);
- *        });
- *
- *    return () => {
- *        unsubscribe(unsubscripeMp);
- *    }
- *
- * }, [] );
- *
- * ```
- *
- * For applications that need to access the instance of the hub, get the current instance
- * from the EventEmitterContext:
- *
- * ```
- * const {hub} = useContext(EventEmitterContext);
- *  * ```
- *
- *
- */
 export declare const EventEmitterContext: React.Context<EventEmitterContextType>;
 /**
  * A React component that provides the EventEmitterContext to its children.
@@ -530,31 +173,6 @@ export declare const EventEmitterContext: React.Context<EventEmitterContextType>
  * with the event emitter.
  *
  * @param children The child components to be wrapped in the context.
- *
- * ## Usage
- *
- * The entire application should be wrapped in the EventEmitterProvider.
- *
- * App.tsx
- * ```
- * import { EventEmitterProvider } from "@adcops/autocore-react/core/EventEmitterContext.js";
- * function App() {
- *
- *      return(
- *          <EventEmitterProvider>
- *              <PrimeReactProvider>
- *                  <main>
- *                      <section>
- *                          <ContentView />
- *                      </section>
- *                  </main>
- *              </PrimeReactProvider>
- *          </EventEmitterProvider>
- *      );
- *
- * }
- *
- * ```
  */
 export declare const EventEmitterProvider: React.FC<{
     children: ReactNode;

package/dist/core/EventEmitterContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventEmitterContext.d.ts","sourceRoot":"","sources":["../../src/core/EventEmitterContext.tsx"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkSG;AAEH,OAAO,KAON,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AACrC,OAAO,EAAa,GAAG,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,GAAG,EAAE,CAAC;AAEf;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,kFAAkF;IAClF,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAE9C,6DAA6D;IAC7D,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEnC;;;OAGG;IACH,MAAM,CACJ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEjC;;;;;OAKG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC;IAEpE;;;;OAIG;IACH,WAAW,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C;;;OAGG;IACH,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAEhB;;;;OAIG;IACH,gBAAgB,EAAE,CAChB,KAAK,CAAC,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC;IAErD;;;OAGG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyHG;AACH,eAAO,MAAM,mBAAmB,wCA6B9B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,CAsIlE,CAAC"}
+{"version":3,"file":"EventEmitterContext.d.ts","sourceRoot":"","sources":["../../src/core/EventEmitterContext.tsx"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAON,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,OAAO,CAAC;AACrC,OAAO,EAAa,GAAG,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,GAAG,EAAE,CAAC;AAEf;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,KAAK;IACpB;;;OAGG;IACH,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAE9C,6DAA6D;IAC7D,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED,MAAM,MAAM,uBAAuB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;OAKG;IACH,QAAQ,EAAE,uBAAuB,CAAC;IAElC;;;;;;;OAOG;IACH,MAAM,CACJ,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CAAC;IAE3B;;;;;;OAMG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAE/D;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAE1D;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAE3F;;;;;;OAMG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAE9E;;;;;;;;;;OAUG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,MAAM,CAAC;IAEpE;;;;OAIG;IACH,WAAW,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C;;OAEG;IACH,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAEhB;;OAEG;IACH,gBAAgB,EAAE,CAChB,KAAK,CAAC,EAAE,MAAM,KACX,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC;IAErD;;OAEG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B;AAaD,eAAO,MAAM,mBAAmB,wCAa9B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,CAsLlE,CAAC"}

package/dist/core/EventEmitterContext.js

@@ -1 +1 @@
-import{jsx as _jsx}from"react/jsx-runtime";import React,{createContext,useState,useMemo,useCallback,useRef,useEffect}from"react";import{createHub,Hub}from"../hub";export{Hub};export const EventEmitterContext=createContext({state:{subscriptions:{},nextSubscriptionId:1},dispatch:()=>{},subscribe:()=>0,invoke:async(e,t,r)=>Promise.resolve({data:{},success:!1,error_message:""}),unsubscribe:e=>{},hub:null,getSubscriptions:()=>[],isConnected:()=>!1});export const EventEmitterProvider=({children:e})=>{const[t,r]=useState({subscriptions:{},nextSubscriptionId:1}),s=useMemo(()=>createHub(),[]),c=useRef(1),n=useRef({});useEffect(()=>{r(e=>({...e,subscriptions:{...n.current},nextSubscriptionId:c.current}))},[]);const o=useCallback(e=>{const{topic:t,payload:s}=e,c=n.current[t]?.slice()??[];for(const e of c)try{e.callback(s)}catch(e){}r(e=>({...e,eventData:s}))},[]),u=useCallback((e,t)=>{const s=c.current++,o={id:s,callback:t},u=[...n.current[e]??[],o];return n.current={...n.current,[e]:u},r(e=>({...e,subscriptions:{...n.current},nextSubscriptionId:c.current})),s},[]),i=useCallback(e=>{const t={};for(const[r,s]of Object.entries(n.current)){const c=s.filter(t=>t.id!==e);c.length>0&&(t[r]=c)}n.current=t,r(e=>({...e,subscriptions:{...t}}))},[]);useEffect(()=>()=>{n.current={},c.current=1},[]),import.meta&&import.meta.hot&&import.meta.hot.dispose(()=>{n.current={},c.current=1});const a=useMemo(()=>({state:t,dispatch:o,subscribe:u,unsubscribe:i,invoke:s.invoke,hub:s,getSubscriptions:e=>e?n.current[e]??[]:n.current,isConnected:s.isConnected}),[t,s,o,u,i]);return s.setContext(a),_jsx(EventEmitterContext.Provider,{value:a,children:e})};
+import{jsx as _jsx}from"react/jsx-runtime";import React,{createContext,useState,useMemo,useCallback,useRef,useEffect}from"react";import{createHub,Hub}from"../hub";import{MessageType}from"../hub/CommandMessage";export{Hub};const placeholderResponse={data:{},success:!1,error_message:"Context not initialized",transaction_id:0,timecode:0,topic:"",message_type:MessageType.NoOp};export const EventEmitterContext=createContext({state:{subscriptions:{},nextSubscriptionId:1},dispatch:()=>{},subscribe:()=>0,unsubscribe:()=>{},invoke:async()=>placeholderResponse,read:async()=>placeholderResponse,write:async()=>placeholderResponse,serverSubscribe:async(e,t,s)=>placeholderResponse,serverUnsubscribe:async(e,t)=>placeholderResponse,hub:null,getSubscriptions:()=>[],isConnected:()=>!1});export const EventEmitterProvider=({children:e})=>{const[t,s]=useState({subscriptions:{},nextSubscriptionId:1}),r=useMemo(()=>createHub(),[]),c=useRef(1),n=useRef({});useEffect(()=>{s(e=>({...e,subscriptions:{...n.current},nextSubscriptionId:c.current}))},[]);const o=useCallback(e=>{const{topic:t,payload:s}=e,r=n.current[t]?.slice()??[];for(const e of r)try{e.callback(s)}catch(e){}},[]),u=useCallback((e,t)=>{const r=c.current++,o={id:r,callback:t},u=[...n.current[e]??[],o];return n.current={...n.current,[e]:u},s(e=>({...e,subscriptions:{...n.current},nextSubscriptionId:c.current})),r},[]),i=useCallback(e=>{const t={};for(const[s,r]of Object.entries(n.current)){const c=r.filter(t=>t.id!==e);c.length>0&&(t[s]=c)}n.current=t,s(e=>({...e,subscriptions:{...t}}))},[]);useEffect(()=>()=>{n.current={},c.current=1},[]),import.meta&&import.meta.hot&&import.meta.hot.dispose(()=>{n.current={},c.current=1});const a=useCallback((e,t,s)=>r.invoke(e,t,s),[r]),b=useCallback((e,t)=>r.read(e,t),[r]),l=useCallback((e,t)=>r.write(e,t),[r]),p=useCallback((e,t,s)=>r.subscribe(e,t,s),[r]),d=useCallback((e,t)=>r.unsubscribe(e,t),[r]),m=useCallback(()=>r.isConnected(),[r]),f=useMemo(()=>({state:t,dispatch:o,subscribe:u,unsubscribe:i,invoke:a,read:b,write:l,serverSubscribe:p,serverUnsubscribe:d,hub:r,getSubscriptions:e=>e?n.current[e]??[]:n.current,isConnected:m}),[t,r,o,u,i,a,b,l,p,d,m]);return useEffect(()=>{r.setContext(f)},[r,f]),_jsx(EventEmitterContext.Provider,{value:f,children:e})};

package/dist/hooks/adsHooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adsHooks.d.ts","sourceRoot":"","sources":["../../src/hooks/adsHooks.tsx"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,qBAAqB,GAC9B,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,EAC7C,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,UAAS,MAAM,CAAC,MAAM,EAAE,EAAE,CAAM,SAuDnC,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,IAMjC,OAAO,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,mBAO1D;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAKnD,MAAM,mBAa1C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CActE"}
+{"version":3,"file":"adsHooks.d.ts","sourceRoot":"","sources":["../../src/hooks/adsHooks.tsx"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,qBAAqB,GAC9B,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,EAC7C,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,UAAS,MAAM,CAAC,MAAM,EAAE,EAAE,CAAM,SAuDnC,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,IAIjC,OAAO,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,mBAQ1D;AAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAGnD,MAAM,mBAc1C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CActE"}