@adcops/autocore-react 3.0.40 → 3.1.1

package/src/core/AutoCoreTagTypes.ts

@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2025 Automated Design Corp.. All Rights Reserved.
+ * Created Date: 2025-09-05 07:57:49
+ * -----
+ * Last Modified: 2025-09-10 10:22:18
+ * -----
+ *
+ */
+
+/**
+ * @module core/AutoCoreTagTypes
+ *
+ * Core type system for AutoCore's tag layer:
+ * - Strongly-typed tag values (boolean/number/string/json)
+ * - Optional **scales** for numeric unit conversion (e.g., mm ⇄ in)
+ * - Optional **codecs** to present richer client-side types (Date/Map) while
+ *   keeping pure JSON across the wire (serde_json::Value on the server)
+ */
+
+export type PrimitiveKind = "boolean" | "number" | "string" | "json";
+
+/** Strict JSON value (mirrors serde_json::Value) */
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue =
+  | JsonPrimitive
+  | { [key: string]: JsonValue }
+  | JsonValue[];
+
+/**
+ * Extended client-side value you *may* choose to present in the UI.
+ * Use codecs to round-trip these as pure JSON to the server.
+ */
+export type ExtendedJsonValue = JsonValue | Date | Map<string, JsonValue>;
+
+/**
+ * Map a tag's declared primitive kind to the app-visible type.
+ * - "json" becomes ExtendedJsonValue so UIs can work with Date/Map when desired.
+ */
+export type TagValueOf<K extends PrimitiveKind> =
+  K extends "boolean" ? boolean :
+  K extends "number"  ? number  :
+  K extends "string"  ? string  :
+  ExtendedJsonValue;
+
+/**
+ * Runtime binding for a single tag, as returned by hooks like `useAutoCoreTag`.
+ * - `value` is app-visible (already scaled/decoded)
+ * - `rawValue` is the last **unscaled, un-decoded** controller value received (server JSON)
+ * - `write` expects app-visible value (provider will inverse-scale/encode)
+ * - `tap` is typically for boolean momentaries (provider may pulse true→false)
+ */
+export type TagBinding<T> = Readonly<{
+  /** App-visible value (scaled/decoded). */
+  value: T | undefined;
+  /** Last raw value from the server (pre-scale, pre-codec). */
+  rawValue: unknown | undefined;
+  /** Write a new app-visible value (provider will inverse-scale/encode). */
+  write: (displayValue: T) => Promise<void>;
+  /** Momentary action; typically boolean true→false pulse. */
+  tap: () => Promise<void>;
+  /** True while initial read/bootstrapping is in progress. */
+  isLoading: boolean;
+}>;
+
+/**
+ * Configuration for a named scale group.
+ * Apply by setting `scale: "<name>"` on numeric tags.
+ */
+export interface ScaleConfig {
+  /** Unique name for this scale group (e.g., "position", "load") */
+  name: string;
+  /** Current scale factor — incoming values ×= scale; outgoing values /= scale */
+  scale: number;
+  /** Units/label for display (e.g., "mm", "in", "lbs") */
+  label: string;
+  /** Optional description for debugging/documentation */
+  description?: string;
+  /**
+   * Optional server tag that provides the scale dynamically.
+   * (If used, your provider should subscribe and update `scale` when it changes.)
+   */
+  serverTag?: {
+    domain: string;
+    symbolName: string;
+  };
+}
+
+/**
+ * A codec lets a tag expose a richer client-side type while staying JSON on the wire.
+ * Common examples:
+ * - Date values: ISO string ⇄ Date
+ * - Map-like blobs: object ⇄ Map<string, JsonValue>
+ */
+export type TagCodec<TIn = unknown, TOut extends JsonValue = JsonValue> = {
+  /** raw JSON (from server) → app-visible value */
+  fromServer?: (raw: unknown) => TIn;
+  /** app-visible value → pure JSON (to server) */
+  toServer?: (value: TIn) => TOut;
+};
+
+/**
+ * Tag configuration descriptor used to build a typed spec.
+ *
+ * @typeParam K - Literal tag name (use `as const` on your spec array)
+ * @typeParam T - Primitive kind for type mapping (boolean/number/string/json)
+ */
+export type TagConfig<
+  K extends string = string,
+  T extends PrimitiveKind = PrimitiveKind
+> = {
+  /** Local key used by UI/consumers (unique within your spec) */
+  tagName: K;
+  /** Domain for the symbol (e.g., "ADS", "MEMORYSTORE") */
+  domain: string;
+  /** Server symbol/topic name (as used by your backend invoke API) */
+  symbolName: string;
+  /** Declared primitive kind for typing and DevPanel rendering */
+  valueType: T;
+
+  /** Optional initial **raw** value before first server update */
+  initialValue?: TagValueOf<T>;
+  /** Optional per-tag hook/config options (e.g., cycle time, debounce) */
+  options?: Record<string, unknown>;
+
+  /**
+   * Optional scale group for numeric tags.
+   * If present, provider will:
+   * - Multiply incoming numbers by the group's `scale`
+   * - Divide outgoing numbers by the group's `scale`
+   */
+  scale?: string;
+
+  /**
+   * Optional codec to present richer UI types while keeping JSON on the wire.
+   * Only commonly used with `valueType: "json"`.
+   */
+  codec?: TagCodec;
+};
+
+/** Extract the tag config for a particular tag name `K` from a `Spec` */
+export type ExtractByTag<
+  Spec extends readonly TagConfig[],
+  K
+> = Extract<Spec[number], { tagName: K }>;
+
+/**
+ * Build a strongly-typed map of tagName → app-visible value type.
+ * Use with `as const` specs to preserve literal tag names.
+ */
+export type TagValueMap<Spec extends readonly TagConfig[]> = {
+  [K in Spec[number]["tagName"]]: TagValueOf<ExtractByTag<Spec, K>["valueType"]>;
+};
+
+/**
+ * Helper: binding type for a specific tag name from a spec.
+ */
+export type BindingOf<
+  Spec extends readonly TagConfig[],
+  K extends Spec[number]["tagName"]
+> = TagBinding<TagValueMap<Spec>[K]>;
+
+/**
+ * Enhanced context value with scale management.
+ * Providers should:
+ * - Buffer **raw** values in `rawValues` (pre-scale, pre-codec)
+ * - Populate `values` from `rawValues` using current scales/codecs
+ * - Inverse-scale/encode on write(t) before invoking backend
+ */
+export interface BaseContextValue<VMap extends Record<string, any>> {
+  /** Current app-visible tag values (already scaled/decoded). */
+  values: Partial<VMap>;
+
+  /** Last raw (controller) values, as received (pre-scale, pre-codec). */
+  rawValues: Record<string, unknown>;
+
+  /** Whether initial reads are pending. */
+  isLoading: boolean;
+
+  /**
+   * Write a single tag value (app-visible → provider will inverse-scale/encode).
+   * Strongly typed by tag name when used with a typed Context.
+   */
+  write: <K extends keyof VMap & string>(tagName: K, value: VMap[K]) => Promise<void>;
+
+  /**
+   * Trigger a momentary/toggle action for a tag.
+   * Typically used for boolean "request" bits.
+   */
+  tap: <K extends keyof VMap & string>(tagName: K) => Promise<void>;
+
+  /** Current scale configurations by name. */
+  scales: Record<string, ScaleConfig>;
+
+  /**
+   * Update a scale group (factor and label). Providers should recompute affected tags from **raw**.
+   *
+   * @param scaleName - Name of the scale group (e.g., "position")
+   * @param newScale  - New scale factor (display = raw * newScale)
+   * @param newLabel  - New units label (e.g., "inches")
+   */
+  updateScale: (scaleName: string, newScale: number, newLabel: string) => Promise<void>;
+}

package/src/core/EventEmitterContext.tsx

@@ -2,23 +2,316 @@
  * Copyright (C) 2024 Automated Design Corp. All Rights Reserved.
  * Created Date: 2024-01-17 11:45:10
  * -----
- * Last Modified: 2025-08-30 06:54:17
+ * Last Modified: 2025-09-06 14:08:30
  * Modified By: ADC
  * -----
  *
  */
 
+/**
+ * @fileoverview EventEmitterContext - Global Event Bus for AutoCore React Applications
+ * 
+ * The EventEmitterContext provides a comprehensive event-driven communication system for React applications,
+ * enabling seamless interaction between components and backend services. It serves as the foundational layer
+ * for AutoCore's real-time data flow and component communication architecture.
+ * 
+ * ## 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
+ * 
+ * ## 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
+ * 
+ * ## Basic Usage
+ * 
+ * ### 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);
+ * ```
+ * 
+ * @module core/EventEmitterContext
+ * @version 3.0.41
+ * @author Automated Design Corp.
+ * @since 1.0.0
+ */
+
 import React, {
   createContext,
-  ReactNode,
   useState,
   useMemo,
   useCallback,
   useRef,
   useEffect,
 } from "react";
+
+import type {ReactNode} from "react";
 import { createHub, Hub } from "../hub";
-import { CommandMessageResult } from "../hub/CommandMessage";
+import type { CommandMessageResult } from "../hub/CommandMessage";
 
 export { Hub };
 
@@ -150,8 +443,6 @@ export interface EventEmitterContextType {
   isConnected: () => boolean;
 }
 
-let globalSubscriptionId = 1;
-
 /**
  * A global context for managing event emission and subscription.
  *
@@ -349,19 +640,28 @@ export const EventEmitterProvider: React.FC<{ children: ReactNode }> = ({
   // Memoize the hub instance so it's only created once
   const hub = useMemo(() => createHub(), []);
 
-  // <-- New: the source of truth for subscriptions lives in a ref
+  // Use ref for subscription ID management (avoids global state issues)
+  const nextIdRef = useRef(1);
+
+  // Subscription storage - this is the single source of truth
   const subsRef = useRef<Record<string, Subscription[]>>({});
 
-  // Keep the ref in sync for debugging / external reads
+  // Sync state with ref for debugging/inspection purposes only
   useEffect(() => {
-    subsRef.current = state.subscriptions;
-  }, [state.subscriptions]);
+    setState(prev => ({
+      ...prev,
+      subscriptions: { ...subsRef.current },
+      nextSubscriptionId: nextIdRef.current
+    }));
+  }, []);
 
   const dispatch = useCallback((action: Action) => {
     const { topic, payload } = action;
 
-    // Read once, outside setState, so it can't be double-invoked by StrictMode
+    // Read from ref (single source of truth) and create a defensive copy
     const listeners = subsRef.current[topic]?.slice() ?? [];
+    
+    // Execute callbacks synchronously to avoid timing issues
     for (const sub of listeners) {
       try {
         sub.callback(payload);
@@ -370,24 +670,31 @@ export const EventEmitterProvider: React.FC<{ children: ReactNode }> = ({
       }
     }
 
-    // Optional: keep last payload in state (pure)
+    // Update state for debugging/inspection (optional)
     setState((prev) => ({ ...prev, eventData: payload }));
   }, []);
 
   const subscribe = useCallback(
     (topic: string, callback: React.Dispatch<any>): number => {
-      const id = ++globalSubscriptionId;
-
-      // Mutate ref
-      const prev = subsRef.current[topic] ?? [];
-      const next = [...prev, { id, callback }];
-      subsRef.current[topic] = next;
-
-      // Reflect in state (for debugging/inspection)
-      setState((prevState) => ({
+      const id = nextIdRef.current++;
+      
+      // Create new subscription entry
+      const newSub: Subscription = { id, callback };
+      
+      // Atomically update the ref with a complete new structure
+      const currentSubs = subsRef.current[topic] ?? [];
+      const newSubs = [...currentSubs, newSub];
+      
+      subsRef.current = {
+        ...subsRef.current,
+        [topic]: newSubs
+      };
+
+      // Update state for debugging/inspection
+      setState(prevState => ({
         ...prevState,
-        subscriptions: { ...prevState.subscriptions, [topic]: next },
-        nextSubscriptionId: globalSubscriptionId + 1,
+        subscriptions: { ...subsRef.current },
+        nextSubscriptionId: nextIdRef.current,
       }));
 
       return id;
@@ -396,36 +703,43 @@ export const EventEmitterProvider: React.FC<{ children: ReactNode }> = ({
   );
 
   const unsubscribe = useCallback((subscriptionId: number) => {
-    const map = subsRef.current;
-    for (const t of Object.keys(map)) {
-      const next = map[t].filter((s) => s.id !== subscriptionId);
-      if (next.length) map[t] = next;
-      else delete map[t];
+    // Create a completely new structure to avoid mutation issues
+    const newSubscriptions: Record<string, Subscription[]> = {};
+    
+    for (const [topic, subs] of Object.entries(subsRef.current)) {
+      const filteredSubs = subs.filter(s => s.id !== subscriptionId);
+      if (filteredSubs.length > 0) {
+        newSubscriptions[topic] = filteredSubs;
+      }
+      // If no subscriptions left for this topic, don't include it
     }
+    
+    // Atomically replace the entire structure
+    subsRef.current = newSubscriptions;
+
+    // Update state for debugging/inspection
+    setState(prev => ({ 
+      ...prev, 
+      subscriptions: { ...newSubscriptions }
+    }));
+  }, []);
 
-    setState((prev) => ({ ...prev, subscriptions: { ...map } }));
+  // Clean up on unmount and handle HMR
+  useEffect(() => {
+    return () => {
+      subsRef.current = {};
+      nextIdRef.current = 1;
+    };
   }, []);
 
-  // (Nice-to-have) Handle HMR so listeners don’t leak across hot updates
+  // Handle HMR so listeners don't leak across hot updates
   if (import.meta && (import.meta as any).hot) {
     (import.meta as any).hot.dispose(() => {
       subsRef.current = {};
+      nextIdRef.current = 1;
     });
   }
 
-//   const getSubscriptions = useCallback(
-//     (topic?: string): Record<string, Subscription[]> | Subscription[] => {
-//       if (topic) {
-//         // Return subscriptions for the provided topic, or an empty array if the topic doesn't exist
-//         return state.subscriptions[topic] || [];
-//       } else {
-//         // Return all subscriptions
-//         return state.subscriptions;
-//       }
-//     },
-//     []
-//   );
-
   // Provide the memoized hub instance in the context value
   const contextValue = useMemo(
     () => ({
@@ -449,4 +763,4 @@ export const EventEmitterProvider: React.FC<{ children: ReactNode }> = ({
       {children}
     </EventEmitterContext.Provider>
   );
-};
+};

package/src/core/ValueSimulator.ts

@@ -3,13 +3,13 @@
  * Created Date: 2024-01-18 12:49:58
  * Author: Thomas C. Bitsky Jr.
  * -----
- * Last Modified: 2024-03-08 09:33:45
+ * Last Modified: 2025-09-05 14:50:12
  * Modified By: ADC
  * -----
  * 
  */
 
-import { EmitterDispatchFunction } from "./EventEmitterContext";
+import type { EmitterDispatchFunction } from "./EventEmitterContext";
 
 
 /**