@equinor/echo-framework 0.7.3 → 0.7.6

package/dist/__tests__/realTimeDataHooks.test.d.ts

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

package/dist/__tests__/realTimeDataUtils.test.d.ts

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

package/dist/_virtual/_tslib.js

@@ -18,6 +18,19 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
 
+function __rest(s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function (resolve) {
@@ -51,3 +64,4 @@ function __awaiter(thisArg, _arguments, P, generator) {
 }
 
 exports.__awaiter = __awaiter;
+exports.__rest = __rest;

package/dist/components/errorBoundary/errorBoundary.d.ts

@@ -5,6 +5,7 @@ interface ErrorBoundaryState {
 }
 export interface ErrorBoundaryProps {
     onComponentDidCatch?: (error: Error, errorInfo: ErrorInfo) => void;
+    children?: React.ReactNode;
 }
 export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
     constructor(props: Readonly<ErrorBoundaryProps>);

package/dist/components/index.d.ts

@@ -10,6 +10,7 @@ export * from './panel';
 export * from './panelButton';
 export * from './plantSelector';
 export * from './projectSelector';
+export * from './realTimeData';
 export * from './router';
 export * from './searchMenu';
 export * from './toaster';

package/dist/components/panel/corePanelLeft.d.ts

@@ -1,3 +1,6 @@
 import React from 'react';
-declare const CorePanelLeft: React.FC;
+interface CorePanelLeftProps {
+    isToggleButtonVisible?: boolean;
+}
+declare const CorePanelLeft: React.FC<CorePanelLeftProps>;
 export default CorePanelLeft;

package/dist/components/panel/corePanelRight.d.ts

@@ -1,3 +1,6 @@
 import React from 'react';
-declare const _default: React.NamedExoticComponent<{}>;
+interface CorePanelRightProps {
+    isToggleButtonVisible?: boolean;
+}
+declare const _default: React.NamedExoticComponent<CorePanelRightProps>;
 export default _default;

package/dist/components/realTimeData/RealTimePopoverButton.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+interface RTDProps {
+    tagNo: string;
+    /**
+     * Callback for whenever RTD popover is to be opened. Could be used to handle closing of other popovers.
+     */
+    onOpen?: () => void;
+}
+/**
+ * ContextMenu button for displaying Real-Time-Data from connected sensors.
+ * @param {RTDProps} {
+ * tagNo: The tagNo to check for connected IMS tags.
+ * onOpen: Optional callback for whenever RTD popover is being opened
+ * }
+ * @return {*}
+ */
+declare function RealTimePopoverButton({ tagNo, onOpen }: RTDProps): JSX.Element | null;
+export { RealTimePopoverButton };

package/dist/components/realTimeData/components/IMSDropdown/RealTimeIMSDropdown.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { AdditionalFieldDto } from '@equinor/echo-search';
+interface Props {
+    imsFields: AdditionalFieldDto[];
+}
+declare function RealTimeIMSDropdown({ imsFields }: Props): JSX.Element;
+export { RealTimeIMSDropdown };

package/dist/components/realTimeData/components/IMSDropdown/index.d.ts

@@ -0,0 +1 @@
+export * from './RealTimeIMSDropdown';

package/dist/components/realTimeData/components/connectorForIMSTag/RealTimeConnectorForIMSTag.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+interface Props {
+    ims: string;
+}
+declare function RealTimeConnectorForIMSTag({ ims }: Props): JSX.Element;
+export { RealTimeConnectorForIMSTag };

package/dist/components/realTimeData/components/connectorForIMSTag/index.d.ts

@@ -0,0 +1 @@
+export * from './RealTimeConnectorForIMSTag';

package/dist/components/realTimeData/components/contextButton/RealTimeContextButton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    onOpen?: () => void;
+}
+export declare const RealTimeContextButton: React.FC<Props>;
+export {};

package/dist/components/realTimeData/components/contextButton/index.d.ts

@@ -0,0 +1 @@
+export * from './RealTimeContextButton';

package/dist/components/realTimeData/components/contextPopover/Popover.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/**
+ * Generic Popover placement component that can take in optional background color
+ */
+declare const ContextPopover: React.FC;
+export { ContextPopover };

package/dist/components/realTimeData/components/contextPopover/index.d.ts

@@ -0,0 +1 @@
+export * from './Popover';

package/dist/components/realTimeData/components/index.d.ts

@@ -0,0 +1,4 @@
+export * from './connectorForIMSTag';
+export * from './contextButton';
+export * from './contextPopover';
+export * from './IMSDropdown';

package/dist/components/realTimeData/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useSignalR';
+export * from './useSignalRListener';
+export * from './useRealTimeHub';

package/dist/components/realTimeData/hooks/useRealTimeHub.d.ts

@@ -0,0 +1,13 @@
+import { SignalRState } from './useSignalR';
+import { IMSByName } from '../../../types/realtimedata';
+interface RealTimeData extends SignalRState {
+    metadata?: IMSByName;
+    present?: SignalRData;
+}
+declare type SignalRData = {
+    time: Date;
+    value: number;
+    status: number;
+};
+export declare function useRealTimeHub(id: string, instCode?: string | null): RealTimeData;
+export {};

package/dist/components/realTimeData/hooks/useSignalR.d.ts

@@ -0,0 +1,9 @@
+import { HubConnection } from '@microsoft/signalr';
+export interface SignalRState {
+    connection?: HubConnection;
+    status: string;
+    loading: boolean;
+    message?: string;
+}
+declare function useSignalR(hubUrl: string): SignalRState;
+export { useSignalR };

package/dist/components/realTimeData/hooks/useSignalRListener.d.ts

@@ -0,0 +1,4 @@
+import { HubConnection } from '@microsoft/signalr';
+declare type HubMethod = (...args: any[]) => void;
+export declare function useSignalRListener(hubConnection: HubConnection | undefined, target: string, method: HubMethod): void;
+export {};

package/dist/components/realTimeData/index.d.ts

@@ -0,0 +1 @@
+export * from './RealTimePopoverButton';

package/dist/coreApplication/EchoBarComponent.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface EchoBottomBarProps {
+    isLandscape: boolean;
+}
+export declare const EchoBarComponent: React.FC<EchoBottomBarProps>;
+export default EchoBarComponent;

package/dist/coreApplication/EchoContent.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 interface CorePanelsProps {
     children: React.ReactNode;
     Legend?: React.FC;
+    isToggleButtonVisible?: boolean;
 }
 export declare const EchoContent: React.FC<CorePanelsProps>;
 export {};

package/dist/coreApplication/index.d.ts

@@ -1,3 +1,4 @@
+export * from './EchoBarComponent';
 export * from './EchoContent';
 export * from './EchoContentPanels';
 export * from './EchoEventHandler';

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useIsLandscape';

package/dist/hooks/useIsLandscape.d.ts

@@ -0,0 +1 @@
+export declare function useIsLandscape(): boolean;

package/dist/index.d.ts

@@ -6,6 +6,8 @@ import './theme/theme.css';
 import { getLegendStatusColor } from './utils/legendUtils';
 export * from './components';
 export * from './coreApplication';
+export * from './hooks';
+export { RegisteredHookName } from './hooks/hookLibrary';
 export { RegisteredComponentName } from './services/componentRegistry/componentRegistry';
 export * from './services/eventHubActions';
 export * from './theme/themeConst';
@@ -17,7 +19,6 @@ export type { ModelPermissions } from './types/modelPermissions';
 export * from './utils';
 export { getLegendStatusColor, legendTypeToLegendStatus } from './utils/legendUtils';
 export * from './utils/startup';
-export { RegisteredHookName } from './hooks/hookLibrary';
 export declare const registerEchopediaComponent: ({ name, component }: {
     name: import("./services/componentRegistry/componentRegistry").RegisteredComponentName;
     component: import("react").FunctionComponent<any>;

package/dist/node_modules/@microsoft/signalr/dist/esm/AbortController.js

@@ -0,0 +1,54 @@
+'use strict';
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// Rough polyfill of https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+// We don't actually ever use the API being polyfilled, we always use the polyfill because
+// it's a very new API right now.
+// Not exported from index.
+
+/** @private */
+
+var AbortController = /*#__PURE__*/function () {
+  function AbortController() {
+    _classCallCheck(this, AbortController);
+
+    this._isAborted = false;
+    this.onabort = null;
+  }
+
+  _createClass(AbortController, [{
+    key: "abort",
+    value: function abort() {
+      if (!this._isAborted) {
+        this._isAborted = true;
+
+        if (this.onabort) {
+          this.onabort();
+        }
+      }
+    }
+  }, {
+    key: "signal",
+    get: function get() {
+      return this;
+    }
+  }, {
+    key: "aborted",
+    get: function get() {
+      return this._isAborted;
+    }
+  }]);
+
+  return AbortController;
+}();
+
+exports.AbortController = AbortController;

package/dist/node_modules/@microsoft/signalr/dist/esm/DefaultHttpClient.js

@@ -0,0 +1,96 @@
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+var Errors = require('./Errors.js');
+
+var FetchHttpClient = require('./FetchHttpClient.js');
+
+var HttpClient = require('./HttpClient.js');
+
+var Utils = require('./Utils.js');
+
+var XhrHttpClient = require('./XhrHttpClient.js'); // Licensed to the .NET Foundation under one or more agreements.
+
+/** Default implementation of {@link @microsoft/signalr.HttpClient}. */
+
+
+var DefaultHttpClient = /*#__PURE__*/function (_HttpClient$HttpClien) {
+  _inherits(DefaultHttpClient, _HttpClient$HttpClien);
+
+  var _super = _createSuper(DefaultHttpClient);
+
+  /** Creates a new instance of the {@link @microsoft/signalr.DefaultHttpClient}, using the provided {@link @microsoft/signalr.ILogger} to log messages. */
+  function DefaultHttpClient(logger) {
+    var _this;
+
+    _classCallCheck(this, DefaultHttpClient);
+
+    _this = _super.call(this);
+
+    if (typeof fetch !== "undefined" || Utils.Platform.isNode) {
+      _this._httpClient = new FetchHttpClient.FetchHttpClient(logger);
+    } else if (typeof XMLHttpRequest !== "undefined") {
+      _this._httpClient = new XhrHttpClient.XhrHttpClient(logger);
+    } else {
+      throw new Error("No usable HttpClient found.");
+    }
+
+    return _this;
+  }
+  /** @inheritDoc */
+
+
+  _createClass(DefaultHttpClient, [{
+    key: "send",
+    value: function send(request) {
+      // Check that abort was not signaled before calling send
+      if (request.abortSignal && request.abortSignal.aborted) {
+        return Promise.reject(new Errors.AbortError());
+      }
+
+      if (!request.method) {
+        return Promise.reject(new Error("No method defined."));
+      }
+
+      if (!request.url) {
+        return Promise.reject(new Error("No url defined."));
+      }
+
+      return this._httpClient.send(request);
+    }
+  }, {
+    key: "getCookieString",
+    value: function getCookieString(url) {
+      return this._httpClient.getCookieString(url);
+    }
+  }]);
+
+  return DefaultHttpClient;
+}(HttpClient.HttpClient);
+
+exports.DefaultHttpClient = DefaultHttpClient;

package/dist/node_modules/@microsoft/signalr/dist/esm/DefaultReconnectPolicy.js

@@ -0,0 +1,47 @@
+'use strict';
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+}); // Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// 0, 2, 10, 30 second delays before reconnect attempts.
+
+var DEFAULT_RETRY_DELAYS_IN_MILLISECONDS = [0, 2000, 10000, 30000, null];
+/** @private */
+
+var DefaultReconnectPolicy = /*#__PURE__*/function () {
+  function DefaultReconnectPolicy(retryDelays) {
+    _classCallCheck(this, DefaultReconnectPolicy);
+
+    this._retryDelays = retryDelays !== undefined ? [].concat(_toConsumableArray(retryDelays), [null]) : DEFAULT_RETRY_DELAYS_IN_MILLISECONDS;
+  }
+
+  _createClass(DefaultReconnectPolicy, [{
+    key: "nextRetryDelayInMilliseconds",
+    value: function nextRetryDelayInMilliseconds(retryContext) {
+      return this._retryDelays[retryContext.previousRetryCount];
+    }
+  }]);
+
+  return DefaultReconnectPolicy;
+}();
+
+exports.DefaultReconnectPolicy = DefaultReconnectPolicy;