@8ms/helpers 1.39.0 → 2.0.1

package/number/{getCurrency.d.ts → formatCurrency.d.ts}

@@ -1,10 +1,5 @@
-type GetCurrency = {
-    currency: string;
-    input: any;
-};
 /**
  * Use the International number formatting to return the currency value.
  * https://www.freecodecamp.org/news/how-to-format-number-as-currency-in-javascript-one-line-of-code/
  */
-declare const getCurrency: ({ currency, input }: GetCurrency) => string;
-export default getCurrency;
+export declare const formatCurrency: (input: any, locale?: string, currency?: string) => string;

package/number/{getCurrency.js → formatCurrency.js}

@@ -1,20 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrency = void 0;
 /**
  * Use the International number formatting to return the currency value.
  * https://www.freecodecamp.org/news/how-to-format-number-as-currency-in-javascript-one-line-of-code/
  */
-const getCurrency = ({ currency, input }) => {
+const formatCurrency = (input, locale = "en-GB", currency = "GBP") => {
     const value = Number(input);
     const currencyClean = currency.toUpperCase()
         .trim();
-    let formatted = new Intl.NumberFormat('en-GB', {
-        style: 'currency',
+    let formatted = new Intl.NumberFormat(locale, {
+        style: "currency",
         currency: currencyClean,
     }).format(value);
-    if ('USD' === currencyClean) {
-        formatted = formatted.replace('US$', '$');
+    if ("USD" === currencyClean) {
+        formatted = formatted.replace("US$", "$");
     }
     return formatted;
 };
-exports.default = getCurrency;
+exports.formatCurrency = formatCurrency;

package/number/getDecimal.d.ts

@@ -1,9 +1,4 @@
-type GetDecimal = {
-    dp?: number;
-    input: any;
-};
 /**
  * Return a decimal number after rounding.
  */
-declare const getDecimal: (props: GetDecimal) => number;
-export default getDecimal;
+export declare const getDecimal: (input: any, dp?: number) => number;

package/number/getDecimal.js

@@ -1,16 +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 getNumber_1 = __importDefault(require("./getNumber"));
+exports.getDecimal = void 0;
+const getNumber_1 = require("./getNumber");
 /**
  * Return a decimal number after rounding.
  */
-const getDecimal = (props) => {
-    const number = (0, getNumber_1.default)({
-        input: props.input,
-    });
-    return Number(number.toFixed(props?.dp || 2));
+const getDecimal = (input, dp = 2) => {
+    const number = (0, getNumber_1.getNumber)(input);
+    return Number(number.toFixed(dp));
 };
-exports.default = getDecimal;
+exports.getDecimal = getDecimal;

package/number/getNumber.d.ts

@@ -1,8 +1,4 @@
 /**
  * Take an input and return a number.
  */
-declare const getNumber: ({ defaultValue, input }: {
-    defaultValue?: number;
-    input: any;
-}) => number;
-export default getNumber;
+export declare const getNumber: (input: any, defaultValue?: number) => number;

package/number/getNumber.js

@@ -1,51 +1,48 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const isJson_1 = __importDefault(require("../json/isJson"));
+exports.getNumber = void 0;
+const json_1 = require("../json");
 /**
  * Take an input and return a number.
  */
-const getNumber = ({ defaultValue = 0, input = '' }) => {
-    const actualDefaultValue = defaultValue || 0;
+const getNumber = (input, defaultValue = 0) => {
+    // Handle null/undefined inputs
+    if (input == null) {
+        return defaultValue;
+    }
     let response = input;
-    // JSON - Decode the value
-    if ((0, isJson_1.default)({ input })) {
-        // Only parse this if it's a string
-        if ('string' === typeof input) {
+    // JSON - Decode the value if it's a JSON string
+    if (typeof input === "string" && (0, json_1.isJson)(input)) {
+        try {
             response = JSON.parse(input);
         }
-        // Already decoded
-        else {
+        catch {
+            // If parsing fails, continue with original input
             response = input;
         }
     }
     // Already a number
-    if ('number' === typeof response) {
-        response = response;
+    if (typeof response === "number") {
+        return isNaN(response) ? defaultValue : response;
     }
     // String input
-    else if ('string' === typeof response) {
-        // Attempt to convert to number
-        response = Number(response);
-        // Not a number, try extracting the number value
-        if (isNaN(response)) {
-            const match = RegExp(/^\D*([0-9\.]*)\D*$/, 'g')
-                .exec(input);
-            if (match.length) {
-                response = Number(match[1]);
+    if (typeof response === "string") {
+        // First, try direct conversion
+        const directConversion = Number(response.trim());
+        if (!isNaN(directConversion)) {
+            return directConversion;
+        }
+        // If that fails, try extracting numbers from the string
+        const match = response.match(/^\D*([0-9]*\.?[0-9]+)\D*$/);
+        if (match && match[1]) {
+            const extracted = Number(match[1]);
+            if (!isNaN(extracted)) {
+                return extracted;
             }
         }
     }
-    // Attempt to convert to a number
-    else {
-        response = Number(response);
-    }
-    // Trouble converting the number, use default value
-    if (isNaN(response)) {
-        response = actualDefaultValue;
-    }
-    return response;
+    // For other types, attempt direct conversion
+    const converted = Number(response);
+    return isNaN(converted) ? defaultValue : converted;
 };
-exports.default = getNumber;
+exports.getNumber = getNumber;

package/number/getPercentIncrease.d.ts

@@ -1,10 +1,4 @@
-type GetPercentageIncrease = {
-    comparison: any;
-    current: any;
-    defaultValue: number;
-};
 /**
  * Formula to work out the percentage increase/decrease.
  */
-declare const getPercentageIncrease: ({ comparison, current, defaultValue }: GetPercentageIncrease) => number;
-export default getPercentageIncrease;
+export declare const getPercentIncrease: (current: any, comparison: any, defaultValue: number) => number;

package/number/getPercentIncrease.js

@@ -1,22 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const getNumber_1 = __importDefault(require("./getNumber"));
+exports.getPercentIncrease = void 0;
+const getNumber_1 = require("./getNumber");
 /**
  * Formula to work out the percentage increase/decrease.
  */
-const getPercentageIncrease = ({ comparison, current, defaultValue }) => {
-    const currentValue = (0, getNumber_1.default)({
-        input: current
-    });
-    const comparisonValue = (0, getNumber_1.default)({
-        input: comparison
-    });
+const getPercentIncrease = (current, comparison, defaultValue) => {
+    const currentValue = (0, getNumber_1.getNumber)(current);
+    const comparisonValue = (0, getNumber_1.getNumber)(comparison);
     if (0 === comparisonValue) {
         return defaultValue;
     }
     return (currentValue - comparisonValue) / comparisonValue * 100;
 };
-exports.default = getPercentageIncrease;
+exports.getPercentIncrease = getPercentIncrease;

package/number/{getDivide.d.ts → getSafeDivide.d.ts}

@@ -1,4 +1,4 @@
-type GetDivide = {
+type GetSafeDivideProps = {
     defaultValue?: number;
     dp?: number;
     divisor: any;
@@ -7,5 +7,5 @@ type GetDivide = {
 /**
  * Shorthand function to divide number, but fallback if the divisor is 0.
  */
-declare const getDivide: (props: GetDivide) => number;
-export default getDivide;
+export declare const getSafeDivide: (props: GetSafeDivideProps) => number;
+export {};

package/number/getSafeDivide.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSafeDivide = void 0;
+const getNumber_1 = require("./getNumber");
+const getDecimal_1 = require("./getDecimal");
+/**
+ * Shorthand function to divide number, but fallback if the divisor is 0.
+ */
+const getSafeDivide = (props) => {
+    const numeratorInt = (0, getNumber_1.getNumber)(props.numerator);
+    if (numeratorInt === 0) {
+        return 0;
+    }
+    const divisorInt = (0, getNumber_1.getNumber)(props.divisor);
+    if (divisorInt === 0 || !Number.isFinite(divisorInt)) {
+        return props?.defaultValue ?? 0;
+    }
+    return (0, getDecimal_1.getDecimal)(numeratorInt / divisorInt, props?.dp);
+};
+exports.getSafeDivide = getSafeDivide;

package/number/index.d.ts

@@ -0,0 +1,6 @@
+export { format } from "./format";
+export { formatCurrency } from "./formatCurrency";
+export { getDecimal } from "./getDecimal";
+export { getSafeDivide } from "./getSafeDivide";
+export { getNumber } from "./getNumber";
+export { getPercentIncrease } from "./getPercentIncrease";

package/number/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPercentIncrease = exports.getNumber = exports.getSafeDivide = exports.getDecimal = exports.formatCurrency = exports.format = void 0;
+var format_1 = require("./format");
+Object.defineProperty(exports, "format", { enumerable: true, get: function () { return format_1.format; } });
+var formatCurrency_1 = require("./formatCurrency");
+Object.defineProperty(exports, "formatCurrency", { enumerable: true, get: function () { return formatCurrency_1.formatCurrency; } });
+var getDecimal_1 = require("./getDecimal");
+Object.defineProperty(exports, "getDecimal", { enumerable: true, get: function () { return getDecimal_1.getDecimal; } });
+var getSafeDivide_1 = require("./getSafeDivide");
+Object.defineProperty(exports, "getSafeDivide", { enumerable: true, get: function () { return getSafeDivide_1.getSafeDivide; } });
+var getNumber_1 = require("./getNumber");
+Object.defineProperty(exports, "getNumber", { enumerable: true, get: function () { return getNumber_1.getNumber; } });
+var getPercentIncrease_1 = require("./getPercentIncrease");
+Object.defineProperty(exports, "getPercentIncrease", { enumerable: true, get: function () { return getPercentIncrease_1.getPercentIncrease; } });

package/object/index.d.ts

@@ -0,0 +1 @@
+export { replaceKeys } from "./replaceKeys";

package/object/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceKeys = void 0;
+var replaceKeys_1 = require("./replaceKeys");
+Object.defineProperty(exports, "replaceKeys", { enumerable: true, get: function () { return replaceKeys_1.replaceKeys; } });

package/object/replaceKeys.d.ts

@@ -1,10 +1,5 @@
-type ReplaceKeys = {
-    instance: any;
-    getNewKey: Function;
-};
 /**
  * Iteratively replace all the keys in an object.
  * https://www.techighness.com/post/replace-all-keys-of-deeply-nested-objects-or-array-of-objects/
  */
-declare const replaceKeys: ({ instance, getNewKey }: ReplaceKeys) => object;
-export default replaceKeys;
+export declare const replaceKeys: (instance: any, getNewKey: Function) => object;

package/object/replaceKeys.js

@@ -1,30 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceKeys = void 0;
 /**
  * Iteratively replace all the keys in an object.
  * https://www.techighness.com/post/replace-all-keys-of-deeply-nested-objects-or-array-of-objects/
  */
-const replaceKeys = ({ instance, getNewKey }) => {
+const replaceKeys = (instance, getNewKey) => {
     let response = instance;
     if (Array.isArray(instance)) {
         response = [];
         for (let i = 0; i < instance.length; i++) {
-            response[i] = replaceKeys({
-                instance: instance[i],
-                getNewKey,
-            });
+            response[i] = (0, exports.replaceKeys)(instance[i], getNewKey);
         }
     }
     else if ("object" === typeof instance) {
         response = {};
         for (const key in instance) {
             const newKey = getNewKey(key);
-            response[newKey] = replaceKeys({
-                instance: instance[key],
-                getNewKey,
-            });
+            response[newKey] = (0, exports.replaceKeys)(instance[key], getNewKey);
         }
     }
     return response;
 };
-exports.default = replaceKeys;
+exports.replaceKeys = replaceKeys;

package/onePassword/OnePasswordNamespace.d.ts

@@ -0,0 +1,13 @@
+import { OnePasswordConfig } from "./index";
+import { BaseNamespace } from "../_class";
+import type { Client } from "@1password/sdk";
+export declare class OnePasswordNamespace extends BaseNamespace {
+    client: Client | null;
+    config: OnePasswordConfig;
+    constructor(key: string, config: OnePasswordConfig);
+    ensureInit: () => Promise<void>;
+    listVaults: () => Promise<import("@1password/sdk").VaultOverview[]>;
+    getItem: (vaultId: string, itemId: string) => Promise<import("@1password/sdk").Item>;
+    getJsonNote: (vaultId: string, itemId: string) => Promise<any>;
+    listItems: (vaultId: string) => Promise<import("@1password/sdk").ItemOverview[]>;
+}

package/onePassword/OnePasswordNamespace.js

@@ -0,0 +1,81 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnePasswordNamespace = void 0;
+const _class_1 = require("../_class");
+class OnePasswordNamespace extends _class_1.BaseNamespace {
+    constructor(key, config) {
+        super(key, config);
+        this.client = null;
+        // Async setup to only initialise where required
+        this.ensureInit = async () => {
+            if (!this.client) {
+                try {
+                    const { createClient } = await Promise.resolve().then(() => __importStar(require("@1password/sdk")));
+                    this.client = await createClient({
+                        auth: this.config.serviceAccountToken,
+                        integrationName: this.config.integrationName || "8MS Helper TS",
+                        integrationVersion: this.config.integrationVersion || "v1.0.0",
+                    });
+                }
+                catch (e) {
+                    throw new Error("1Password SDK not installed");
+                }
+            }
+        };
+        this.listVaults = async () => {
+            await this.ensureInit();
+            return this.client.vaults.list();
+        };
+        this.getItem = async (vaultId, itemId) => {
+            await this.ensureInit();
+            return this.client.items.get(vaultId, itemId);
+        };
+        this.getJsonNote = async (vaultId, itemId) => {
+            let response = null;
+            const item = await this.getItem(vaultId, itemId);
+            if (item && "undefined" !== typeof item.notes) {
+                response = JSON.parse(item.notes);
+            }
+            return response;
+        };
+        this.listItems = async (vaultId) => {
+            await this.ensureInit();
+            return this.client.items.list(vaultId);
+        };
+    }
+    ;
+}
+exports.OnePasswordNamespace = OnePasswordNamespace;

package/onePassword/index.d.ts

@@ -0,0 +1,7 @@
+import { OnePasswordNamespace } from "./OnePasswordNamespace";
+export type OnePasswordConfig = {
+    serviceAccountToken: string;
+    integrationName?: string;
+    integrationVersion?: string;
+};
+export declare const onePasswordClient: (key?: string, config?: OnePasswordConfig) => Promise<OnePasswordNamespace>;

package/onePassword/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onePasswordClient = void 0;
+const OnePasswordNamespace_1 = require("./OnePasswordNamespace");
+const onePasswordNamespaces = new Map();
+// Main client that is used by system
+const onePasswordClient = async (key = "default", config) => {
+    if (onePasswordNamespaces.has(key)) {
+        return onePasswordNamespaces.get(key);
+    }
+    if (!config) {
+        if (key === "default") {
+            config = {
+                serviceAccountToken: process.env.ONEPASSWORD_SERVICE_TOKEN
+            };
+        }
+        else {
+            throw new Error(`Config required for namespace '${key}'`);
+        }
+    }
+    const namespace = new OnePasswordNamespace_1.OnePasswordNamespace(key, config);
+    onePasswordNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.onePasswordClient = onePasswordClient;

package/openAi/OpenAiNamespace.d.ts

@@ -0,0 +1,11 @@
+import { OpenAiConfig } from "./index";
+import { BaseNamespace } from "../_class";
+export declare class OpenAiNamespace extends BaseNamespace {
+    client: boolean | null;
+    config: OpenAiConfig | null;
+    /**
+     * Renew the access token as it expires every 3 hours.
+     */
+    ensureInit: () => Promise<void>;
+    completion: (prompt: string, temperature?: number, maxTokens?: number, model?: string) => Promise<any>;
+}

package/openAi/OpenAiNamespace.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiNamespace = void 0;
+const _class_1 = require("../_class");
+const axios_1 = require("../axios");
+class OpenAiNamespace extends _class_1.BaseNamespace {
+    constructor() {
+        super(...arguments);
+        this.client = null;
+        this.config = null;
+        /**
+         * Renew the access token as it expires every 3 hours.
+         */
+        this.ensureInit = async () => {
+            if (!this.client) {
+                this.client = true;
+            }
+        };
+        this.completion = async (prompt, temperature = 1, maxTokens = null, model = "gpt-3.5-turbo") => {
+            let response = null;
+            // Make the API request
+            const apiResponse = await (0, axios_1.post)(`https://api.openai.com/v1/chat/completions`, {
+                max_tokens: maxTokens,
+                model,
+                messages: [
+                    {
+                        role: "user",
+                        content: prompt,
+                    }
+                ],
+                temperature: 1,
+            }, {
+                headers: {
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                }
+            });
+            if (apiResponse.isSuccess()) {
+                response = apiResponse.getBody();
+            }
+            return response;
+        };
+    }
+}
+exports.OpenAiNamespace = OpenAiNamespace;

package/openAi/index.d.ts

@@ -0,0 +1,5 @@
+import { OpenAiNamespace } from "./OpenAiNamespace";
+export type OpenAiConfig = {
+    apiKey: string;
+};
+export declare const openAiClient: (key?: string, config?: OpenAiConfig, vaultId?: string, itemId?: string) => Promise<OpenAiNamespace>;

package/openAi/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAiClient = void 0;
+const OpenAiNamespace_1 = require("./OpenAiNamespace");
+const onePassword_1 = require("../onePassword");
+const openAiNamespaces = new Map();
+const openAiClient = async (key = "default", config, vaultId, itemId) => {
+    if (openAiNamespaces.has(key)) {
+        return openAiNamespaces.get(key);
+    }
+    let instanceConfig;
+    if (config) {
+        instanceConfig = config;
+    }
+    else if (vaultId && itemId) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(vaultId, itemId);
+    }
+    else if ("default" === key && process.env.OPEN_AI_VAULT_ID && process.env.OPEN_AI_ITEM_ID) {
+        instanceConfig = await (await (0, onePassword_1.onePasswordClient)())
+            .getJsonNote(process.env.OPEN_AI_VAULT_ID, process.env.OPEN_AI_ITEM_ID);
+    }
+    else {
+        throw new Error(`Config required for namespace '${key}'`);
+    }
+    const namespace = new OpenAiNamespace_1.OpenAiNamespace(key, instanceConfig);
+    openAiNamespaces.set(key, namespace);
+    return namespace;
+};
+exports.openAiClient = openAiClient;