@adcops/autocore-react 3.0.18 → 3.0.20

package/src/hooks/adsHooks.tsx

@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2024 Automated Design Corp.. All Rights Reserved.
+ * Created Date: 2024-04-26 09:04:40
+ * -----
+ * Last Modified: 2024-04-28 20:07:12
+ * -----
+ * 
+ */
+
+
+
+import { useContext, useRef, useEffect } from 'react';
+import { EventEmitterContext } from '../core/EventEmitterContext';
+
+
+/**
+ * Sleep for a given number of milliseconds.
+ * @param ms Number of milliseconds to sleep.
+ */
+function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+
+
+/**
+ * Custom hook for registering symbols and subscribing to updates on the 
+ * ADS domain via the EventEmitterContext.
+ * This hook abstracts the common pattern of registering symbols and handling subscriptions
+ * to updates in components that need real-time data from a backend service.
+ *
+ * @param setters A mapping of state setter functions, where each key corresponds to a piece of state
+ *                related to a symbol, and each value is the setter function for that state.
+ * @param symbols A mapping of state keys to their corresponding symbol names in the backend system.
+ *                Each key should match a key in the `setters` object, and each value should be a string
+ *                that represents the symbol name to register and subscribe to.
+ *
+ * ## Usage Example:
+ * ```typescript
+ * const setters = {
+ *     speed: setSpeed,
+ *     temperature: setTemperature
+ * };
+ *
+ * const symbols = {
+ *     speed: "Sensor.speed",
+ *     temperature: "Sensor.temperature"
+ * };
+ *
+ * useRegisterSymbols(setters, symbols);
+ * ```
+ *
+ * This will register and subscribe to updates for "Sensor.speed" and "Sensor.temperature",
+ * and update the `speed` and `temperature` states via `setSpeed` and `setTemperature` respectively
+ * whenever new data is received.
+ */
+export const useAdsRegisterSymbols = (setters: Record<string, (value: any) => void>, symbols: Record<string, string>) => {
+    const { invoke, subscribe, unsubscribe, isConnected } = useContext(EventEmitterContext);
+    const subscriptions = useRef<number[]>([]);
+    const isMounted = useRef(true);
+
+    useEffect(() => {
+        isMounted.current = true;
+
+        const registerAndSubscribe = async () => {
+            for (const [key, symbolName] of Object.entries(symbols)) {
+                try {
+                    await invoke("ADS", "register_symbol", { symbol_name: symbolName });
+                    //console.log(`Subscribe... ADS/${symbolName}`);
+                    const subscriptionId = subscribe(`ADS/${symbolName}`, (data) => {
+                        if (isMounted.current) {
+                            const setter = setters[key];
+                            if (setter) {
+                                setter(data.value);
+                            }
+                        }
+                    });
+                    subscriptions.current.push(subscriptionId);
+                } catch (err) {
+                    console.error(`Failed to register symbol ${symbolName}: ${err}`);
+                }
+            }
+            await invoke("ADS", "refresh", {});
+        };
+        
+        if (!isConnected() ) {
+            //console.log("SCHEDULE LATER...");
+            let connectionSubId = subscribe("HUB/connected", () => {
+                registerAndSubscribe();
+                unsubscribe(connectionSubId);
+            });
+            subscriptions.current.push(connectionSubId);
+        }
+        else {
+            //console.log("ALREADY CONNECTED...");
+            registerAndSubscribe();
+        }
+        
+
+        return () => {
+            //console.log("UNSUBSCRIBE");
+            isMounted.current = false;
+            subscriptions.current.forEach(subscriptionId => unsubscribe(subscriptionId));
+            subscriptions.current = [];
+        };
+    }, []); // Ensure setters and symbols are included if they can change
+
+    return null; // This hook does not render anything
+};
+
+
+/**
+ * Custom hook to create a function that sends a specified value to a remote device or server.
+ * This hook abstracts the repetitive logic involved in sending these values,
+ * such as invoking the command and handling errors.
+ *
+ * @param {string} domain The domain under which the backend function is grouped.
+ * @param {string} fname The name of the function to be called on the backend.
+ * @param {string} symbolName The symbol name that identifies the specific value or setting in the backend.
+ * @returns {Function} A function that accepts a value (number or boolean) and sends it to the configured backend.
+ *
+ * @example
+ * ```tsx
+ * import React, { useState } from 'react';
+ * import { Button } from 'primereact/button';
+ * import useWriteValue from './useWriteValue'; // adjust the import path as necessary
+ *
+ * const Component: React.FC = () => {
+ *   const [value, setValue] = useState<number>(0);
+ *   const writeToBackend = useAdsWriteValue("ADS", "write_value", "GNV.mySymbol");
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         type="number"
+ *         value={value}
+ *         onChange={(e) => setValue(Number(e.target.value))}
+ *       />
+ *       <Button
+ *         label="Send to Backend"
+ *         onClick={() => writeToBackend(value)}
+ *       />
+ *     </div>
+ *   );
+ * };
+ */
+export function useAdsWriteValue(symbolName: string) {
+    const { invoke } = useContext(EventEmitterContext);
+    const domain = "ADS";
+    const fname = "write_value";
+
+    // Return a function that takes a value and sends it to the backend
+    return async (value: object | boolean | number | string ) => {
+        try {
+            await invoke(domain, fname, { symbol_name: symbolName, value });
+        } catch (err) {
+            console.error(`Error writing tag ${symbolName}: ${err}`);
+        }
+    };
+}
+
+
+
+
+/**
+ * Custom hook to send a "tap" action, which sends true followed by false after a short delay,
+ * to a specified symbol in the backend. This is used to simulate a button tap or momentary switch.
+ *
+ * @param {string} domain - The domain under which the backend function is grouped.
+ * @param {string} fname - The function name to be called on the backend.
+ * @param {string} symbolName - The symbol name to target for the tap action.
+ * @returns {Function} A function that triggers the tap action.
+ *
+ * @example
+ * ```tsx
+ * import React from 'react';
+ * import { Button } from 'primereact/button';
+ * import useTapValue from './useTapValue'; // Ensure the correct import path
+ *
+ * const MyComponent: React.FC = () => {
+ *   const sendTapAction = useTapValue("ADS", "write_value", "GNV.myButton");
+ *
+ *   return (
+ *     <Button
+ *       label="Tap Button"
+ *       onClick={() => sendTapAction()}
+ *     />
+ *   );
+ * };
+ * ```
+ */
+export function useAdsTapValue(symbolName: string): () => Promise<void> {
+    const { invoke } = useContext(EventEmitterContext);
+    const domain = "ADS";
+    const fname = "write_value";
+
+    return async () => {
+        try {
+            await invoke(domain, fname, { symbol_name: symbolName, value: true });
+            await sleep(300); // Sleep for 300ms before writing false
+            await invoke(domain, fname, { symbol_name: symbolName, value: false });
+        } catch (err) {
+            console.error(`Error handling tap action for ${symbolName}: ${err}`);
+        }
+    };
+}
+

package/dist/hooks/useAdsRegisterSymbol.d.ts

@@ -1,32 +0,0 @@
-/**
- * Custom hook for registering symbols and subscribing to updates on the
- * ADS domain via the EventEmitterContext.
- * This hook abstracts the common pattern of registering symbols and handling subscriptions
- * to updates in components that need real-time data from a backend service.
- *
- * @param setters A mapping of state setter functions, where each key corresponds to a piece of state
- *                related to a symbol, and each value is the setter function for that state.
- * @param symbols A mapping of state keys to their corresponding symbol names in the backend system.
- *                Each key should match a key in the `setters` object, and each value should be a string
- *                that represents the symbol name to register and subscribe to.
- *
- * ## Usage Example:
- * ```typescript
- * const setters = {
- *     speed: setSpeed,
- *     temperature: setTemperature
- * };
- *
- * const symbols = {
- *     speed: "Sensor.speed",
- *     temperature: "Sensor.temperature"
- * };
- *
- * useRegisterSymbols(setters, symbols);
- * ```
- *
- * This will register and subscribe to updates for "Sensor.speed" and "Sensor.temperature",
- * and update the `speed` and `temperature` states via `setSpeed` and `setTemperature` respectively
- * whenever new data is received.
- */
-export declare const useAdsRegisterSymbols: (setters: Record<string, (value: any) => void>, symbols: Record<string, string>) => null;

package/dist/hooks/useAdsRegisterSymbol.js

@@ -1 +0,0 @@
-import{useEffect,useContext,useRef}from"react";import{EventEmitterContext}from"../core/EventEmitterContext";export const useAdsRegisterSymbols=(e,t)=>{const{invoke:r,subscribe:n,unsubscribe:s,isConnected:c}=useContext(EventEmitterContext),o=useRef([]),u=useRef(!0);return useEffect((()=>{u.current=!0;const i=async()=>{for(const[s,c]of Object.entries(t))try{await r("ADS","register_symbol",{symbol_name:c});const t=n(`ADS/${c}`,(t=>{if(u.current){const r=e[s];r&&r(t.value)}}));o.current.push(t)}catch(e){}await r("ADS","refresh",{})};if(c())i();else{let e=n("HUB/connected",(()=>{i(),s(e)}));o.current.push(e)}return()=>{u.current=!1,o.current.forEach((e=>s(e))),o.current=[]}}),[]),null};

package/src/hooks/useAdsRegisterSymbol.ts

@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2024 Automated Design Corp.. All Rights Reserved.
- * Created Date: 2024-04-25 09:17:05
- * -----
- * Last Modified: 2024-04-25 16:03:15
- * -----
- * 
- */
-
-
-import { useEffect, useContext, useRef } from 'react';
-import {EventEmitterContext} from "../core/EventEmitterContext";
-
-/**
- * Custom hook for registering symbols and subscribing to updates on the 
- * ADS domain via the EventEmitterContext.
- * This hook abstracts the common pattern of registering symbols and handling subscriptions
- * to updates in components that need real-time data from a backend service.
- *
- * @param setters A mapping of state setter functions, where each key corresponds to a piece of state
- *                related to a symbol, and each value is the setter function for that state.
- * @param symbols A mapping of state keys to their corresponding symbol names in the backend system.
- *                Each key should match a key in the `setters` object, and each value should be a string
- *                that represents the symbol name to register and subscribe to.
- *
- * ## Usage Example:
- * ```typescript
- * const setters = {
- *     speed: setSpeed,
- *     temperature: setTemperature
- * };
- *
- * const symbols = {
- *     speed: "Sensor.speed",
- *     temperature: "Sensor.temperature"
- * };
- *
- * useRegisterSymbols(setters, symbols);
- * ```
- *
- * This will register and subscribe to updates for "Sensor.speed" and "Sensor.temperature",
- * and update the `speed` and `temperature` states via `setSpeed` and `setTemperature` respectively
- * whenever new data is received.
- */
-export const useAdsRegisterSymbols = (setters: Record<string, (value: any) => void>, symbols: Record<string, string>) => {
-    const { invoke, subscribe, unsubscribe, isConnected } = useContext(EventEmitterContext);
-    const subscriptions = useRef<number[]>([]);
-    const isMounted = useRef(true);
-
-    useEffect(() => {
-        isMounted.current = true;
-
-        const registerAndSubscribe = async () => {
-            for (const [key, symbolName] of Object.entries(symbols)) {
-                try {
-                    await invoke("ADS", "register_symbol", { symbol_name: symbolName });
-                    //console.log(`Subscribe... ADS/${symbolName}`);
-                    const subscriptionId = subscribe(`ADS/${symbolName}`, (data) => {
-                        if (isMounted.current) {
-                            const setter = setters[key];
-                            if (setter) {
-                                setter(data.value);
-                            }
-                        }
-                    });
-                    subscriptions.current.push(subscriptionId);
-                } catch (err) {
-                    console.error(`Failed to register symbol ${symbolName}: ${err}`);
-                }
-            }
-            await invoke("ADS", "refresh", {});
-        };
-        
-        if (!isConnected() ) {
-            //console.log("SCHEDULE LATER...");
-            let connectionSubId = subscribe("HUB/connected", () => {
-                registerAndSubscribe();
-                unsubscribe(connectionSubId);
-            });
-            subscriptions.current.push(connectionSubId);
-        }
-        else {
-            //console.log("ALREADY CONNECTED...");
-            registerAndSubscribe();
-        }
-        
-
-        return () => {
-            //console.log("UNSUBSCRIBE");
-            isMounted.current = false;
-            subscriptions.current.forEach(subscriptionId => unsubscribe(subscriptionId));
-            subscriptions.current = [];
-        };
-    }, []); // Ensure setters and symbols are included if they can change
-
-    return null; // This hook does not render anything
-};