@openfin/core 25.68.26

package/src/util/http.d.ts

@@ -0,0 +1,11 @@
+import { ClientRequestArgs } from 'http';
+export declare const getProxy: () => {
+    port: string;
+    host: string;
+    username: string;
+    password: string;
+};
+export declare const getRequestOptions: (url: string) => ClientRequestArgs;
+export declare const fetch: (url: string) => Promise<string>;
+export declare const downloadFile: (url: string, writeLocation: string) => Promise<unknown>;
+export declare const fetchJson: (url: string) => Promise<any>;

package/src/util/http.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchJson = exports.downloadFile = exports.fetch = exports.getRequestOptions = exports.getProxy = void 0;
+const url_1 = require("url");
+const fs = require("fs");
+const getProxyVar = () => {
+    return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+};
+exports.getProxy = () => {
+    const parsedUrl = new url_1.URL(getProxyVar());
+    return {
+        port: parsedUrl.port,
+        host: parsedUrl.hostname,
+        username: parsedUrl.username,
+        password: parsedUrl.password
+    };
+};
+exports.getRequestOptions = (url) => {
+    const parsedUrl = new url_1.URL(url);
+    let options;
+    if (getProxyVar() && parsedUrl.hostname !== 'localhost' && parsedUrl.hostname.substring(0, 3) !== '127') {
+        options = {};
+        const proxy = exports.getProxy();
+        options.host = proxy.host;
+        options.port = proxy.port;
+        options.path = url;
+        options.headers = { Host: parsedUrl.hostname };
+        if (proxy.username && proxy.password) {
+            const auth = `Basic ${Buffer.from(`${proxy.username}:${proxy.password}`).toString('base64')}`;
+            Object.assign(options.headers, { 'Proxy-Authorization': auth });
+        }
+    }
+    else {
+        options = parsedUrl;
+    }
+    return options;
+};
+exports.fetch = async (url) => {
+    const requestUrl = getProxyVar() ? getProxyVar() : url;
+    const proto = url_1.parse(requestUrl).protocol.slice(0, -1) === 'http' ? 'http' : 'https';
+    const fetcher = await Promise.resolve().then(() => require(proto));
+    return new Promise((resolve, reject) => {
+        const options = exports.getRequestOptions(url);
+        const request = fetcher.get(options, (response) => {
+            if (response.statusCode < 200 || response.statusCode > 299) {
+                reject(new Error(`Failed to load url: ${url}, status code:${response.statusCode}`));
+            }
+            const body = [];
+            response.on('data', (chunk) => {
+                body.push(chunk);
+            });
+            response.on('end', () => resolve(body.join('')));
+        });
+        request.on('error', (err) => {
+            reject(err);
+        });
+    });
+};
+exports.downloadFile = async (url, writeLocation) => {
+    const requestUrl = getProxyVar() ? getProxyVar() : url;
+    const proto = url_1.parse(requestUrl).protocol.slice(0, -1) === 'http' ? 'http' : 'https';
+    const fetcher = await Promise.resolve().then(() => require(proto));
+    return new Promise((resolve, reject) => {
+        try {
+            const options = exports.getRequestOptions(url);
+            fetcher.get(options, (response) => {
+                const file = fs.createWriteStream(writeLocation);
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+};
+exports.fetchJson = async (url) => {
+    const res = await exports.fetch(url);
+    return JSON.parse(res);
+};

package/src/util/normalize-config.d.ts

@@ -0,0 +1,3 @@
+import { ConnectConfig, InternalConnectConfig, ExternalConfig } from '../transport/wire';
+export declare function normalizeConfig(config: ConnectConfig): Promise<InternalConnectConfig | ExternalConfig>;
+export declare function validateConfig(config: ConnectConfig): Promise<InternalConnectConfig>;

package/src/util/normalize-config.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = exports.normalizeConfig = void 0;
+const fs = require("fs");
+const wire_1 = require("../transport/wire");
+const promises_1 = require("./promises");
+const http_1 = require("./http");
+async function readLocalConfig(location) {
+    const txt = await promises_1.promisify(fs.readFile)(location);
+    return JSON.parse(txt.toString());
+}
+async function loadConfig(config) {
+    try {
+        return await http_1.fetchJson(config.manifestUrl);
+    }
+    catch (e) {
+        try {
+            return await readLocalConfig(config.manifestUrl);
+        }
+        catch (error) {
+            throw new Error(`Could not locate JSON at supplied manifestUrl: ${config.manifestUrl}`);
+        }
+    }
+}
+async function normalizeConfig(config) {
+    const testThisConfig = config;
+    if (wire_1.isExternalConfig(config)) {
+        const loadedConfig = await loadConfig(config);
+        testThisConfig.runtime = loadedConfig.runtime;
+        if (typeof loadedConfig.assetsUrl === 'string') {
+            testThisConfig.assetsUrl = loadedConfig.assetsUrl;
+        }
+        if (Array.isArray(loadedConfig.services)) {
+            testThisConfig.services = loadedConfig.services;
+        }
+    }
+    return testThisConfig;
+}
+exports.normalizeConfig = normalizeConfig;
+async function validateConfig(config) {
+    const normalized = await normalizeConfig(config);
+    if (wire_1.isInternalConnectConfig(normalized)) {
+        return normalized;
+    }
+    throw new Error('Invalid Config');
+}
+exports.validateConfig = validateConfig;

package/src/util/promises.d.ts

@@ -0,0 +1,5 @@
+export declare function promisify(func: Function): (...args: any[]) => Promise<any>;
+export declare function promiseMap<T, S>(arr: T[], asyncF: (x: T, i: number, r: T[]) => Promise<S>): Promise<S[]>;
+export declare type asyncF<T> = (...args: any[]) => Promise<T>;
+export declare function serial<T>(arr: asyncF<T>[]): Promise<T[]>;
+export declare function promiseMapSerial<T>(arr: any[], func: asyncF<T>): Promise<T[]>;

package/src/util/promises.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseMapSerial = exports.serial = exports.promiseMap = exports.promisify = void 0;
+function promisify(func) {
+    return (...args) => new Promise((resolve, reject) => {
+        func(...args, (err, val) => (err ? reject(err) : resolve(val)));
+    });
+}
+exports.promisify = promisify;
+async function promiseMap(arr, asyncF) {
+    return Promise.all(arr.map(asyncF));
+}
+exports.promiseMap = promiseMap;
+async function serial(arr) {
+    const ret = [];
+    for (const func of arr) {
+        // eslint-disable-next-line no-await-in-loop
+        const next = await func();
+        ret.push(next);
+    }
+    return ret;
+}
+exports.serial = serial;
+async function promiseMapSerial(arr, func) {
+    return serial(arr.map((value, index, array) => () => func(value, index, array)));
+}
+exports.promiseMapSerial = promiseMapSerial;

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

@@ -0,0 +1,7 @@
+export default class RefCoutner {
+    topicRefMap: Map<any, any>;
+    incRefCount(key: string): number;
+    decRefCount(key: string): number;
+    actOnFirst(key: string, firstAction: () => any, nonFirstAction: () => {}): any;
+    actOnLast(key: string, lastAction: () => any, nonLastAction: () => {}): any;
+}

package/src/util/ref-counter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RefCoutner {
+    constructor() {
+        this.topicRefMap = new Map();
+    }
+    // returns the ref count after incrementing
+    incRefCount(key) {
+        const refCount = this.topicRefMap.get(key);
+        let returnCount;
+        if (!refCount) {
+            this.topicRefMap.set(key, 1);
+            returnCount = 1;
+        }
+        else {
+            const newRefCount = refCount + 1;
+            returnCount = newRefCount;
+            this.topicRefMap.set(key, newRefCount);
+        }
+        return returnCount;
+    }
+    // returns the ref count after decrementing, or -1 if the key already had no references
+    decRefCount(key) {
+        const refCount = this.topicRefMap.get(key);
+        let returnCount;
+        if (refCount) {
+            const newRefCount = refCount - 1;
+            this.topicRefMap.set(key, newRefCount);
+            returnCount = newRefCount;
+        }
+        else {
+            returnCount = -1;
+        }
+        return returnCount;
+    }
+    // Execute firstAction if it is the first such ref, else execute nonFirstAction.
+    // In either case the return value is that of the action executed
+    actOnFirst(key, firstAction, nonFirstAction) {
+        const numRefs = this.incRefCount(key);
+        const isFirstRef = numRefs === 1;
+        return isFirstRef ? firstAction() : nonFirstAction();
+    }
+    // Execute lastAction if it is the first such ref, else execute nonLastAction.
+    // In either case the return value is that of the action executed
+    actOnLast(key, lastAction, nonLastAction) {
+        const numRefs = this.decRefCount(key);
+        const isLastRef = numRefs === 0;
+        return isLastRef ? lastAction() : nonLastAction();
+    }
+}
+exports.default = RefCoutner;

package/src/util/runtimeVersioning.d.ts

@@ -0,0 +1,3 @@
+export declare function meetsMinimumRuntimeVersion(currentVersion: string, minVersion: string): boolean;
+export declare function parseRuntimeUuid(runtimeUuid: string): string;
+export declare function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid: string, minVersion: string): boolean;

package/src/util/runtimeVersioning.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeUuidMeetsMinimumRuntimeVersion = exports.parseRuntimeUuid = exports.meetsMinimumRuntimeVersion = void 0;
+function vNum(x) {
+    return [...x.split('.').reverse().entries()].reduce((p, [i, v]) => p + +v * 10000 ** i, 0);
+}
+/*
+  Compares runtime versions to see if the current runtime meets your desired minimum.
+*/
+function meetsMinimumRuntimeVersion(currentVersion, minVersion) {
+    const currentVersionParsed = vNum(currentVersion);
+    const minVersionParsed = vNum(minVersion);
+    return currentVersionParsed >= minVersionParsed;
+}
+exports.meetsMinimumRuntimeVersion = meetsMinimumRuntimeVersion;
+// Strips the port info from the runtimeUuid, leaving just the runtime version.
+function parseRuntimeUuid(runtimeUuid) {
+    return runtimeUuid.split('/')[0];
+}
+exports.parseRuntimeUuid = parseRuntimeUuid;
+function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {
+    const runtimeVersion = parseRuntimeUuid(runtimeUuid);
+    return meetsMinimumRuntimeVersion(runtimeVersion, minVersion);
+}
+exports.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;

package/src/util/utilTypes.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Recursive completion of a type.  Useful if a type contains optional props (and subprops)
+ * which are always populated in certain contexts.  A `DeepPick` type would be even better,
+ * but no reliable implementation of one appears to exist yet.
+ */
+export declare type Complete<T extends {}> = T & {
+    [MK in keyof T]-?: Complete<NonNullable<T[MK]>>;
+};

package/src/util/utilTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/util/validate.d.ts

@@ -0,0 +1,3 @@
+export declare function validateIdentity(identity: {
+    uuid: any;
+}): string | undefined;

package/src/util/validate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIdentity = void 0;
+function validateIdentity(identity) {
+    let errorMsg;
+    if (typeof identity !== 'object' || typeof identity.uuid !== 'string') {
+        errorMsg = 'Not a valid identity object';
+    }
+    return errorMsg;
+}
+exports.validateIdentity = validateIdentity;