ag-common 0.0.3

package/dist/api/helpers/openApiHelpers.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiImpl = void 0;
+/* eslint-disable no-new */
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const distinctBy_1 = require("../../common/helpers/distinctBy");
+const log_1 = require("../../common/helpers/log");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const getPaths = (schema) => Object.entries(schema.paths).map(([fullPath, verbs]) => ({
+    fullPath,
+    pathList: fullPath.split('/').filter((s) => s),
+    verbs: Object.keys(verbs),
+}));
+const setUpApiGw = ({ stack, NODE_ENV, baseUrl, certificate, hostedZone, shortStackName, }) => {
+    const api = new aws_cdk_lib_1.aws_apigateway.RestApi(stack, `${shortStackName}-api-${NODE_ENV}`, {
+        defaultCorsPreflightOptions: {
+            allowOrigins: aws_cdk_lib_1.aws_apigateway.Cors.ALL_ORIGINS,
+        },
+    });
+    const dn = new aws_cdk_lib_1.aws_apigateway.DomainName(stack, 'domain', {
+        domainName: `api.${baseUrl}`,
+        certificate,
+        endpointType: aws_cdk_lib_1.aws_apigateway.EndpointType.EDGE,
+        securityPolicy: aws_cdk_lib_1.aws_apigateway.SecurityPolicy.TLS_1_2,
+        mapping: api,
+    });
+    new aws_cdk_lib_1.aws_route53.ARecord(stack, 'ARecord', {
+        comment: '(cdk)',
+        recordName: 'api',
+        zone: hostedZone,
+        target: aws_cdk_lib_1.aws_route53.RecordTarget.fromAlias(new aws_cdk_lib_1.aws_route53_targets.ApiGatewayDomain(dn)),
+    });
+    return api;
+};
+const getDynamoPermissions = ({ lambdaPermissions, pathV, verb, seenPermissions, }) => {
+    const pathCompute = pathV + '-' + verb;
+    const lp = lambdaPermissions === null || lambdaPermissions === void 0 ? void 0 : lambdaPermissions[pathCompute];
+    if (lp) {
+        seenPermissions[pathCompute] = true;
+    }
+    else {
+        seenPermissions[pathCompute] = false;
+    }
+    const def = lambdaPermissions === null || lambdaPermissions === void 0 ? void 0 : lambdaPermissions.default;
+    if (def) {
+        seenPermissions.default = true;
+    }
+    //
+    const readTables = (0, distinctBy_1.distinctBy)([...((def === null || def === void 0 ? void 0 : def.reads) || []), ...((lp === null || lp === void 0 ? void 0 : lp.reads) || [])], (s) => s.shortName);
+    const writeTables = (0, distinctBy_1.distinctBy)([...((def === null || def === void 0 ? void 0 : def.writes) || []), ...((lp === null || lp === void 0 ? void 0 : lp.writes) || [])], (s) => s.shortName);
+    const tables = [...readTables, ...writeTables];
+    const environment = {};
+    Object.values(tables).forEach((v) => {
+        environment[v.shortName] = v.table.tableName;
+    });
+    return { environment, readTables, writeTables };
+};
+const addApiPaths = (api, subs, apiRoots) => {
+    let apiPath;
+    subs.forEach((s, i) => {
+        if (i === 0) {
+            if (apiRoots[s]) {
+                apiPath = apiRoots[s];
+            }
+            else {
+                apiPath = api.root.addResource(s);
+                apiRoots[s] = apiPath;
+            }
+        }
+        else {
+            if (!apiPath) {
+                throw new Error('no apipath');
+            }
+            apiPath = apiPath.addResource(s);
+        }
+    });
+    if (!apiPath) {
+        throw new Error('no apipath');
+    }
+    return apiPath;
+};
+const lambdaNameSafe = (raw) => raw.replace(/[^a-zA-Z0-9-.]/gim, '-').replace(/(-){2,}/gim, '-');
+const openApiImpl = (p) => {
+    if (!p.schema) {
+        throw new Error('no openapi schema found');
+    }
+    const { stack, NODE_ENV, endpointsBase, lambdaPermissions } = p;
+    const paths = getPaths(p.schema);
+    const api = setUpApiGw(p);
+    const apiRoots = {};
+    const seenPermissions = {};
+    paths.forEach(({ fullPath, verbs, pathList }) => {
+        const apiPath = addApiPaths(api, pathList, apiRoots);
+        verbs.forEach((verb) => {
+            const { environment, readTables, writeTables } = getDynamoPermissions({
+                lambdaPermissions,
+                pathV: fullPath,
+                verb,
+                seenPermissions,
+            });
+            const lambdaName = lambdaNameSafe(`${p.shortStackName}-${fullPath}-${verb}-${NODE_ENV}`);
+            const lambdaV = new aws_cdk_lib_1.aws_lambda_nodejs.NodejsFunction(stack, lambdaName, {
+                functionName: lambdaName,
+                runtime: aws_cdk_lib_1.aws_lambda.Runtime.NODEJS_14_X,
+                handler: 'handler',
+                environment,
+                memorySize: 128,
+                timeout: aws_cdk_lib_1.Duration.seconds(30),
+                description: '(cdk)',
+                entry: `${endpointsBase}${fullPath}/${verb.toUpperCase()}.ts`,
+                bundling: {
+                    externalModules: ['aws-sdk', 'aws-lambda'],
+                },
+            });
+            readTables.forEach((t) => t.table.grantReadData(lambdaV));
+            writeTables.forEach((t) => t.table.grantReadWriteData(lambdaV));
+            //
+            apiPath.addMethod(verb.toUpperCase(), new aws_cdk_lib_1.aws_apigateway.LambdaIntegration(lambdaV, {}));
+        });
+    });
+    Object.keys(lambdaPermissions).forEach((k) => {
+        if (!seenPermissions[k] || seenPermissions[k] === false) {
+            (0, log_1.warn)(`unused permissions for '${k}', did you mean one of these paths?=`, Object.entries(seenPermissions)
+                .filter(([, b]) => !b)
+                .map(([f]) => f)
+                .join('\n'));
+            throw new Error('unused permissions!:' + k);
+        }
+    });
+};
+exports.openApiImpl = openApiImpl;

package/dist/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './helpers';

package/dist/api/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./helpers"), exports);

package/dist/api/types.d.ts

@@ -0,0 +1,45 @@
+import { aws_dynamodb as dynamodb } from 'aws-cdk-lib';
+import { Key } from 'aws-sdk/clients/dynamodb';
+export interface DYNAMOKEYS {
+    type: string;
+    L1: string;
+    L2?: string;
+    L3?: string;
+    L4?: string;
+    L5?: string;
+    PK: string;
+    PK1: string;
+    PK2: string;
+    PK3?: string;
+    PK4?: string;
+}
+export interface IGeneratedDynamoData {
+    table: dynamodb.ITable;
+    shortName: string;
+}
+export interface ILambdaPermissions {
+    [pathHyphenVerb: string]: {
+        reads?: IGeneratedDynamoData[];
+        writes?: IGeneratedDynamoData[];
+    } & {
+        default?: {
+            reads?: IGeneratedDynamoData[];
+            writes?: IGeneratedDynamoData[];
+        };
+    };
+}
+export interface IQueryDynamo {
+    pkName: string;
+    pkValue: string | number;
+    pkOperator?: string;
+    skName?: string;
+    skValue?: string | number | string[] | number[];
+    skOperator?: string;
+    tableName: string;
+    indexName?: string;
+    count?: number;
+    startKey?: Key;
+    filterName?: string;
+    filterValue?: string | number;
+    filterOperator?: string;
+}

package/dist/api/types.js

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

package/dist/common/helpers/array.d.ts

@@ -0,0 +1,9 @@
+export declare const toObject: <T, Indexer extends string | number>(arr: T[], keyF: (a: T) => Indexer) => { [a in Indexer]: T; } | null;
+export declare const flat: <T>(arr: T[][]) => T[];
+export declare const take: <T>(array: T[], num: number) => {
+    part: T[];
+    rest: T[];
+};
+export declare const chunk: <T>(array: T[], max: number) => T[][];
+export declare const partition: <T>(array: T[], func: (v: T) => boolean) => T[][] | null;
+export declare function notEmpty<TValue>(value: TValue | null | undefined | false): value is TValue;

package/dist/common/helpers/array.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEmpty = exports.partition = exports.chunk = exports.take = exports.flat = exports.toObject = void 0;
+const toObject = (arr, keyF) => {
+    if (!arr || !keyF) {
+        return null;
+    }
+    const ret = {};
+    arr.forEach((v) => {
+        const k = keyF(v);
+        ret[k] = v;
+    });
+    return ret;
+};
+exports.toObject = toObject;
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const flat = (arr) => [].concat(...arr);
+exports.flat = flat;
+const take = (array, num) => {
+    const ret = JSON.parse(JSON.stringify(array));
+    return { part: ret.slice(0, num), rest: ret.slice(num) };
+};
+exports.take = take;
+const chunk = (array, max) => {
+    const rows = [];
+    let row = [];
+    for (const k in array) {
+        const item = array[k];
+        if (row.length < max) {
+            row = [...row, item];
+        }
+        else {
+            rows.push(row);
+            row = [];
+        }
+    }
+    if (row.length > 0) {
+        rows.push(row);
+    }
+    return rows;
+};
+exports.chunk = chunk;
+const partition = (array, func) => !(array === null || array === void 0 ? void 0 : array.length)
+    ? null
+    : [array.filter((r) => func(r)), array.filter((r) => !func(r))];
+exports.partition = partition;
+function notEmpty(value) {
+    return value !== null && value !== undefined && value !== false;
+}
+exports.notEmpty = notEmpty;

package/dist/common/helpers/distinctBy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * return a distinct array of items determined by a key function
+ * @param data
+ * @param key
+ * @param ignoreEmpty
+ */
+export declare function distinctBy<T, TY>(data: T[], key: (item: T) => TY, ignoreEmpty?: boolean): T[];
+export declare const distinct: <T>(arr: readonly T[]) => T[];

package/dist/common/helpers/distinctBy.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distinct = exports.distinctBy = void 0;
+/**
+ * return a distinct array of items determined by a key function
+ * @param data
+ * @param key
+ * @param ignoreEmpty
+ */
+function distinctBy(data, key, ignoreEmpty) {
+    if (!data || data.length === 0) {
+        return data;
+    }
+    const hashSet = new Set();
+    return data.filter((x) => {
+        let keyVal;
+        if (typeof key === 'string') {
+            keyVal = x[key];
+        }
+        else {
+            keyVal = key(x);
+        }
+        if (!keyVal && ignoreEmpty) {
+            return false;
+        }
+        if (!hashSet.has(keyVal)) {
+            hashSet.add(keyVal);
+            return true;
+        }
+        return false;
+    });
+}
+exports.distinctBy = distinctBy;
+const distinct = (arr) => [...new Set(arr)];
+exports.distinct = distinct;

package/dist/common/helpers/email.d.ts

@@ -0,0 +1,7 @@
+export declare const isEmailValid: (email: string) => boolean;
+export declare const getEmailErrors: (email: string, event: {
+    creatorId: string;
+}) => string | undefined;
+export declare const getEmailsErrors: (emails: string[], event: {
+    creatorId: string;
+}) => string[];

package/dist/common/helpers/email.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmailsErrors = exports.getEmailErrors = exports.isEmailValid = void 0;
+const array_1 = require("./array");
+const regex = /^[-!#$%&'*+/0-9=?A-Z^_a-z{|}~](\.?[-!#$%&'*+/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-*\.?[a-zA-Z0-9])*\.[a-zA-Z](-?[a-zA-Z0-9])+$/;
+const isEmailValid = (email) => {
+    if (!email)
+        return false;
+    if (email.length > 256)
+        return false;
+    const valid = regex.test(email);
+    if (!valid)
+        return false;
+    const parts = email.split('@');
+    if (parts[0].length > 64)
+        return false;
+    const domainParts = parts[1].split('.');
+    if (domainParts.some((part) => part.length > 64)) {
+        return false;
+    }
+    return true;
+};
+exports.isEmailValid = isEmailValid;
+const getEmailErrors = (email, event) => {
+    if (!(0, exports.isEmailValid)(email)) {
+        return `email not valid:${email}`;
+    }
+    if (event.creatorId === email) {
+        return `You cannot add the creator of this event as an admin`;
+    }
+    return undefined;
+};
+exports.getEmailErrors = getEmailErrors;
+const getEmailsErrors = (emails, event) => emails.map((email) => (0, exports.getEmailErrors)(email, event)).filter(array_1.notEmpty);
+exports.getEmailsErrors = getEmailsErrors;

package/dist/common/helpers/groupBy.d.ts

@@ -0,0 +1,22 @@
+/**
+ * group an array of items by the output of a key function
+ * @param arr
+ * @param getKey
+ */
+export declare function groupBy<T, TY extends string | number>(arr: T[], getKey: (i: T) => TY): {
+    [key in TY]: T[];
+};
+/**
+ * group an array of items by the output of a key function
+ * @param arr
+ * @param getKey
+ */
+export declare function groupByList<T, TY>(arr: T[], getKey: (i: T) => TY): {
+    key: TY;
+    items: T[];
+}[];
+export declare function groupByTwice<T>(arr: T[], getKey: (i: T) => string | number, getSubKey: (i: T) => string | number): {
+    [key in string | number]: {
+        [a in string | number]: T;
+    };
+};

package/dist/common/helpers/groupBy.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByTwice = exports.groupByList = exports.groupBy = void 0;
+/**
+ * group an array of items by the output of a key function
+ * @param arr
+ * @param getKey
+ */
+function groupBy(arr, getKey) {
+    const ret = {};
+    arr.forEach((item) => {
+        const key = getKey(item);
+        if (!ret[key]) {
+            ret[key] = [];
+        }
+        ret[key].push(item);
+    });
+    return ret;
+}
+exports.groupBy = groupBy;
+/**
+ * group an array of items by the output of a key function
+ * @param arr
+ * @param getKey
+ */
+function groupByList(arr, getKey) {
+    const ret = [];
+    arr.forEach((item) => {
+        const key = getKey(item);
+        const i = ret.find((r) => r.key === key);
+        if (!i) {
+            ret.push({ key, items: [item] });
+        }
+        else {
+            i.items.push(item);
+        }
+    });
+    return ret;
+}
+exports.groupByList = groupByList;
+function groupByTwice(arr, getKey, getSubKey) {
+    const ret = {};
+    arr.forEach((item) => {
+        const key = getKey(item);
+        const subkey = getSubKey(item);
+        if (!ret[key]) {
+            ret[key] = {};
+        }
+        ret[key][subkey] = item;
+    });
+    return ret;
+}
+exports.groupByTwice = groupByTwice;

package/dist/common/helpers/hashCode.d.ts

@@ -0,0 +1,2 @@
+export declare const hashCode: (str: string, seed?: number) => string;
+export declare const generateNewPK: () => string;

package/dist/common/helpers/hashCode.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNewPK = exports.hashCode = void 0;
+/* eslint-disable no-bitwise */
+const hashCode = (str, seed = 0) => {
+    if (!str) {
+        return '';
+    }
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < str.length; i += 1) {
+        ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 =
+        Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
+            Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 =
+        Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
+            Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    const ret = 4294967296 * (2097151 & h2) + (h1 >>> 0);
+    return ret.toString();
+};
+exports.hashCode = hashCode;
+const generateNewPK = () => (0, exports.hashCode)(new Date().getTime().toString());
+exports.generateNewPK = generateNewPK;

package/dist/common/helpers/i18n.d.ts

@@ -0,0 +1,11 @@
+declare type TLangExceptEn = 'id' | 'vi';
+export declare type TLang = TLangExceptEn | 'en';
+export declare const AllLang: TLang[];
+export declare type TResource = {
+    [k in TLangExceptEn]: string | null;
+} & {
+    en: string;
+};
+export declare const getValidatedLang: (raw: string) => TLang;
+export declare const t: (res: TResource, lang: TLang) => string;
+export {};

package/dist/common/helpers/i18n.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = exports.getValidatedLang = exports.AllLang = void 0;
+exports.AllLang = ['en', 'id', 'vi'];
+const getValidatedLang = (raw) => {
+    const f = exports.AllLang.find((l) => l === raw);
+    if (!f) {
+        return 'en';
+    }
+    return f;
+};
+exports.getValidatedLang = getValidatedLang;
+const t = (res, lang) => { var _a; return (_a = res[lang]) !== null && _a !== void 0 ? _a : res.en; };
+exports.t = t;

package/dist/common/helpers/index.d.ts

@@ -0,0 +1,12 @@
+export * from './array';
+export * from './distinctBy';
+export * from './email';
+export * from './groupBy';
+export * from './hashCode';
+export * from './i18n';
+export * from './log';
+export * from './math';
+export * from './object';
+export * from './random';
+export * from './secondsInNearest';
+export * from './string';

package/dist/common/helpers/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);
+__exportStar(require("./distinctBy"), exports);
+__exportStar(require("./email"), exports);
+__exportStar(require("./groupBy"), exports);
+__exportStar(require("./hashCode"), exports);
+__exportStar(require("./i18n"), exports);
+__exportStar(require("./log"), exports);
+__exportStar(require("./math"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./random"), exports);
+__exportStar(require("./secondsInNearest"), exports);
+__exportStar(require("./string"), exports);

package/dist/common/helpers/log.d.ts

@@ -0,0 +1,5 @@
+export declare const info: (...args: any[]) => void;
+export declare const warn: (...args: any[]) => void;
+export declare const error: (...args: any[]) => void;
+export declare const debug: (...args: any[]) => void;
+export declare const trace: (...args: any[]) => void;

package/dist/common/helpers/log.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = exports.debug = exports.error = exports.warn = exports.info = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-console */
+const info = (...args) => {
+    console.log(...args);
+};
+exports.info = info;
+const warn = (...args) => {
+    console.warn(...args);
+};
+exports.warn = warn;
+const error = (...args) => {
+    console.error(...args);
+};
+exports.error = error;
+const debug = (...args) => {
+    console.debug(...args);
+};
+exports.debug = debug;
+const trace = (...args) => {
+    console.trace(...args);
+};
+exports.trace = trace;

package/dist/common/helpers/math.d.ts

@@ -0,0 +1,11 @@
+export declare const toFixed: (num: number, fixed: number) => number;
+export declare function roundToHalf(converted: number): number;
+export declare function clamp({ value, min, max, }: {
+    value: number;
+    min: number;
+    max: number;
+}): number;
+export declare function sumArray(array: number[]): number;
+export declare const getRandomInt: (max: number) => number;
+export declare function isNumber(val: string): boolean;
+export declare function toFixedDown(num: number, scale: number): number;

package/dist/common/helpers/math.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFixedDown = exports.isNumber = exports.getRandomInt = exports.sumArray = exports.clamp = exports.roundToHalf = exports.toFixed = void 0;
+const toFixed = (num, fixed) => {
+    var _a, _b;
+    const re = new RegExp(`^-?\\d+(?:.\\d{0,${fixed || -1}})?`);
+    const x = (_b = (_a = num === null || num === void 0 ? void 0 : num.toString()) === null || _a === void 0 ? void 0 : _a.match(re)) === null || _b === void 0 ? void 0 : _b[0];
+    if (!x) {
+        return num;
+    }
+    return Number.parseFloat(x);
+};
+exports.toFixed = toFixed;
+function roundToHalf(converted) {
+    let decimal = converted - parseInt(converted.toString(), 10);
+    decimal = Math.round(decimal * 10);
+    if (decimal === 5) {
+        return parseInt(converted.toString(), 10) + 0.5;
+    }
+    if (decimal < 3 || decimal > 7) {
+        return Math.round(converted);
+    }
+    return parseInt(converted.toString(), 10) + 0.5;
+}
+exports.roundToHalf = roundToHalf;
+function clamp({ value, min, max, }) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+exports.clamp = clamp;
+function sumArray(array) {
+    return array.reduce((a, b) => a + b);
+}
+exports.sumArray = sumArray;
+const getRandomInt = (max) => {
+    return Math.floor(Math.random() * Math.floor(max));
+};
+exports.getRandomInt = getRandomInt;
+function isNumber(val) {
+    const re = new RegExp(`(\\d+\\.?\\d*)(\\d)`);
+    const m = val.toString().match(re);
+    return !!m;
+}
+exports.isNumber = isNumber;
+function toFixedDown(num, scale) {
+    if (!`${num}`.includes('e')) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return +`${Math.round(`${num}e+${scale}`)}e-${scale}`;
+    }
+    const arr = `${num}`.split('e');
+    let sig = '';
+    if (+arr[1] + scale > 0) {
+        sig = '+';
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return +`${Math.round(`${+arr[0]}e${sig}${+arr[1] + scale}`)}e-${scale}`;
+}
+exports.toFixedDown = toFixedDown;

package/dist/common/helpers/object.d.ts

@@ -0,0 +1,17 @@
+export declare const tryJsonParse: <T>(str: string | undefined | null, defaultValue: T | null | undefined) => T | null | undefined;
+export declare function isJson(str: string | Record<string, unknown>): boolean;
+export declare const objectKeysToLowerCase: <T>(origObj: {
+    [a: string]: T;
+}) => {
+    [a: string]: T;
+};
+export declare const getObjectKeysAsNumber: (o: {
+    [a: number]: unknown;
+}) => number[];
+export interface IArrayType<T> {
+    key: string;
+    value: T;
+}
+export declare function objectToArray<T>(obj: {
+    [a: string]: T;
+}): IArrayType<T>[];