@fixefy/fixefy-ui-utils 0.2.3 → 0.2.4

package/dist/auth/index.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    attachAuth: function() {
+        return attachAuth;
+    },
+    getToken: function() {
+        return getToken;
+    }
+});
+const _nookies = require("nookies");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+const attachAuth = (ctx, headers)=>{
+    const token = getToken(ctx);
+    return _object_spread_props(_object_spread({}, headers), {
+        authorization: `Bearer ${token}`
+    });
+};
+const getToken = (ctx)=>{
+    return (0, _nookies.parseCookies)(ctx)['token'];
+} // export const checkLoggedIn = async ({ client }) => {
+ //   const rv = await client
+ //     .query({ query: gql(ME_QUERY) })
+ //     .then(({ data }) => ({ loggedInUser: data }))
+ //     .catch(() => ({
+ //       loggedInUser: null,
+ //     })); // Fail gracefully
+ //   return rv;
+ // };
+;

package/dist/aws/aws_lambda_helper.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    generateMappings: function() {
+        return generateMappings;
+    },
+    getLambda: function() {
+        return getLambda;
+    },
+    getLambdaParams: function() {
+        return getLambdaParams;
+    },
+    getLambdaResult: function() {
+        return getLambdaResult;
+    }
+});
+const _awssdk = /*#__PURE__*/ _interop_require_default(require("aws-sdk"));
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+const getLambda = (args)=>{
+    const { key, region, secret } = args, lambdaCredentials = new _awssdk.default.Credentials({
+        accessKeyId: key,
+        secretAccessKey: secret
+    }), rv = new _awssdk.default.Lambda({
+        credentials: lambdaCredentials,
+        region,
+        maxRetries: 0,
+        httpOptions: {
+            connectTimeout: 30000,
+            timeout: 300000
+        }
+    });
+    return rv;
+};
+const getLambdaParams = (args)=>{
+    const { function_name: functionName } = args, // clientContextObj: unknown = { authorization, file_name, ws },
+    clientContext = '' //Buffer.from( JSON.stringify( clientContextObj ) ).toString( 'base64' )
+    ;
+    const rv = {
+        ClientContext: clientContext,
+        FunctionName: functionName,
+        InvocationType: 'RequestResponse',
+        Payload: ''
+    };
+    return rv;
+};
+const generateMappings = function() {
+    var _ref = _async_to_generator(function*(args) {
+        // get the lambda's params
+        const params = getLambdaParams(args);
+        // get lambda
+        const lambda = getLambda(args);
+        // create promise
+        const p = new Promise((resolve, reject)=>{
+            lambda.invoke(params, (err, data)=>{
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(data);
+                }
+            });
+        });
+        // execute lambda
+        const result = yield p;
+        // get result
+        const rv = getLambdaResult({
+            result
+        });
+        return rv;
+    });
+    return function generateMappings(args) {
+        return _ref.apply(this, arguments);
+    };
+}();
+const getLambdaResult = (args)=>{
+    const { result: { ExecutedVersion: executedVersion, FunctionError: functionError, LogResult: logResult, Payload: payload, StatusCode: statusCode } } = args;
+    let rv = {
+        execute_version: executedVersion,
+        function_error: functionError,
+        log_result: logResult,
+        status_code: statusCode
+    };
+    // input check - if payload is invalid - return empty object
+    if (payload != null) {
+        const payloadObject = JSON.parse(payload);
+        rv = _object_spread_props(_object_spread({}, rv), {
+            body: payloadObject,
+            error: payloadObject.errorMessage
+        });
+    }
+    return rv;
+};

package/dist/aws/data_models.js

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

package/dist/aws/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./aws_lambda_helper"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/commander/index.js

@@ -0,0 +1,390 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildCode: function() {
+        return buildCode;
+    },
+    convertToString: function() {
+        return convertToString;
+    },
+    copyToClipboard: function() {
+        return copyToClipboard;
+    },
+    determineIconByEvent: function() {
+        return determineIconByEvent;
+    },
+    formatNumberWithCommas: function() {
+        return formatNumberWithCommas;
+    },
+    getNormalizationKeyForEntity: function() {
+        return getNormalizationKeyForEntity;
+    },
+    getScoreColor: function() {
+        return getScoreColor;
+    },
+    getStringValueByValueType: function() {
+        return getStringValueByValueType;
+    },
+    getVal: function() {
+        return getVal;
+    },
+    isInServer: function() {
+        return isInServer;
+    },
+    isValidTimestamp: function() {
+        return isValidTimestamp;
+    },
+    lineString: function() {
+        return lineString;
+    },
+    makeString: function() {
+        return makeString;
+    },
+    nest: function() {
+        return nest;
+    },
+    normalizeStringBodyRaw: function() {
+        return normalizeStringBodyRaw;
+    },
+    normalizeTimestamp: function() {
+        return normalizeTimestamp;
+    },
+    titleCase: function() {
+        return titleCase;
+    },
+    toCamelCase: function() {
+        return toCamelCase;
+    },
+    toCamelCaseString: function() {
+        return toCamelCaseString;
+    },
+    toCurrency: function() {
+        return toCurrency;
+    },
+    toInitials: function() {
+        return toInitials;
+    },
+    toPascalCase: function() {
+        return toPascalCase;
+    },
+    toWords: function() {
+        return toWords;
+    },
+    trimRuleCode: function() {
+        return trimRuleCode;
+    },
+    useStatePromisify: function() {
+        return useStatePromisify;
+    }
+});
+const _ = require("../");
+const _datefns = require("date-fns");
+const _react = require("react");
+const _fixefynumeric = /*#__PURE__*/ _interop_require_default(require("@fixefy/fixefy-numeric"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+const buildCode = (obj, level = 0, name)=>{
+    const toRender = [];
+    const keys = Object.keys(obj);
+    if (keys.length < 1) {
+        toRender.push(lineString(level, name) + '{}');
+        return toRender;
+    }
+    toRender.push(lineString(level, name) + '{');
+    keys.forEach((key)=>{
+        if (key === '__typename') return;
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+            toRender.push(...buildCode(obj[key], level + 1, key));
+        } else {
+            const val = getVal(obj[key]);
+            toRender.push(lineString(level + 1, key) + val);
+        }
+    });
+    toRender.push(lineString(level) + '}');
+    return toRender;
+};
+const copyToClipboard = (str)=>{
+    if (window == undefined) return;
+    const el = document.createElement('textarea');
+    el.value = str;
+    el.setAttribute('readonly', '');
+    el.style.position = 'absolute';
+    el.style.left = '-9999px';
+    document.body.appendChild(el);
+    el.select();
+    document.execCommand('copy');
+    document.body.removeChild(el);
+};
+const convertToString = (input)=>{
+    if (input) {
+        return typeof input === 'string' ? input : String(input);
+    } else {
+        return null;
+    }
+};
+const determineIconByEvent = (event)=>{
+    let rv;
+    if (event) {
+        switch(event.type){
+            case 'charged':
+                rv = '../../static/images/transactions/billing.svg';
+                break;
+            case 'packed':
+                rv = '../../static/images/transactions/system.svg';
+                break;
+            default:
+                rv = '../../static/images/transactions/user.svg';
+                break;
+        }
+    }
+    return rv;
+};
+const formatNumberWithCommas = (number)=>{
+    return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+};
+const getNormalizationKeyForEntity = (entity_type)=>{
+    let rv;
+    switch(entity_type.toLowerCase()){
+        case _.EntityTypes.User:
+            rv = 'username';
+            break;
+        case _.EntityTypes.Pricing:
+            rv = 'value';
+            break;
+        case _.EntityTypes.Metadata:
+            rv = 'title';
+            break;
+        case _.EntityTypes.Transaction:
+        case _.EntityTypes.Transmission:
+            rv = 'readable_id';
+            break;
+        default:
+            rv = 'title';
+            break;
+    }
+    return rv;
+};
+const getStringValueByValueType = ({ value, name })=>{
+    let rv;
+    let entity_type;
+    let roundedValue;
+    let formattedValue;
+    switch(typeof value){
+        case 'boolean':
+            rv = value === true ? 'YES' : 'NO';
+            break;
+        case 'number':
+            if (isValidTimestamp(value)) {
+                rv = normalizeTimestamp(value, false);
+                break;
+            }
+            roundedValue = Number(value) === value && value % 1 === 0 ? value : value.toFixed(2);
+            formattedValue = name === 'variance' ? `${(roundedValue * 100).toFixed(1)}%` : roundedValue;
+            rv = formattedValue;
+            break;
+        case 'object':
+            if (Array.isArray(value)) {
+                rv = value.join(', ');
+            } else {
+                entity_type = value && value.__typename && value.__typename.toLowerCase();
+                rv = titleCase(value[getNormalizationKeyForEntity(entity_type)]);
+            }
+            break;
+        case 'string':
+            rv = titleCase(value);
+            break;
+    }
+    return rv;
+};
+const getVal = (val)=>{
+    if (typeof val === 'number') return val;
+    if (typeof val === 'string') return `"${val}"`;
+    return val;
+};
+const isInServer = ()=>typeof window === 'undefined';
+const isValidTimestamp = (_timestamp)=>{
+    const parsedNumber = typeof _timestamp == 'string' ? parseInt(_timestamp) : _timestamp;
+    const newTimestamp = new Date(parsedNumber).getTime();
+    const rv = _fixefynumeric.default.isFloat(newTimestamp) || _fixefynumeric.default.isInt(newTimestamp) && newTimestamp.toString().length >= 10;
+    return rv;
+};
+const lineString = (level, name)=>{
+    let str = '';
+    for(let i = 0; i < level; i++){
+        str += '  ';
+    }
+    if (name) {
+        str += name + ': ';
+    }
+    return str;
+};
+const makeString = (len = 5)=>{
+    let text = '';
+    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for(let i = 0; i < len; i++)text += possible.charAt(Math.floor(Math.random() * possible.length));
+    return text;
+};
+const nest = ({ items })=>{
+    const mappedArray = Object.create(null);
+    items.forEach((item)=>mappedArray[item.id] = _object_spread_props(_object_spread({}, item), {
+            children: []
+        }));
+    const nestedArray = [];
+    items.forEach((item)=>{
+        if (item) {
+            if (item.parent) mappedArray[item.parent] && mappedArray[item.parent].children.push(mappedArray[item.id]);
+            else nestedArray.push(mappedArray[item.id]);
+        }
+    });
+    return nestedArray;
+};
+const normalizeTimestamp = (timestamp, options)=>{
+    const { dateOnly, format: _format } = options || {};
+    const _timestamp = typeof timestamp == 'string' ? parseInt(timestamp) : timestamp;
+    const rv = (0, _datefns.format)(new Date(_timestamp), _format ? _format : dateOnly ? 'dd/MM/yyyy' : 'dd/MM/yyyy hh:mm');
+    return rv;
+};
+const normalizeStringBodyRaw = (key, body)=>{
+    return typeof body[key] === 'string' && (key === 'body' || key === 'raw') ? JSON.parse(body[key]) : body[key];
+};
+const titleCase = (str = '')=>str && toPascalCase(str.toString(), true);
+const toCamelCase = (inputArray)=>{
+    let result = '';
+    var _inputArray_length;
+    for(let i = 0, len = (_inputArray_length = inputArray === null || inputArray === void 0 ? void 0 : inputArray.length) !== null && _inputArray_length !== void 0 ? _inputArray_length : 0; i < len; i++){
+        const currentStr = inputArray === null || inputArray === void 0 ? void 0 : inputArray.at(i);
+        let tempStr = currentStr.toLowerCase();
+        if (i != 0) {
+            // convert first letter to upper case (the word is in lowercase)
+            tempStr = tempStr.substr(0, 1).toUpperCase() + tempStr.substr(1);
+        }
+        result += tempStr;
+    }
+    return result;
+};
+const toCamelCaseString = (input)=>{
+    const words = toWords(input);
+    return toCamelCase(words);
+};
+const toCurrency = (input, options)=>{
+    return input ? typeof input == 'number' ? input.toFixed((options === null || options === void 0 ? void 0 : options.decimel) || 2).replace(/\B(?=(\d{3})+(?!\d))/g, ',') : input.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',') : input;
+};
+const toInitials = (str)=>{
+    if (str === '') return str;
+    const matches = str.match(/\b(\w)/g);
+    return matches === null || matches === void 0 ? void 0 : matches.join('').toUpperCase();
+};
+const toPascalCase = (string, title = false)=>{
+    return string && string.replace(/(_[a-z])?(^[a-z])?(_|\s[a-z])?/g, ($1)=>$1.toUpperCase().replace('_', title ? ' ' : ''));
+};
+const toWords = (input)=>{
+    input = convertToString(input);
+    const regex = /[A-Z\xC0-\xD6\xD8-\xDE]?[a-z\xDF-\xF6\xF8-\xFF]+|[A-Z\xC0-\xD6\xD8-\xDE]+(?![a-z\xDF-\xF6\xF8-\xFF])|\d+/g;
+    return input === null || input === void 0 ? void 0 : input.match(regex);
+};
+const trimRuleCode = (input)=>{
+    const stringefied = typeof input == 'string' ? input : JSON.stringify(input);
+    const match = stringefied.substring(stringefied.indexOf('{') + 1, stringefied.lastIndexOf('}'));
+    return match ? match : '';
+};
+const useStatePromisify = (_state)=>{
+    const [state, setState] = (0, _react.useState)(_state);
+    const resolverRef = (0, _react.useRef)(null);
+    (0, _react.useEffect)(()=>{
+        if (resolverRef.current) {
+            resolverRef.current(state);
+            resolverRef.current = null;
+        }
+    }, [
+        resolverRef,
+        state
+    ]);
+    const handleSetState = (0, _react.useCallback)((stateAction)=>{
+        setState(stateAction);
+        return new Promise((resolve)=>{
+            resolverRef.current = resolve;
+        });
+    }, [
+        setState
+    ]);
+    return [
+        state,
+        handleSetState
+    ];
+};
+const getScoreColor = (value)=>{
+    if (value <= 20) {
+        return 'bad';
+    } else if (value <= 40) {
+        return 'low';
+    } else if (value <= 60) {
+        return 'medium';
+    } else if (value <= 80) {
+        return 'high';
+    } else {
+        return 'excellent';
+    }
+};