@openfin/core 31.74.6 → 31.74.8

package/src/util/channel-api-relay.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRelayedDispatch = exports.relayChannelClientApi = void 0;
+const EXPECTED_ERRORS = [
+    'no longer connected',
+    'RTCDataChannel closed unexpectedly',
+    'The client you are trying to dispatch from is disconnected from the target provider',
+];
+// Checks possible error messages that we want to trap, client error message can originate
+// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose
+const isDisconnectedError = (errorMsg) => {
+    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));
+};
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+const relayChannelClientApi = async (channelProvider, relayId) => {
+    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
+        return channelProvider.dispatch(target, action, payload);
+    });
+    await Promise.resolve();
+};
+exports.relayChannelClientApi = relayChannelClientApi;
+const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
+    try {
+        return await client.dispatch(`relay:${relayId}`, {
+            action,
+            payload,
+            target
+        });
+    }
+    catch (e) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        ;
+        throw e;
+    }
+};
+exports.createRelayedDispatch = createRelayedDispatch;

package/src/util/lazy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+export declare class Lazy<T> {
+    private producerFn;
+    constructor(producerFn: () => T);
+    private value;
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue(): T;
+}

package/src/util/lazy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+class Lazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue() {
+        if (!this.value) {
+            this.value = this.producerFn();
+        }
+        return this.value;
+    }
+}
+exports.Lazy = Lazy;

package/src/util/ref-counter.d.ts

@@ -1,4 +1,4 @@
-export default class RefCoutner {
+export declare class RefCounter {
     topicRefMap: Map<any, any>;
     incRefCount(key: string): number;
     decRefCount(key: string): number;

package/src/util/ref-counter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class RefCoutner {
+exports.RefCounter = void 0;
+class RefCounter {
     constructor() {
         this.topicRefMap = new Map();
     }
@@ -48,4 +49,4 @@ class RefCoutner {
         return isLastRef ? lastAction() : nonLastAction();
     }
 }
-exports.default = RefCoutner;
+exports.RefCounter = RefCounter;

package/src/util/reversible-map.d.ts

@@ -0,0 +1,11 @@
+export declare class ReversibleMap<TKey extends string | number | symbol, TValue extends Object | string | number> {
+    private readonly valueToKey;
+    private readonly keyToValue;
+    setUnique: (key: TKey, value: TValue) => void;
+    getKey: (value: TValue) => TKey;
+    getValue(key: TKey): TValue;
+    deleteKey: (key: TKey) => TValue | undefined;
+    deleteValue: (value: TValue) => TKey | undefined;
+    hasKey: (key: TKey) => boolean;
+    hasValue: (value: TValue) => boolean;
+}

package/src/util/reversible-map.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReversibleMap = void 0;
+class ReversibleMap {
+    constructor() {
+        this.valueToKey = new Map();
+        this.keyToValue = new Map();
+        this.setUnique = (key, value) => {
+            if (this.hasKey(key) || this.hasValue(value)) {
+                throw new Error('Key or value already in the map.');
+            }
+            this.keyToValue.set(key, value);
+            this.valueToKey.set(value, key);
+        };
+        this.getKey = (value) => {
+            const existingKey = this.valueToKey.get(value);
+            if (!existingKey) {
+                throw new Error('Value not found in the map.');
+            }
+            return existingKey;
+        };
+        this.deleteKey = (key) => {
+            const value = this.getValue(key);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return value;
+        };
+        this.deleteValue = (value) => {
+            const key = this.getKey(value);
+            this.keyToValue.delete(key);
+            this.valueToKey.delete(value);
+            return key;
+        };
+        this.hasKey = (key) => {
+            return this.keyToValue.has(key);
+        };
+        this.hasValue = (value) => {
+            return this.valueToKey.has(value);
+        };
+    }
+    getValue(key) {
+        const item = this.keyToValue.get(key);
+        if (!item) {
+            throw new Error('Key not found in the map.');
+        }
+        return item;
+    }
+}
+exports.ReversibleMap = ReversibleMap;