@8ms/helpers 1.40.6 → 1.40.10

package/swr/isAnyLoading.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Are any of SWRs loading
+ */
+export declare const isAnyLoading: ({ swrs }: {
+    swrs: any;
+}) => boolean;
+export default isAnyLoading;

package/swr/isAnyLoading.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnyLoading = void 0;
+const isLoading_1 = __importDefault(require("./isLoading"));
+/**
+ * Are any of SWRs loading
+ */
+const isAnyLoading = ({ swrs }) => {
+    let fetcherLoading = 0;
+    for (const swr in swrs) {
+        if ((0, isLoading_1.default)({ swr: swrs[swr] })) {
+            fetcherLoading++;
+        }
+    }
+    return fetcherLoading > 0;
+};
+exports.isAnyLoading = isAnyLoading;
+exports.default = exports.isAnyLoading;

package/swr/isData.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check to see if a single SWR has an error.
+ */
+declare const isData: ({ swr }: {
+    swr: any;
+}) => boolean;
+export default isData;

package/swr/isData.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Check to see if a single SWR has an error.
+ */
+const isData = ({ swr }) => (undefined === swr.error || null === swr.error) &&
+    undefined !== swr.data &&
+    'undefined' !== swr.data;
+exports.default = isData;

package/swr/isError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check to see if a single SWR has an error.
+ */
+declare const isError: ({ swr }: {
+    swr: any;
+}) => boolean;
+export default isError;

package/swr/isError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Check to see if a single SWR has an error.
+ */
+const isError = ({ swr }) => undefined !== swr.error && null !== swr.error;
+exports.default = isError;

package/swr/isLoading.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check to see if a single SWR is loading.
+ */
+declare const isLoading: ({ swr }: {
+    swr: any;
+}) => boolean;
+export default isLoading;

package/swr/isLoading.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isData_1 = __importDefault(require("./isData"));
+const isError_1 = __importDefault(require("./isError"));
+/**
+ * Check to see if a single SWR is loading.
+ */
+const isLoading = ({ swr }) => !(0, isError_1.default)({ swr }) && !(0, isData_1.default)({ swr });
+exports.default = isLoading;

package/upTimeRobot/getMonitors.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isArray_1 = __importDefault(require("lodash/isArray"));
+const post_1 = __importDefault(require("../axios/post"));
+/**
+ * Use the Up Time Robot API to retrieve up to 50 monitors at a time.
+ * https://uptimerobot.com/api/
+ */
+const getMonitors = async ({ apiKey, params }) => {
+    let finalParams = {};
+    if (undefined !== params) {
+        finalParams = {
+            ...params,
+        };
+        if (undefined !== params.monitors && (0, isArray_1.default)(params.monitors)) {
+            finalParams['monitors'] = params.monitors.join('-');
+        }
+        if (undefined !== params.statuses && (0, isArray_1.default)(params.statuses)) {
+            finalParams['statuses'] = params.statuses.join('-');
+        }
+        if (undefined !== params.types && (0, isArray_1.default)(params.types)) {
+            finalParams['types'] = params.types.join('-');
+        }
+    }
+    const response = await (0, post_1.default)({
+        data: finalParams,
+        url: `https://api.uptimerobot.com/v2/getMonitors?api_key=${apiKey}`,
+    });
+    return response;
+};

package/upTimeRobot/logTypes.d.ts

@@ -0,0 +1,7 @@
+declare const logTypes: {
+    DOWN: number;
+    UP: number;
+    PAUSED: number;
+    STARTED: number;
+};
+export default logTypes;

package/upTimeRobot/logTypes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logTypes = {
+    DOWN: 1,
+    UP: 2,
+    PAUSED: 99,
+    STARTED: 98,
+};
+exports.default = logTypes;

package/upTimeRobot/monitorStatuses.d.ts

@@ -0,0 +1,8 @@
+declare const monitorStatuses: {
+    PAUSED: number;
+    NOT_CHECKED: number;
+    UP: number;
+    SEEMS_DOWN: number;
+    DOWN: number;
+};
+export default monitorStatuses;

package/upTimeRobot/monitorStatuses.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const monitorStatuses = {
+    PAUSED: 0,
+    NOT_CHECKED: 1,
+    UP: 2,
+    SEEMS_DOWN: 8,
+    DOWN: 9,
+};
+exports.default = monitorStatuses;

package/upTimeRobot/monitorSubTypes.d.ts

@@ -0,0 +1,10 @@
+declare const monitorSubTypes: {
+    HTTP: number;
+    HTTPS: number;
+    FTP: number;
+    SMTP: number;
+    POP3: number;
+    IMAP: number;
+    CUSTOM_PORT: number;
+};
+export default monitorSubTypes;

package/upTimeRobot/monitorSubTypes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const monitorSubTypes = {
+    HTTP: 1,
+    HTTPS: 2,
+    FTP: 3,
+    SMTP: 4,
+    POP3: 5,
+    IMAP: 6,
+    CUSTOM_PORT: 99,
+};
+exports.default = monitorSubTypes;

package/upTimeRobot/monitorTypes.d.ts

@@ -0,0 +1,8 @@
+declare const monitorTypes: {
+    HTTPS: number;
+    KEYWORD: number;
+    PING: number;
+    PORT: number;
+    HEARTBEAT: number;
+};
+export default monitorTypes;

package/upTimeRobot/monitorTypes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const monitorTypes = {
+    HTTPS: 1,
+    KEYWORD: 2,
+    PING: 3,
+    PORT: 4,
+    HEARTBEAT: 5,
+};
+exports.default = monitorTypes;

package/upTimeRobot/requestStatuses.d.ts

@@ -0,0 +1,5 @@
+declare const requestStatuses: {
+    ERROR: string;
+    SUCCESS: string;
+};
+export default requestStatuses;

package/upTimeRobot/requestStatuses.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const requestStatuses = {
+    ERROR: 'fail',
+    SUCCESS: 'ok',
+};
+exports.default = requestStatuses;

package/url/buildParameters.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Take an object and return the parameter for a given URL irrespective of path.
+ */
+declare const buildParameters: ({ existing, updated }: {
+    existing: object;
+    updated: object;
+}) => string;
+export default buildParameters;

package/url/buildParameters.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge_1 = __importDefault(require("lodash/merge"));
+/**
+ * Take an object and return the parameter for a given URL irrespective of path.
+ */
+const buildParameters = ({ existing, updated }) => {
+    const merged = (0, merge_1.default)(existing, updated);
+    let response = '';
+    if (Object.values(merged).length) {
+        for (const key in merged) {
+            const value = undefined === updated[key] ? existing[key] : updated[key];
+            response += '' === response ? '?' : '&';
+            response += `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+        }
+    }
+    return response;
+};
+exports.default = buildParameters;

package/url/buildRelative.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create a new relative URL based on the current path.
+ */
+declare const buildRelative: ({ router, updated }: {
+    router: any;
+    updated: object;
+}) => string;
+export default buildRelative;

package/url/buildRelative.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const buildParameters_1 = __importDefault(require("./buildParameters"));
+/**
+ * Create a new relative URL based on the current path.
+ */
+const buildRelative = ({ router, updated }) => {
+    return `${router.pathname}${(0, buildParameters_1.default)({ existing: router.query, updated: updated || {} })}`;
+};
+exports.default = buildRelative;

package/url/buildUrl.d.ts

@@ -0,0 +1,10 @@
+import { Url } from './url';
+type BuildUrlType = {
+    path: string;
+    url: Url;
+};
+/**
+ * Get the current base url.
+ */
+declare const buildUrl: ({ path, url }: BuildUrlType) => string;
+export default buildUrl;

package/url/buildUrl.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isDevelopment_1 = __importDefault(require("../environment/isDevelopment"));
+const isLocalhost_1 = __importDefault(require("../environment/isLocalhost"));
+const isProduction_1 = __importDefault(require("../environment/isProduction"));
+const isStaging_1 = __importDefault(require("../environment/isStaging"));
+/**
+ * Get the current base url.
+ */
+const buildUrl = ({ path, url }) => {
+    let response;
+    if ((0, isDevelopment_1.default)() && (0, isLocalhost_1.default)()) {
+        response = url.localhost;
+    }
+    else if ((0, isStaging_1.default)()) {
+        response = url.staging;
+    }
+    else if ((0, isProduction_1.default)()) {
+        response = url.production;
+    }
+    else {
+        response = url.development;
+    }
+    return response + path || '';
+};
+exports.default = buildUrl;

package/url/isAbsolute.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Does the URL begin with HTTP or HTTPS?
+ */
+declare const isAbsolute: ({ input }: {
+    input: string;
+}) => boolean;
+export default isAbsolute;

package/url/isAbsolute.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Does the URL begin with HTTP or HTTPS?
+ */
+const isAbsolute = ({ input }) => {
+    try {
+        new URL(input);
+    }
+    catch (error) {
+        return false;
+    }
+    return true;
+};
+exports.default = isAbsolute;

package/url/isRelative.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Does the URL begin with a slash.
+ */
+declare const isRelative: ({ input }: {
+    input: string;
+}) => boolean;
+export default isRelative;

package/url/isRelative.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Does the URL begin with a slash.
+ */
+const isRelative = ({ input }) => '/' === input.trim()
+    .charAt(0);
+exports.default = isRelative;

package/url/url.d.ts

@@ -0,0 +1,6 @@
+export type Url = {
+    localhost: string;
+    development: string;
+    staging: string;
+    production: string;
+};

package/url/url.js

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

package/url/writeUrlContents.d.ts

@@ -0,0 +1,11 @@
+type WriteUrlContents = {
+    filePath: string;
+    url: string;
+};
+/**
+ * Downloads a given URL's contents to a local file.
+ *
+ * Requires fs-extra
+ */
+declare const saveUrlContents: ({ filePath, url }: WriteUrlContents) => Promise<void>;
+export default saveUrlContents;

package/url/writeUrlContents.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ky_1 = __importDefault(require("ky"));
+const stream_1 = require("stream");
+const createDirectory_1 = __importDefault(require("../file/createDirectory"));
+/**
+ * Downloads a given URL's contents to a local file.
+ *
+ * Requires fs-extra
+ */
+const saveUrlContents = async ({ filePath, url }) => {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs-extra")));
+    await (0, createDirectory_1.default)({
+        filePath,
+    });
+    const writer = fs.createWriteStream(filePath);
+    const response = await ky_1.default.get(url);
+    const stream = stream_1.Readable.fromWeb(response.body);
+    await new Promise((resolve, reject) => {
+        stream.pipe(writer);
+        let error = null;
+        writer.on("error", err => {
+            error = err;
+            writer.close();
+            reject(err);
+        });
+        writer.on("close", () => {
+            if (!error) {
+                resolve();
+            }
+            //no need to call the reject here, as it will have been called in the
+            //'error' stream;
+        });
+    });
+};
+exports.default = saveUrlContents;

package/util/defaultTo.d.ts

@@ -0,0 +1,10 @@
+type DefaultTo = {
+    defaultValue: any;
+    instance: any;
+    keys: any | any[];
+};
+/**
+ * Function to default to a value, whilst filtering through an instance
+ */
+declare const defaultTo: (props: DefaultTo) => any;
+export default defaultTo;

package/util/defaultTo.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isObject_1 = __importDefault(require("lodash/isObject"));
+const getArray_1 = __importDefault(require("../array/getArray"));
+/**
+ * Function to default to a value, whilst filtering through an instance
+ */
+const defaultTo = (props) => {
+    const keysArray = (0, getArray_1.default)({
+        input: props.keys
+    });
+    let found = true;
+    let pointer = props.instance;
+    // Instance is undefined or is null
+    if (undefined === props.instance || null === pointer) {
+        found = false;
+    }
+    // Instance exists
+    else {
+        keysArray.forEach(key => {
+            if (found) {
+                // Sub key doesn't exist
+                if ((0, isObject_1.default)(pointer)) {
+                    if (undefined === pointer[key] || null === pointer[key]) {
+                        found = false;
+                    }
+                    // Sub key exists, update pointer
+                    else {
+                        pointer = pointer[key];
+                    }
+                }
+                else {
+                    found = false;
+                }
+            }
+        });
+    }
+    return found ? pointer : props.defaultValue;
+};
+exports.default = defaultTo;

package/util/getBrotliCompressed.d.ts

@@ -0,0 +1,9 @@
+type GetBrotliCompressed = {
+    input?: any;
+    options?: object;
+};
+/**
+ * Compress a given input using Brotli.
+ */
+declare const getBrotliCompressed: ({ input, options }?: GetBrotliCompressed) => Promise<unknown>;
+export default getBrotliCompressed;

package/util/getBrotliCompressed.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Compress a given input using Brotli.
+ */
+const getBrotliCompressed = async ({ input, options } = {}) => {
+    return new Promise(async (resolve, reject) => {
+        const zlib = require('zlib');
+        zlib.brotliCompress(input || '', options || {}, (err, data) => {
+            if (err) {
+                reject(`Error compressing - ${err.code}`);
+            }
+            else {
+                resolve(data.toString('base64'));
+            }
+        });
+    });
+};
+exports.default = getBrotliCompressed;

package/util/getBrotliDecompressed.d.ts

@@ -0,0 +1,9 @@
+type GetBrotliDecompressed = {
+    input?: any;
+    options?: object;
+};
+/**
+ * Decompress a given Brotli input into a string.
+ */
+declare const getBrotliDecompressed: ({ input, options }?: GetBrotliDecompressed) => Promise<unknown>;
+export default getBrotliDecompressed;

package/util/getBrotliDecompressed.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Decompress a given Brotli input into a string.
+ */
+const getBrotliDecompressed = async ({ input, options } = {}) => {
+    return new Promise(async (resolve, reject) => {
+        const zlib = require('zlib');
+        const compressedData = Buffer.from(input || '', "base64");
+        zlib.brotliDecompress(compressedData, options || {}, (err, data) => {
+            if (err) {
+                reject(`Error decompressing - ${err.code}`);
+            }
+            else {
+                resolve(data.toString('utf8'));
+            }
+        });
+    });
+};
+exports.default = getBrotliDecompressed;

package/util/getClean.d.ts

@@ -0,0 +1,11 @@
+type GetClean = {
+    hash?: boolean;
+    input: string;
+    lowercase?: boolean;
+    parameter?: boolean;
+};
+/**
+ * Return a clean URL with a few options.
+ */
+declare const getClean: ({ hash, input, lowercase, parameter }: GetClean) => string;
+export default getClean;

package/util/getClean.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getWithoutParameter_1 = __importDefault(require("./getWithoutParameter"));
+const getWithoutHash_1 = __importDefault(require("./getWithoutHash"));
+/**
+ * Return a clean URL with a few options.
+ */
+const getClean = ({ hash, input, lowercase, parameter }) => {
+    let response = input.trim();
+    if (parameter) {
+        response = (0, getWithoutParameter_1.default)({
+            input: response,
+        });
+    }
+    if (hash) {
+        response = (0, getWithoutHash_1.default)({
+            input: response,
+        });
+    }
+    if (lowercase) {
+        response = response.toLowerCase();
+    }
+    return response;
+};
+exports.default = getClean;

package/util/getGzipCompressed.d.ts

@@ -0,0 +1,9 @@
+type GetGzipCompressed = {
+    input?: any;
+    options?: object;
+};
+/**
+ * Compress a given input using Gzip.
+ */
+declare const getGzipCompressed: ({ input, options }?: GetGzipCompressed) => Promise<unknown>;
+export default getGzipCompressed;

package/util/getGzipCompressed.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Compress a given input using Gzip.
+ */
+const getGzipCompressed = async ({ input, options } = {}) => {
+    return new Promise(async (resolve, reject) => {
+        const zlib = require('zlib');
+        zlib.gzip(input || '', options || {}, (err, data) => {
+            if (err) {
+                reject(`Error compressing - ${err.code}`);
+            }
+            else {
+                resolve(data.toString('base64'));
+            }
+        });
+    });
+};
+exports.default = getGzipCompressed;