@norgate-av/react-crestron-ch5-hooks 1.0.0

package/dist/react-crestron-ch5-hooks.umd.development.js

@@ -0,0 +1,645 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@crestron/ch5-crcomlib'), require('@norgate-av/crestron-ch5-helper'), require('react')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@crestron/ch5-crcomlib', '@norgate-av/crestron-ch5-helper', 'react'], factory) :
+    (global = global || self, factory(global['@norgate-av/react-crestron-ch5-hooks'] = {}, global.ch5Crcomlib, global.CrestronCH5, global.React));
+}(this, (function (exports, ch5Crcomlib, CrestronCH5, react) { 'use strict';
+
+    CrestronCH5 = CrestronCH5 && Object.prototype.hasOwnProperty.call(CrestronCH5, 'default') ? CrestronCH5['default'] : CrestronCH5;
+
+    /**
+     * `useCrestronPublishAnalog` is a hook that returns an object with a setValue function.
+     * @param {string} signalName - The name of the signal you want to publish to.
+     * @returns An array with a single IAnalogEventAction object.
+     */
+
+    function useCrestronPublishAnalog(signalName) {
+      return [{
+        setValue: function setValue(value) {
+          return ch5Crcomlib.publishEvent(CrestronCH5.SignalType.Number, signalName, value);
+        }
+      }];
+    }
+    var useCrestronPublishNumber = useCrestronPublishAnalog;
+
+    /**
+     * `useCrestronSubscribeAnalog` is a hook that returns an object with a value property.
+     * @param {string} signalName - The name of the signal you want to subscribe to.
+     * @param {AnalogStateCallback} [callback] - An optional callback function that will be called whenever the state
+     * changes.
+     * @returns An array with a single IAnalogState object.
+     */
+
+    function useCrestronSubscribeAnalog(signalName, callback) {
+      var _useState = react.useState(0),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.Number;
+        var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+          setState(value);
+
+          if (callbackRef.current) {
+            callbackRef.current(value, signalName);
+          }
+        });
+        return function () {
+          ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+        };
+      }, [signalName]);
+      return [{
+        value: state
+      }];
+    }
+    var useCrestronSubscribeNumber = useCrestronSubscribeAnalog;
+
+    /**
+     * `useCrestronAnalog` is a hook that returns an object with a state and action property.
+     * @param {string} signalName - The name of the signal you want to use.
+     * @param {AnalogStateCallback} [callback] - An optional callback function that will be called whenever the state of the signal
+     * changes.
+     * @returns An array with a single IAnalogSignal object.
+     */
+
+    function useCrestronAnalog(signalName, callback) {
+      var _useCrestronSubscribe = useCrestronSubscribeAnalog(signalName, callback),
+          state = _useCrestronSubscribe[0];
+
+      var _useCrestronPublishAn = useCrestronPublishAnalog(signalName),
+          action = _useCrestronPublishAn[0];
+
+      return [{
+        state: state,
+        action: action
+      }];
+    }
+    var useCrestronNumber = useCrestronAnalog;
+
+    /**
+     * `useCrestronPublishDigital` is a hook that returns an object with setValue, push, release and click functions.
+     * @param {string} signalName - The name of the signal you want to publish to.
+     * @returns An array with a single IDigitalEventAction object.
+     */
+
+    function useCrestronPublishDigital(signalName) {
+      var signalType = CrestronCH5.SignalType.Boolean;
+
+      var setValue = function setValue(value) {
+        ch5Crcomlib.publishEvent(signalType, signalName, value);
+      };
+
+      var push = function push() {
+        setValue(true);
+      };
+
+      var release = function release() {
+        setValue(false);
+      };
+
+      var click = function click() {
+        push();
+        release();
+      }; // const hold = (duration: number, callback: () => void) => {
+      //     push();
+      //     setTimeout(() => {
+      //         release();
+      //         callback();
+      //     }, duration);
+      // };
+
+
+      return [{
+        setValue: setValue,
+        push: push,
+        release: release,
+        click: click
+      }];
+    }
+    var useCrestronPublishBoolean = useCrestronPublishDigital;
+
+    /**
+     * `useCrestronSubscribeDigital` is a hook that returns an object with a value property.
+     * @param {string} signalName - The name of the signal you want to subscribe to.
+     * @param {DigitalStateCallback} [callback] - An optional callback function that will be called whenever the state
+     * changes.
+     * @returns An array with a single IDigitalState object.
+     */
+
+    function useCrestronSubscribeDigital(signalName, callback) {
+      var _useState = react.useState(false),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.Boolean;
+        var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+          setState(value);
+
+          if (callbackRef.current) {
+            callbackRef.current(value, signalName);
+          }
+        });
+        return function () {
+          ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+        };
+      }, [signalName]);
+      return [{
+        value: state
+      }];
+    }
+    var useCrestronSubscribeBoolean = useCrestronSubscribeDigital;
+
+    /**
+     * `useCrestronDigital` is a hook that returns an object with a state and action property.
+     * @param {string} signalName - The name of the signal you want to use.
+     * @param {DigitalStateCallback} [callback] - An optional callback function that will be called whenever the state of the signal
+     * changes.
+     * @returns An array with a single IDigitalSignal object
+     */
+
+    function useCrestronDigital(signalName, callback) {
+      var _useCrestronSubscribe = useCrestronSubscribeDigital(signalName, callback),
+          state = _useCrestronSubscribe[0];
+
+      var _useCrestronPublishDi = useCrestronPublishDigital(signalName),
+          action = _useCrestronPublishDi[0];
+
+      return [{
+        state: state,
+        action: action
+      }];
+    }
+    var useCrestronBoolean = useCrestronDigital;
+
+    /**
+     * `useCrestronPublishSerial` is a hook that returns an object with a setValue function.
+     * @param {string} signalName - The name of the signal you want to publish to.
+     * @returns An array with a single ISerialEventAction object.
+     */
+
+    function useCrestronPublishSerial(signalName) {
+      return [{
+        setValue: function setValue(value) {
+          return ch5Crcomlib.publishEvent(CrestronCH5.SignalType.String, signalName, value);
+        }
+      }];
+    }
+    var useCrestronPublishString = useCrestronPublishSerial;
+
+    /**
+     * `useCrestronSubscribeSerial` is a hook that returns an object with a value property.
+     * @param {string} signalName - The name of the signal you want to subscribe to.
+     * @param {SerialStateCallback} [callback] - An optional callback function that will be called whenever the state
+     * changes.
+     * @returns An array with a single ISerialState object.
+     */
+
+    function useCrestronSubscribeSerial(signalName, callback) {
+      var _useState = react.useState(""),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.String;
+        var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+          setState(value);
+
+          if (callbackRef.current) {
+            callbackRef.current(value, signalName);
+          }
+        });
+        return function () {
+          ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+        };
+      }, [signalName]);
+      return [{
+        value: state
+      }];
+    }
+    var useCrestronSubscribeString = useCrestronSubscribeSerial;
+
+    /**
+     * `useCrestronSerial` is a hook that returns an object with a state and action property.
+     * @param {string} signalName - The name of the signal you want to use.
+     * @param {SerialStateCallback} [callback] - An optional callback function that will be called whenever the state of the signal
+     * changes.
+     * @returns An array with a single ISerialSignal object.
+     */
+
+    function useCrestronSerial(signalName, callback) {
+      var _useCrestronSubscribe = useCrestronSubscribeSerial(signalName, callback),
+          state = _useCrestronSubscribe[0];
+
+      var _useCrestronPublishSe = useCrestronPublishSerial(signalName),
+          action = _useCrestronPublishSe[0];
+
+      return [{
+        state: state,
+        action: action
+      }];
+    }
+    var useCrestronString = useCrestronSerial;
+
+    function getSignalCollection(length, state, action) {
+      var signals = []; // eslint-disable-next-line no-plusplus
+
+      for (var index = 0; index < length; index++) {
+        signals.push({
+          state: state[index],
+          action: action[index]
+        });
+      }
+
+      return signals;
+    }
+
+    /**
+     * `useCrestronPublishAnalogCollection` is a hook that returns an array of objects each with a setValue function.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to publish to.
+     * @returns An array of IAnalogEventAction objects.
+     */
+
+    function useCrestronPublishAnalogCollection(signalNames) {
+      var signalType = CrestronCH5.SignalType.Number;
+      var actions = [];
+      signalNames.forEach(function (signalName) {
+        actions.push({
+          setValue: function setValue(value) {
+            return ch5Crcomlib.publishEvent(signalType, signalName, value);
+          }
+        });
+      });
+      return actions;
+    }
+    var useCrestronPublishNumberCollection = useCrestronPublishAnalogCollection;
+
+    function _extends() {
+      _extends = Object.assign || function (target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+
+        return target;
+      };
+
+      return _extends.apply(this, arguments);
+    }
+
+    /**
+     * `useCrestronSubscribeAnalogCollection` is a hook that returns an array of objects each with a value property.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to subscribe to.
+     * @param {AnalogStateCallback} [callback] - An optional callback function that will be called whenever the
+     * state changes.
+     * @returns An array of IAnalogState objects.
+     */
+
+    function useCrestronSubscribeAnalogCollection(signalNames, callback) {
+      var _useState = react.useState(Array.from({
+        length: signalNames.length
+      }).fill({
+        value: 0
+      })),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.Number;
+        var subscriptions = [];
+        signalNames.forEach(function (signalName, index) {
+          var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+            setState(function (prevState) {
+              var newState = [].concat(prevState);
+              newState[index] = _extends({}, newState[index], {
+                value: value
+              });
+              return newState;
+            });
+
+            if (callbackRef.current) {
+              callbackRef.current(value, signalName);
+            }
+          });
+          subscriptions.push({
+            id: id,
+            signalName: signalName
+          });
+        });
+
+        var unsubscribeAll = function unsubscribeAll() {
+          subscriptions.forEach(function (_ref) {
+            var id = _ref.id,
+                signalName = _ref.signalName;
+            ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+          });
+        };
+
+        return function () {
+          unsubscribeAll();
+        };
+      }, []);
+      return state;
+    }
+    var useCrestronSubscribeNumberCollection = useCrestronSubscribeAnalogCollection;
+
+    /**
+     * `useCrestronAnalogCollection` is a hook that returns an array of objects each with state and action properties.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to use.
+     * @param {AnalogStateCallback} [callback] - A optional callback function that will be called whenever the state of
+     * the signal changes.
+     * @returns An array of IAnalogSignal objects.
+     */
+
+    function useCrestronAnalogCollection(signalNames, callback) {
+      var state = useCrestronSubscribeAnalogCollection(signalNames, callback);
+      var action = useCrestronPublishAnalogCollection(signalNames);
+      return getSignalCollection(signalNames.length, state, action);
+    }
+    var useCrestronNumberCollection = useCrestronAnalogCollection;
+
+    /**
+     * `useCrestronPublishDigitalCollection` is a hook that returns an array of objects each with setValue, push, release and click functions.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to publish to.
+     * @returns An array of IDigitalEventAction objects.
+     */
+
+    function useCrestronPublishDigitalCollection(signalNames) {
+      var signalType = CrestronCH5.SignalType.Boolean;
+      var actions = [];
+      signalNames.forEach(function (signalName) {
+        var setValue = function setValue(value) {
+          ch5Crcomlib.publishEvent(signalType, signalName, value);
+        };
+
+        var push = function push() {
+          setValue(true);
+        };
+
+        var release = function release() {
+          setValue(false);
+        };
+
+        var click = function click() {
+          push();
+          release();
+        }; // const hold = (duration: number, callback: () => void) => {
+        //     push();
+        //     setTimeout(() => {
+        //         release();
+        //         callback();
+        //     }, duration);
+        // };
+
+
+        actions.push({
+          setValue: setValue,
+          push: push,
+          release: release,
+          click: click
+        });
+      });
+      return actions;
+    }
+    var useCrestronPublishBooleanCollection = useCrestronPublishDigitalCollection;
+
+    /**
+     * `useCrestronSubscribeDigitalCollection` is a hook that returns an array of objects each with a value property.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to subscribe to.
+     * @param {DigitalStateCallback} [callback] - An optional callback function that will be called whenever the
+     * state changes.
+     * @returns An array of IDigitalState objects.
+     */
+
+    function useCrestronSubscribeDigitalCollection(signalNames, callback) {
+      var _useState = react.useState(Array.from({
+        length: signalNames.length
+      }).fill({
+        value: false
+      })),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.Boolean;
+        var subscriptions = [];
+        signalNames.forEach(function (signalName, index) {
+          var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+            setState(function (prevState) {
+              var newState = [].concat(prevState);
+              newState[index] = _extends({}, newState[index], {
+                value: value
+              });
+              return newState;
+            });
+
+            if (callbackRef.current) {
+              callbackRef.current(value, signalName);
+            }
+          });
+          subscriptions.push({
+            id: id,
+            signalName: signalName
+          });
+        });
+
+        var unsubscribeAll = function unsubscribeAll() {
+          subscriptions.forEach(function (_ref) {
+            var id = _ref.id,
+                signalName = _ref.signalName;
+            ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+          });
+        };
+
+        return function () {
+          unsubscribeAll();
+        };
+      }, []);
+      return state;
+    }
+    var useCrestronSubscribeBooleanCollection = useCrestronSubscribeDigitalCollection;
+
+    /**
+     * `useCrestronDigitalCollection` is a hook that returns an array of objects each with state and action properties.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to use.
+     * @param {DigitalStateCallback} [callback] - A optional callback function that will be called whenever the state of
+     * the signal changes.
+     * @returns An array of IDigitalSignal objects.
+     */
+
+    function useCrestronDigitalCollection(signalNames, callback) {
+      var state = useCrestronSubscribeDigitalCollection(signalNames, callback);
+      var action = useCrestronPublishDigitalCollection(signalNames);
+      return getSignalCollection(signalNames.length, state, action);
+    }
+    var useCrestronBooleanCollection = useCrestronDigitalCollection;
+
+    /**
+     * `useCrestronPublishSerialCollection` is a hook that returns an array of objects each with a setValue function.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to publish to.
+     * @returns An array of ISerialEventAction objects.
+     */
+
+    function useCrestronPublishSerialCollection(signalNames) {
+      var signalType = CrestronCH5.SignalType.String;
+      var actions = [];
+      signalNames.forEach(function (signalName) {
+        actions.push({
+          setValue: function setValue(value) {
+            return ch5Crcomlib.publishEvent(signalType, signalName, value);
+          }
+        });
+      });
+      return actions;
+    }
+    var useCrestronPublishStringCollection = useCrestronPublishSerialCollection;
+
+    /**
+     * `useCrestronSubscribeSerialCollection` is a hook that returns an array of objects each with a value property.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to subscribe to.
+     * @param {SerialStateCallback} [callback] - An optional callback function that will be called whenever the
+     * state changes.
+     * @returns An array of ISerialState objects.
+     */
+
+    function useCrestronSubscribeSerialCollection(signalNames, callback) {
+      var _useState = react.useState(Array.from({
+        length: signalNames.length
+      }).fill({
+        value: ""
+      })),
+          state = _useState[0],
+          setState = _useState[1];
+
+      var callbackRef = react.useRef();
+      react.useEffect(function () {
+        callbackRef.current = callback;
+      }, [callback]);
+      react.useEffect(function () {
+        var signalType = CrestronCH5.SignalType.String;
+        var subscriptions = [];
+        signalNames.forEach(function (signalName, index) {
+          var id = ch5Crcomlib.subscribeState(signalType, signalName, function (value) {
+            setState(function (prevState) {
+              var newState = [].concat(prevState);
+              newState[index] = _extends({}, newState[index], {
+                value: value
+              });
+              return newState;
+            });
+
+            if (callbackRef.current) {
+              callbackRef.current(value, signalName);
+            }
+          });
+          subscriptions.push({
+            id: id,
+            signalName: signalName
+          });
+        });
+
+        var unsubscribeAll = function unsubscribeAll() {
+          subscriptions.forEach(function (_ref) {
+            var id = _ref.id,
+                signalName = _ref.signalName;
+            ch5Crcomlib.unsubscribeState(signalType, signalName, id);
+          });
+        };
+
+        return function () {
+          unsubscribeAll();
+        };
+      }, []);
+      return state;
+    }
+    var useCrestronSubscribeStringCollection = useCrestronSubscribeSerialCollection;
+
+    /**
+     * `useCrestronSerialCollection` is a hook that returns an array of objects each with state and action properties.
+     * @param {string[]} signalNames - An array of strings that represent the names of the signals you want
+     * to use.
+     * @param {SerialStateCallback} [callback] - A optional callback function that will be called whenever the state of
+     * the signal changes.
+     * @returns An array of ISerialSignal objects.
+     */
+
+    function useCrestronSerialCollection(signalNames, callback) {
+      var state = useCrestronSubscribeSerialCollection(signalNames, callback);
+      var action = useCrestronPublishSerialCollection(signalNames);
+      return getSignalCollection(signalNames.length, state, action);
+    }
+    var useCrestronStringCollection = useCrestronSerialCollection;
+
+    exports.useCrestronAnalog = useCrestronAnalog;
+    exports.useCrestronAnalogCollection = useCrestronAnalogCollection;
+    exports.useCrestronBoolean = useCrestronBoolean;
+    exports.useCrestronBooleanCollection = useCrestronBooleanCollection;
+    exports.useCrestronDigital = useCrestronDigital;
+    exports.useCrestronDigitalCollection = useCrestronDigitalCollection;
+    exports.useCrestronNumber = useCrestronNumber;
+    exports.useCrestronNumberCollection = useCrestronNumberCollection;
+    exports.useCrestronPublishAnalog = useCrestronPublishAnalog;
+    exports.useCrestronPublishAnalogCollection = useCrestronPublishAnalogCollection;
+    exports.useCrestronPublishBoolean = useCrestronPublishBoolean;
+    exports.useCrestronPublishBooleanCollection = useCrestronPublishBooleanCollection;
+    exports.useCrestronPublishDigital = useCrestronPublishDigital;
+    exports.useCrestronPublishDigitalCollection = useCrestronPublishDigitalCollection;
+    exports.useCrestronPublishNumber = useCrestronPublishNumber;
+    exports.useCrestronPublishNumberCollection = useCrestronPublishNumberCollection;
+    exports.useCrestronPublishSerial = useCrestronPublishSerial;
+    exports.useCrestronPublishSerialCollection = useCrestronPublishSerialCollection;
+    exports.useCrestronPublishString = useCrestronPublishString;
+    exports.useCrestronPublishStringCollection = useCrestronPublishStringCollection;
+    exports.useCrestronSerial = useCrestronSerial;
+    exports.useCrestronSerialCollection = useCrestronSerialCollection;
+    exports.useCrestronString = useCrestronString;
+    exports.useCrestronStringCollection = useCrestronStringCollection;
+    exports.useCrestronSubscribeAnalog = useCrestronSubscribeAnalog;
+    exports.useCrestronSubscribeAnalogCollection = useCrestronSubscribeAnalogCollection;
+    exports.useCrestronSubscribeBoolean = useCrestronSubscribeBoolean;
+    exports.useCrestronSubscribeBooleanCollection = useCrestronSubscribeBooleanCollection;
+    exports.useCrestronSubscribeDigital = useCrestronSubscribeDigital;
+    exports.useCrestronSubscribeDigitalCollection = useCrestronSubscribeDigitalCollection;
+    exports.useCrestronSubscribeNumber = useCrestronSubscribeNumber;
+    exports.useCrestronSubscribeNumberCollection = useCrestronSubscribeNumberCollection;
+    exports.useCrestronSubscribeSerial = useCrestronSubscribeSerial;
+    exports.useCrestronSubscribeSerialCollection = useCrestronSubscribeSerialCollection;
+    exports.useCrestronSubscribeString = useCrestronSubscribeString;
+    exports.useCrestronSubscribeStringCollection = useCrestronSubscribeStringCollection;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=react-crestron-ch5-hooks.umd.development.js.map