@adcops/autocore-react 3.0.0

package/dist/core/EventEmitterContext.d.ts

@@ -0,0 +1,223 @@
+import React, { ReactNode } from 'react';
+import { Hub } from "../hub";
+export { Hub };
+/**
+ * Represents an event subsription.
+ */
+export interface Subscription {
+    /** ID of the subscription used for unsubscription. */
+    id: number;
+    /** Callback function. */
+    callback: React.Dispatch<any>;
+}
+/**
+ * Represents the payload data associated with an event.
+ */
+export interface State {
+    /**
+     * The optional data payload of the event.
+     */
+    eventData?: any;
+    /** Callback subscription. A list of callback subscriptions matched to a 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.
+ */
+export interface Action {
+    /**
+     * The topic or identifier of the event.
+     */
+    topic: string;
+    /**
+     * The optional data payload associated with the event.
+     */
+    payload?: any;
+}
+export type EmitterDispatchFunction = (action: Action) => void;
+export type EmitterSubscribeFunction = (action: Action) => void;
+export type EmitterUnsubscribeFunction = (action: Action) => void;
+export interface EventEmitterContextType {
+    /**
+     * The current state of the event emitter, containing the latest event data.
+     */
+    state: State;
+    /**
+     * A function to dispatch actions globally throughout the front-end,
+     * triggering state updates and events.
+     *
+     * @param action The action to dispatch, containing topic and optional payload.
+     */
+    dispatch: (action: Action) => void;
+    /**
+     * Invoke/send a message to the back end.
+     * This does NOT get published to the front end.
+     */
+    invoke(fname: string, payload?: object): Promise<object>;
+    /**
+     * Subscribe to events identified by the topic.
+     * @param topic The subscription topic.
+     * @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: (subscriptionId: number) => void;
+    /**
+     * Global hub for publishing and receiving events throughout the interface, and for exchanging
+     * data with the backend.
+     */
+    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[];
+}
+/**
+ * A global context for managing event emission and subscription.
+ *
+ * Provides a mechanism for decoupled data sharing between components
+ * using a publish-subscribe pattern.
+ * 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);
+ *    }
+ *
+ * }, [] );
+ *
+ * ```
+ *
+ *
+ */
+export declare const EventEmitterContext: React.Context<EventEmitterContextType>;
+/**
+ * A React component that provides the EventEmitterContext to its children.
+ *
+ * Wraps child components with the context, enabling them to access and interact
+ * 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.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{createContext,useState,useMemo}from"react";import{createHub,Hub}from"../hub";export{Hub};export const EventEmitterContext=createContext({state:{subscriptions:{},nextSubscriptionId:1},dispatch:()=>{},subscribe:()=>0,invoke:async(t,s)=>Promise.resolve({}),unsubscribe:t=>{},hub:null,getSubscriptions:()=>[]});export const EventEmitterProvider=({children:t})=>{const[s,e]=useState({subscriptions:{},nextSubscriptionId:1}),i=useMemo((()=>createHub()),[]),r=t=>{const{topic:s,payload:i}=t;e((t=>(t.subscriptions[s]?.forEach((t=>t.callback(i))),{...t,eventData:i})))},n=(t,i)=>{const r=s.nextSubscriptionId;return e((s=>({...s,subscriptions:{...s.subscriptions,[t]:[...s.subscriptions[t]||[],{id:r,callback:i}]},nextSubscriptionId:s.nextSubscriptionId+1}))),r},o=t=>{e((s=>{const e={...s.subscriptions};for(const s in e)e.hasOwnProperty(s)&&(e[s]=e[s].filter((s=>s.id!==t)),0===e[s].length&&delete e[s]);return{...s,subscriptions:e}}))},c=t=>t?s.subscriptions[t]||[]:s.subscriptions,u=useMemo((()=>({state:s,dispatch:r,subscribe:n,unsubscribe:o,invoke:i.invoke,hub:i,getSubscriptions:c})),[s,i]);return i.setContext(u),_jsx(EventEmitterContext.Provider,{value:u,children:t})};

package/dist/core/MaskPatterns.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview
+ * Provides a collection of pre-defined patterns for masking/validating different types of user input or data string.
+ * These patterns come up so regularly in our work that it seemed best to standardize and centralize their definition.
+ *
+ * These patterns can be used to ensure that user inputs conform to expected formats, such as real numbers (with or without
+ * decimal points), positive real numbers, integers, and positive integers. Utilizing these patterns simplifies the process
+ * of validating and filtering input in forms or any other user input scenarios.
+ *
+ * The patterns are defined as regular expressions and are encapsulated within the `InputPatterns` constant for easy access.
+ * They can be used directly with input validation functions or in conjunction with form validation libraries to enforce
+ * input constraints.
+ */
+/**
+ * Regular expressions Common input patterns for matching different input or expected data types.
+ */
+export declare const RegExMaskPatterns: {
+    /**
+     * Regular expression pattern for matching real numbers.
+     * This pattern matches any real number, including negative and positive numbers with or without a decimal point.
+     * Examples of valid inputs: "123", "-123", "123.456", "-123.456", ".456", "-.456"
+     */
+    readonly RealNumber: RegExp;
+    /**
+     * Regular expression pattern for matching positive real numbers.
+     * This pattern matches any positive real number with or without a decimal point, excluding negative numbers.
+     * Examples of valid inputs: "123", "123.456", ".456"
+     */
+    readonly RealNumberPositive: RegExp;
+    /**
+     * Regular expression pattern for matching integers.
+     * This pattern matches any integer, including negative and positive integers without a decimal point.
+     * Examples of valid inputs: "123", "-123"
+     */
+    readonly Integer: RegExp;
+    /**
+     * Regular expression pattern for matching positive integers.
+     * This pattern matches any positive integer without a decimal point, excluding negative numbers.
+     * Examples of valid inputs: "123"
+     */
+    readonly IntegerPositive: RegExp;
+};
+/**
+ * Patterns for use with PrimeReact.InputMask components
+ */
+export declare const PrimeReactMaskPatterns: {
+    /** USA Social Security Number */
+    readonly SocialSecurityNumber: "999-99-9999";
+    /** USA phone number with optional extension */
+    readonly PhoneNumberUS: "(999) 999-9999? x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberInternational: "+999 999 999 9999? x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberJapan: "+81 9999 999 9999? x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberChina: "+86 999 999 9999? x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberVietnam: "+84 999 999 9999? x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberSouthKorea: "+82 99 9999 9999 x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberCanada: "+1 (999) 999-9999 x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberMexico: "+52 999 999 9999 x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberScotland: "+44 9999 999999 x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberEngland: "+44 9999 999999 x99999";
+    /** International phone number with optional extension */
+    readonly PhoneNumberIreland: "+353 99 999 9999 x99999";
+};

package/dist/core/MaskPatterns.js

@@ -0,0 +1 @@
+export const RegExMaskPatterns={RealNumber:/^-?\d*(\.)?(\d+)?$/,RealNumberPositive:/^\d*(\.)?(\d+)?$/,Integer:/^-?\d*$/,IntegerPositive:/^\d+$/};export const PrimeReactMaskPatterns={SocialSecurityNumber:"999-99-9999",PhoneNumberUS:"(999) 999-9999? x99999",PhoneNumberInternational:"+999 999 999 9999? x99999",PhoneNumberJapan:"+81 9999 999 9999? x99999",PhoneNumberChina:"+86 999 999 9999? x99999",PhoneNumberVietnam:"+84 999 999 9999? x99999",PhoneNumberSouthKorea:"+82 99 9999 9999 x99999",PhoneNumberCanada:"+1 (999) 999-9999 x99999",PhoneNumberMexico:"+52 999 999 9999 x99999",PhoneNumberScotland:"+44 9999 999999 x99999",PhoneNumberEngland:"+44 9999 999999 x99999",PhoneNumberIreland:"+353 99 999 9999 x99999"};

package/dist/core/NumerableTypes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview
+ *
+ * These types enhance TypeScript support for the `numerable` library, which does not directly
+ * export the `NumerableFormatNumberOptions` type. By extracting and refining the type definitions
+ * for the `format` function's parameters, including handling its overloaded signatures, this file
+ * makes it easier to use `numerable` in TypeScript and React projects.
+ *
+ * The process involves creating a type that captures the overloads of the `format` function and
+ * then mapping over these overloads to extract their parameters. This technique enables the
+ * extraction of the specific options type `NumerableFormatNumberOptions` used by the `format`
+ * function, thereby providing type safety and IntelliSense support in TypeScript environments.
+ *
+ * The approach used here is based on a solution for handling function overloads in TypeScript,
+ * as discussed in a StackOverflow answer: https://stackoverflow.com/a/59538756/10049787.
+ */
+import { format } from 'numerable';
+/**
+ * Type helper to capture the overload signatures of a function.
+ * This utility type takes a function with multiple overloads and maps them to a tuple of
+ * functions, each representing one of the overloads.
+ */
+type NumerableFormatOverloads<T> = T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+    (...args: infer A3): infer R3;
+} ? [(...args: A1) => R1, (...args: A2) => R2, (...args: A3) => R3] : T extends {
+    (...args: infer A1): infer R1;
+    (...args: infer A2): infer R2;
+} ? [(...args: A1) => R1, (...args: A2) => R2] : T extends {
+    (...args: infer A1): infer R1;
+} ? [(...args: A1) => R1] : any;
+/**
+ * Extracts parameters from a tuple of function types.
+ * This utility type maps over a tuple of functions (representing overloads) to produce a tuple
+ * of their respective parameter types.
+ */
+type OverloadedParameters<T> = NumerableFormatOverloads<T> extends infer O ? {
+    [K in keyof O]: Parameters<Extract<O[K], (...args: any) => any>>;
+} : never;
+/**
+ * Type representing the parameters of the `numerable.format` function, taking into account its
+ * overloaded signatures.
+ */
+type NumerableFormatParams = OverloadedParameters<typeof format>;
+/**
+ * Type specifically for the options parameter of the `numerable.format` function.
+ * This extracts the type of the third parameter (options) from the first overload of `format`,
+ * as this is where the formatting options are specified.
+ */
+type NumerableFormatNumberOptions = NumerableFormatParams[0][2];
+/**
+ * Exported type for external use, providing a non-nullable version of the formatting options.
+ * This type is intended for use wherever `numerable.format` options are needed, enhancing
+ * code readability and type safety.
+ */
+export type NumerableFormatOptions = NonNullable<NumerableFormatNumberOptions>;
+export {};

package/dist/core/NumerableTypes.js

@@ -0,0 +1 @@
+export{};

package/dist/core/PositionContext.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+/**
+ * Interface representing the position and scale context of a component within its parent container.
+ *
+ * This context is designed to provide components with necessary scaling and positioning
+ * information, such as for rendering elements correctly in absolute positioning or for
+ * adjusting layout based on dynamic offsets.
+ */
+export interface IPositionContext {
+    /**
+     * Represents the scale factor applied to the dimensions of elements.
+     * A scale of 1 indicates no scaling, while values greater or less than 1
+     * indicate zoomed-in or zoomed-out states respectively.
+     */
+    scale: number;
+    /**
+     * Represents the horizontal offset that should be applied to the position
+     * of elements. This can be used to adjust element positioning in response to
+     * dynamic layout changes or to align elements within a scaled environment.
+     */
+    xOffset: number;
+    /**
+     * Represents the vertical offset that should be applied to the position
+     * of elements. Similar to `xOffset`, this is used for vertical alignment and
+     * positioning adjustments in a dynamic or scaled layout.
+     */
+    yOffset: number;
+}
+/**
+ * Creates a React context for position and scaling information of a component using absolute positioning.
+ * This context provides a standardized way to access and react to changes in scale and positioning offsets,
+ * enabling components to adjust their layout and rendering behavior dynamically.
+ *
+ * The default context values are set to assume no scaling (`scale: 1`) and no offsets (`xOffset: 0, yOffset: 0`),
+ * which corresponds to the initial state in many applications before any dynamic adjustments are made.
+ */
+export declare const DimensionsContext: import("react").Context<IPositionContext>;
+export default DimensionsContext;

package/dist/core/PositionContext.js

@@ -0,0 +1 @@
+import{createContext}from"react";export const DimensionsContext=createContext({scale:1,xOffset:0,yOffset:0});export default DimensionsContext;

package/dist/core/UniqueId.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generates a unique UUID per RFC4122.
+ * 8 chars, followed by 3 groups of 4 chars, followed by 12 chars.
+ *
+ * @returns string UUID
+ *
+ * ## Remarks
+ * NOTE: This format of 8 chars, followed by 3 groups of 4 chars, followed by 12 chars
+ *       is known as a UUID and is defined in RFC4122 and is a standard for generating unique IDs.
+ *       This function DOES NOT implement this standard. It simply outputs a string
+ *       that looks similar. The standard is found here: https://www.ietf.org/rfc/rfc4122.txt
+ *
+ * Should avoid duplicates over 10-millions subsequent calls.
+ *
+ */
+export declare function UniqueId(): string;

package/dist/core/UniqueId.js

@@ -0,0 +1 @@
+const PrivateUniqueId=function(){function n(){return Math.random().toString(16).slice(-4)}return n()+n()+"-"+n()+"-"+n()+"-"+n()+"-"+n()+n()+n()};export function UniqueId(){return PrivateUniqueId()}

package/dist/core/ValueSimulator.d.ts

@@ -0,0 +1,71 @@
+import { EmitterDispatchFunction } from "./EventEmitterContext";
+/**
+ * Generates values for simulating data into an HMI.
+ * Used for demonstration and development testing.
+ */
+export declare class ValueSimulator {
+    protected bBit1: boolean;
+    protected bBit2: boolean;
+    protected iRamp1: number;
+    protected iRamp2: number;
+    protected fRamp1: number;
+    protected fRamp2: number;
+    protected iSin1: number;
+    protected iSin2: number;
+    protected fSin1: number;
+    protected fSin2: number;
+    protected iRamp1DirectionUp: boolean;
+    protected iRamp2DirectionUp: boolean;
+    protected fRamp1DirectionUp: boolean;
+    protected fRamp2DirectionUp: boolean;
+    protected iSin1Angle: number;
+    protected iSin2Angle: number;
+    protected fSin1Angle: number;
+    protected fSin2Angle: number;
+    protected intervalId: number;
+    protected dispatch: EmitterDispatchFunction;
+    /**
+     * Constructor
+     * @param dispatch EmitterDispatchFunction Dispatch function from the application's EventEmiterContext.
+     */
+    constructor(dispatch: EmitterDispatchFunction);
+    /**
+     * Start simulating values on a tick
+     */
+    start(): void;
+    /**
+     * Stop simulating values.
+     */
+    stop(): void;
+    /**
+     * Update and dispatch the values.
+     */
+    protected update(): void;
+    /**
+     * Updates the value of a ramp variable, changing its direction when limits are reached.
+     * @param {number} value The current value of the ramp variable.
+     * @param {boolean} directionUp Indicates if the ramp variable is currently increasing.
+     * @param {number} max The maximum value for the ramp.
+     * @returns {[number, boolean]} The updated value and direction.
+     */
+    protected updateRamp(value: number, directionUp: boolean, max: number): [number, boolean];
+    /**
+     * Updates a sine wave value based on the given angle and increments, then calculates the new value and angle.
+     * This method is useful for scenarios where a sine wave value needs to be progressively updated, such as in animations
+     * or simulations. The sine of the updated angle is calculated, multiplied by the maximum value to scale it, and both
+     * the new value and the updated angle are returned.
+     *
+     * @param {number} value The current value of the sine wave. This parameter is not directly used in the calculation of the new value,
+     * but it can be utilized if the method is extended or modified.
+     * @param {number} angle The current angle in radians. This is the phase of the sine wave.
+     * @param {number} increment The value by which the angle is to be incremented, in radians. This controls the progression of the wave.
+     * @param {number} max The maximum value (amplitude) of the sine wave. The calculated sine value will be scaled by this factor.
+     * @returns {[number,number]} A tuple where the first element is the new sine wave value and the second element is the updated angle.
+     */
+    protected updateSin(value: number, angle: number, increment: number, max: number): [number, number];
+    /**
+     * Dispatch the update for a particular topic.
+     */
+    protected updateTopic(topic: string, value: any): void;
+}
+export default ValueSimulator;

package/dist/core/ValueSimulator.js

@@ -0,0 +1 @@
+export class ValueSimulator{constructor(i){Object.defineProperty(this,"bBit1",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"bBit2",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"iRamp1",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"iRamp2",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"fRamp1",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"fRamp2",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"iSin1",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"iSin2",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"fSin1",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"fSin2",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"iRamp1DirectionUp",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"iRamp2DirectionUp",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"fRamp1DirectionUp",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"fRamp2DirectionUp",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"iSin1Angle",{enumerable:!0,configurable:!0,writable:!0,value:Math.random()*Math.PI*2}),Object.defineProperty(this,"iSin2Angle",{enumerable:!0,configurable:!0,writable:!0,value:Math.random()*Math.PI*2}),Object.defineProperty(this,"fSin1Angle",{enumerable:!0,configurable:!0,writable:!0,value:Math.random()*Math.PI*2/10}),Object.defineProperty(this,"fSin2Angle",{enumerable:!0,configurable:!0,writable:!0,value:Math.random()*Math.PI*2/10}),Object.defineProperty(this,"intervalId",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"dispatch",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.dispatch=i}start(){0===this.intervalId&&(this.intervalId=setInterval((()=>this.update()),1e3))}stop(){0!==this.intervalId&&(clearInterval(this.intervalId),this.intervalId=0)}update(){this.bBit1=!this.bBit1,this.bBit2=!this.bBit2,[this.iRamp1,this.iRamp1DirectionUp]=this.updateRamp(this.iRamp1,this.iRamp1DirectionUp,32767),[this.iRamp2,this.iRamp2DirectionUp]=this.updateRamp(this.iRamp2,this.iRamp2DirectionUp,32767),[this.fRamp1,this.fRamp1DirectionUp]=this.updateRamp(this.fRamp1,this.fRamp1DirectionUp,3276.7),[this.fRamp2,this.fRamp2DirectionUp]=this.updateRamp(this.fRamp2,this.fRamp2DirectionUp,3276.7),[this.iSin1,this.iSin1Angle]=this.updateSin(this.iSin1,this.iSin1Angle,Math.PI/180,32767),[this.iSin2,this.iSin2Angle]=this.updateSin(this.iSin2,this.iSin2Angle,Math.PI/180,32767),[this.fSin1,this.fSin1Angle]=this.updateSin(this.fSin1,this.fSin1Angle,Math.PI/180,3276.7),[this.fSin2,this.fSin2Angle]=this.updateSin(this.fSin2,this.fSin2Angle,Math.PI/180,3276.7),this.updateTopic("value-simulator-bBit1",this.bBit1),this.updateTopic("value-simulator-bBit2",this.bBit2),this.updateTopic("value-simulator-iRamp1",this.iRamp1),this.updateTopic("value-simulator-iRamp2",this.iRamp2),this.updateTopic("value-simulator-fRamp1",this.fRamp1),this.updateTopic("value-simulator-fRamp2",this.fRamp2),this.updateTopic("value-simulator-iSin1",this.iSin1),this.updateTopic("value-simulator-iSin2",this.iSin2),this.updateTopic("value-simulator-fSin1",this.fSin1),this.updateTopic("value-simulator-fSin2",this.fSin2)}updateRamp(i,e,t){if(e){if(++i>=t)return[i,!1]}else if(--i<=0)return[i,!0];return[i,e]}updateSin(i,e,t,a){return e+=t,[Math.sin(e)*a,e]}updateTopic(i,e){this.dispatch({topic:i,payload:e})}}export default ValueSimulator;

package/dist/core/hoc.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @fileinfo
+ * Explanation:
+ * React.ComponentType<P>: This is a generic type that can accept any React component (functional or class) with props of type P.
+ * P extends WithSubscriptionProps: Here, P is a generic type parameter that extends WithSubscriptionProps,
+ * meaning it can be any type that includes the properties of WithSubscriptionProps.
+ * Omit<P, keyof WithSubscriptionProps>: This utility type creates a new type by omitting properties from
+ * P that are also in WithSubscriptionProps. This is useful to prevent type clashes.
+ * useState<any>(): The state is typed as any since the value received from the subscription
+ * can be of any type. You may choose to make this more specific based on your application's needs.
+ *
+ */
+import React from 'react';
+/**
+ * High Order Component Subscription properties.
+ */
+export type HocAddSubscriptionProps = {
+    /** The topic to subscribe to. */
+    topic: string;
+    /** The name of the prop through which the subscription data is passed to the WrappedComponent.  */
+    propName?: string;
+};
+/**
+ * Creates a higher-order component that subscribes to a specified topic and passes the data to the wrapped component.
+ *
+ * @param WrappedComponent The component to be wrapped and enhanced with subscription data.
+ * @param topic The topic to subscribe to.
+ * @param propName The name of the prop through which the subscription data is passed to the WrappedComponent.
+ * @returns A component that subscribes to the given topic and updates its specified prop with the received data.
+ */
+export declare function hocAddSubscription<P extends HocAddSubscriptionProps>(WrappedComponent: React.ComponentType<P>, topic: string, propName: keyof P): (props: Omit<P, keyof HocAddSubscriptionProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/core/hoc.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useState,useEffect,useContext}from"react";import{EventEmitterContext}from"./EventEmitterContext";export function hocAddSubscription(t,e,r){return function(n){const[o,s]=useState(),{subscribe:u,unsubscribe:i}=useContext(EventEmitterContext);useEffect((()=>{const t=u(e,s);return()=>i(t)}),[e,u,i]);return _jsx(t,{...n,...{[r]:o}})}}