@adcops/autocore-react 3.0.40 → 3.3.2

package/src/hub/debug.ts

@@ -0,0 +1,211 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * Debug Logging Utility for CoreStream/Hub Communication
+ *
+ * This utility provides debug logging that won't be stripped by production builds.
+ * It uses console.warn/console.error which are typically preserved, and stores
+ * logs in a buffer that can be inspected from the browser console.
+ *
+ * Usage in browser console:
+ *   window.__AUTOCORE_DEBUG__.enable()     - Enable debug logging
+ *   window.__AUTOCORE_DEBUG__.disable()    - Disable debug logging
+ *   window.__AUTOCORE_DEBUG__.logs         - View all logged messages
+ *   window.__AUTOCORE_DEBUG__.clear()      - Clear log buffer
+ *   window.__AUTOCORE_DEBUG__.dump()       - Dump all logs to console
+ */
+
+export interface DebugLogEntry {
+  timestamp: number;
+  source: string;
+  level: "info" | "warn" | "error" | "send" | "recv";
+  message: string;
+  data?: unknown;
+}
+
+interface DebugState {
+  enabled: boolean;
+  logs: DebugLogEntry[];
+  maxLogs: number;
+}
+
+// Global state - attached to window for browser console access
+const state: DebugState = {
+  enabled: true, // Start enabled for debugging
+  logs: [],
+  maxLogs: 1000,
+};
+
+// Format timestamp as HH:MM:SS.mmm
+function formatTime(ts: number): string {
+  const d = new Date(ts);
+  return d.toTimeString().slice(0, 8) + "." + String(d.getMilliseconds()).padStart(3, "0");
+}
+
+// Format log entry for console output
+function formatEntry(entry: DebugLogEntry): string {
+  return `[${formatTime(entry.timestamp)}] [${entry.source}] ${entry.message}`;
+}
+
+// Add a log entry
+function addLog(
+  source: string,
+  level: DebugLogEntry["level"],
+  message: string,
+  data?: unknown
+): void {
+  const entry: DebugLogEntry = {
+    timestamp: Date.now(),
+    source,
+    level,
+    message,
+    data,
+  };
+
+  // Add to buffer (with size limit)
+  state.logs.push(entry);
+  if (state.logs.length > state.maxLogs) {
+    state.logs.shift();
+  }
+
+  // Output to console if enabled
+  if (state.enabled) {
+    const formatted = formatEntry(entry);
+    const style = getLogStyle(level);
+
+    switch (level) {
+      case "error":
+        console.error(`%c${formatted}`, style, data !== undefined ? data : "");
+        break;
+      case "warn":
+        console.warn(`%c${formatted}`, style, data !== undefined ? data : "");
+        break;
+      case "send":
+        console.warn(`%c>>> ${formatted}`, style, data !== undefined ? data : "");
+        break;
+      case "recv":
+        console.warn(`%c<<< ${formatted}`, style, data !== undefined ? data : "");
+        break;
+      default:
+        console.warn(`%c${formatted}`, style, data !== undefined ? data : "");
+    }
+  }
+}
+
+// Get console style for log level
+function getLogStyle(level: DebugLogEntry["level"]): string {
+  switch (level) {
+    case "error":
+      return "color: #ff4444; font-weight: bold;";
+    case "warn":
+      return "color: #ffaa00;";
+    case "send":
+      return "color: #44ff44;"; // Green for outgoing
+    case "recv":
+      return "color: #4444ff;"; // Blue for incoming
+    default:
+      return "color: #888888;";
+  }
+}
+
+// Public debug API
+export const debug = {
+  /** Log an info message */
+  info(source: string, message: string, data?: unknown): void {
+    addLog(source, "info", message, data);
+  },
+
+  /** Log a warning message */
+  warn(source: string, message: string, data?: unknown): void {
+    addLog(source, "warn", message, data);
+  },
+
+  /** Log an error message */
+  error(source: string, message: string, data?: unknown): void {
+    addLog(source, "error", message, data);
+  },
+
+  /** Log an outgoing message (to server) */
+  send(source: string, message: string, data?: unknown): void {
+    addLog(source, "send", message, data);
+  },
+
+  /** Log an incoming message (from server) */
+  recv(source: string, message: string, data?: unknown): void {
+    addLog(source, "recv", message, data);
+  },
+
+  /** Check if debug is enabled */
+  isEnabled(): boolean {
+    return state.enabled;
+  },
+};
+
+// Browser console API
+const consoleAPI = {
+  enable(): void {
+    state.enabled = true;
+    console.warn("%c[AutoCore Debug] Logging ENABLED", "color: #44ff44; font-weight: bold;");
+  },
+
+  disable(): void {
+    state.enabled = false;
+    console.warn("%c[AutoCore Debug] Logging DISABLED", "color: #ff4444; font-weight: bold;");
+  },
+
+  get logs(): DebugLogEntry[] {
+    return [...state.logs];
+  },
+
+  clear(): void {
+    state.logs = [];
+    console.warn("%c[AutoCore Debug] Logs cleared", "color: #ffaa00;");
+  },
+
+  dump(): void {
+    console.group("[AutoCore Debug] Full Log Dump");
+    for (const entry of state.logs) {
+      const formatted = formatEntry(entry);
+      switch (entry.level) {
+        case "send":
+          console.log(`%c>>> ${formatted}`, "color: #44ff44;", entry.data);
+          break;
+        case "recv":
+          console.log(`%c<<< ${formatted}`, "color: #4444ff;", entry.data);
+          break;
+        case "error":
+          console.log(`%c${formatted}`, "color: #ff4444;", entry.data);
+          break;
+        default:
+          console.log(formatted, entry.data);
+      }
+    }
+    console.groupEnd();
+  },
+
+  /** Filter logs by source */
+  filterBySource(source: string): DebugLogEntry[] {
+    return state.logs.filter((e) => e.source.includes(source));
+  },
+
+  /** Filter logs by level */
+  filterByLevel(level: DebugLogEntry["level"]): DebugLogEntry[] {
+    return state.logs.filter((e) => e.level === level);
+  },
+
+  /** Get only send/recv messages */
+  getMessages(): DebugLogEntry[] {
+    return state.logs.filter((e) => e.level === "send" || e.level === "recv");
+  },
+};
+
+// Attach to window for browser console access
+if (typeof window !== "undefined") {
+  (window as unknown as { __AUTOCORE_DEBUG__: typeof consoleAPI }).__AUTOCORE_DEBUG__ = consoleAPI;
+  console.warn(
+    "%c[AutoCore Debug] Debug utility loaded. Access via window.__AUTOCORE_DEBUG__",
+    "color: #44ff44; font-weight: bold;"
+  );
+}
+
+export default debug;

package/src/hub/index.ts

@@ -2,68 +2,78 @@
  * Copyright (C) 2024 Automated Design Corp. All Rights Reserved.
  * Created Date: 2024-01-16 21:07:29
  * -----
- * Last Modified: 2024-05-31 07:51:19
+ * Last Modified: 2026-01-29 09:34:39
  * Modified By: ADC
  * -----
- * 
+ *
  */
 
+console.log("[hub/index.ts] Module loading...");
+
 import { HubBase as Hub } from './HubBase';
 import { HubTauri } from './HubTauri';
 import { HubWebSocket } from "./HubWebSocket";
-import {HubSimulate} from "./HubSimulate"
-import { CommandMessage, CommandMessageResult } from './CommandMessage';
+import { HubSimulate } from "./HubSimulate";
+import { getDebugPanel } from "./DebugPanel";
 
+console.log("[hub/index.ts] Imports complete");
 
+/**
+ * Singleton hub instance.
+ * This ensures all components share the same connection to the backend.
+ */
 let hubInstance: Hub | null = null;
 
 /**
- * Creates a connection to the backend.
- * @returns Hub 
+ * Creates or returns the singleton Hub connection to the backend.
+ *
+ * The hub type is determined automatically:
+ * - If running in Tauri: HubTauri (direct Rust IPC)
+ * - Otherwise: HubWebSocket (WebSocket to autocore-server)
+ *
+ * @returns Hub The singleton hub instance
  */
 export function createHub(): Hub {
+    console.log("[HUB] createHub() called");
+    const panel = getDebugPanel();
+    panel.log("info", "createHub", `called (hasInstance: ${!!hubInstance})`);
 
     if (!hubInstance) {
-        if (window.__TAURI__ !== undefined && window.__TAURI__ !== null) {
-            console.log("HUB: Starting link to Tauri backend.");
+        if (typeof window !== 'undefined' && (window as any).__TAURI__ !== undefined && (window as any).__TAURI__ !== null) {
+            panel.log("info", "createHub", "Creating HubTauri instance");
             hubInstance = new HubTauri();
         } else {
-            console.log("HUB: Starting websocket connection.");
+            panel.log("info", "createHub", "Creating HubWebSocket instance");
             hubInstance = new HubWebSocket();
         }
+    } else {
+        panel.log("info", "createHub", "Returning existing hub instance");
     }
     return hubInstance;
-        
-    // if (window.__TAURI__ !== undefined && window.__TAURI__ !== null) {
-    //     // Standalone Tauri application
-    //     console.log("HUB: Starting link to Tauri backend.");
-    //     return new HubTauri();
-    // }
-    // // else if (
-    // //     window.location.port !== undefined
-    // //     &&  window.location.port.length > 0
-    // //     && window.location.port !== '80' 
-    // //     && window.location.port !== '8080' 
-    // //     && window.location.port !== '443' 
-    // // ) {
-    
-    // //     // We're loaded in some development environment
-    // //     console.log("HUB: Starting HUB SIMULATOR.");
-    // //     return new HubSimulate();
+}
 
-    // // } 
-    // else {
-    //     // A web-app that must communicate with a backend in another process.
-    //     console.log("HUB: Starting websocket connection.");
-    //     return new HubWebSocket();
-    // }
+/**
+ * Returns the current hub instance, or null if not yet created.
+ * Useful for checking if a hub exists without creating one.
+ */
+export function getHubInstance(): Hub | null {
+    return hubInstance;
+}
+
+/**
+ * Resets the singleton hub instance.
+ * This should only be used for testing or when intentionally reconnecting.
+ */
+export function resetHub(): void {
+    hubInstance = null;
 }
 
+// Export HubBase for convenience to save importing throughout the application.
+export { HubBase as Hub } from './HubBase';
+export { HubTauri };
+export { HubWebSocket };
+export { HubSimulate };
 
-// Export HubBase for convenience to save importing throughout the
-// application.
-export {HubBase as Hub} from './HubBase';
-export {HubTauri}
-export {HubWebSocket}
-export {HubSimulate}
-export type {CommandMessage, CommandMessageResult}
+// Export CommandMessage types
+export type { CommandMessage } from './CommandMessage';
+export { MessageType } from './CommandMessage';

package/tsconfig.json

@@ -1,34 +1,49 @@
 {
     "compilerOptions": {
-      "target": "ES2020", // Set the JavaScript language version for emitted JavaScript and include compatible library declarations
-      "outDir": "./dist", // Specify an output folder for all emitted files
-      "useDefineForClassFields": true, // Use 'define' semantics for class fields (as opposed to 'set')
-  
-      // Specify a set of compiled-in library files to be included in the compilation context
-      "lib": ["ES2020", "DOM", "DOM.Iterable"], 
-  
-      "module": "ESNext", // Specify what module code is generated (here, it's the latest module standard)
-      "declaration": true, // Generate the types files (*.d.ts)      
-      "skipLibCheck": true, // Skip type checking of declaration files (*.d.ts)
+        "target": "ES2020", // Set the JavaScript language version for emitted JavaScript and include compatible library declarations
+        "outDir": "./dist", // Specify an output folder for all emitted files
+        "useDefineForClassFields": true, // Use 'define' semantics for class fields (as opposed to 'set')
+        // Specify a set of compiled-in library files to be included in the compilation context
+        "lib": [
+            "ES2020",
+            "DOM",
+            "DOM.Iterable"
+        ],
+        "module": "ESNext", // Specify what module code is generated (here, it's the latest module standard)
+        "declaration": true, // Generate the types files (*.d.ts)      
+        "skipLibCheck": true, // Skip type checking of declaration files (*.d.ts)
+        /* Bundler mode */
+        "moduleResolution": "bundler", // "node", // Choose the module resolution strategy: 'node' for Node.js
+        "allowSyntheticDefaultImports": true, // Allow default imports from modules with no default export
+        "resolveJsonModule": true, // Include modules imported with '.json' extension
+        "isolatedModules": true, // Ensure each file can be safely transpiled without relying on other imports
+        "noEmit": false, // Do not emit outputs (if set to true, no files are emitted)
+        "jsx": "react-jsx", // Specify JSX code generation: 'preserve', 'react', or 'react-jsx' (new transform)
+        /* Linting */
+        "strict": true, // Enable all strict type checking options
+        "noUnusedLocals": true, // Report errors on unused locals
+        "noUnusedParameters": true, // Report errors on unused parameters
+        "noFallthroughCasesInSwitch": true, // Report errors for fallthrough cases in switch statement
 
-      /* Bundler mode */
-      "moduleResolution": "node", // Choose the module resolution strategy: 'node' for Node.js
-      "allowSyntheticDefaultImports": true, // Allow default imports from modules with no default export
-      "resolveJsonModule": true, // Include modules imported with '.json' extension
-      "isolatedModules": true, // Ensure each file can be safely transpiled without relying on other imports
-      "noEmit": false, // Do not emit outputs (if set to true, no files are emitted)
-      "jsx": "react-jsx", // Specify JSX code generation: 'preserve', 'react', or 'react-jsx' (new transform)
-  
-      /* Linting */
-      "strict": true, // Enable all strict type checking options
-      "noUnusedLocals": true, // Report errors on unused locals
-      "noUnusedParameters": true, // Report errors on unused parameters
-      "noFallthroughCasesInSwitch": true // Report errors for fallthrough cases in switch statement
+        /* publish doc along with js code to help with auto-completion */
+        "declarationMap": true, // nice for “go to definition”
+        "emitDeclarationOnly": false, // we want JS + types (default is fine)
+        "removeComments": false, // JS comments: optional; .d.ts will still carry JSDoc
+        "stripInternal": true, // hides /** @internal */ APIs from .d.ts (optional)
+
+        /*  helpful for cross-platform support */
+        "forceConsistentCasingInFileNames": true, 
+
+
+
+        "rootDir" : "src",
+        "verbatimModuleSyntax": true, // This keeps import/export syntax intact and avoids synthetic re-exports TS sometimes injects:
     },
-    "include": ["src"], // Specify file glob patterns to include in the program
-    "exclude": [        // Specify file globa patterns to exclude from compilation
+    "include": [
+        "src"
+    ], // Specify file glob patterns to include in the program
+    "exclude": [ // Specify file globa patterns to exclude from compilation
         "node_modules",
         "dist"
-    ]    
-  }
-  
+    ]
+}