@fixefy/fixefy-ui-utils 0.2.1 → 0.2.2

package/dist/src/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';
+    }
+};

package/dist/src/constants/index.js

@@ -0,0 +1,115 @@
+"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, {
+    ColumnInputTypes: function() {
+        return ColumnInputTypes;
+    },
+    ComponentTypes: function() {
+        return ComponentTypes;
+    },
+    DataTypes: function() {
+        return DataTypes;
+    },
+    EntityTypes: function() {
+        return EntityTypes;
+    },
+    FilterOperatorType: function() {
+        return FilterOperatorType;
+    },
+    InputTypes: function() {
+        return InputTypes;
+    }
+});
+const ColumnInputTypes = {
+    Array: 'array',
+    Avatar: 'avatar',
+    Country: 'country',
+    Currency: 'currency',
+    Date: 'date',
+    Done: 'done',
+    ID: 'id',
+    IncoTerm: 'incoterm',
+    Link: 'link',
+    Percentage: 'percentage',
+    Price: 'price',
+    Progress: 'progress',
+    Score: 'score',
+    Status: 'status',
+    String: 'string',
+    Measure: 'measure'
+};
+const ComponentTypes = {
+    ActionTrey: 'action_trey',
+    AsyncDropdown: 'async_dropdown',
+    Chip: 'chip',
+    ClickableLabel: 'clickable_label',
+    CollapsableDropdown: 'collapsable_dropdown',
+    Container: 'container',
+    DateRange: 'date_range',
+    Dropdown: 'dropdown',
+    Label: 'label',
+    Modal: 'modal',
+    RangeSlider: 'range_slider',
+    TableColumn: 'table_column',
+    Textfield: 'textfield',
+    StaticDropdown: 'static_dropdown',
+    dropdownOptions: 'dropdownOptions',
+    clear: 'clear'
+};
+const DataTypes = {
+    CSV: 'csv',
+    EDI: 'edi',
+    JSON: 'json',
+    PDF: 'pdf',
+    XLS: 'xls',
+    // XLSX: "xlsx",
+    XML: 'xml'
+};
+const EntityTypes = {
+    Block: 'block',
+    Charge: 'charge',
+    Contract: 'contract',
+    Event: 'event',
+    Metadata: 'metadata',
+    Notification: 'notification',
+    Pricing: 'pricing',
+    Service: 'service',
+    Structure: 'structure',
+    Transaction: 'transaction',
+    Transmission: 'transmission',
+    User: 'user',
+    Workspace: 'workspace'
+};
+const FilterOperatorType = {
+    Contains: 'contains',
+    NotContains: 'NotContains',
+    Equals: 'equals',
+    EndsWith: 'endsWith',
+    IsAfter: 'after',
+    IsBefore: 'before',
+    Is: 'is',
+    IsNot: 'not',
+    In: 'in',
+    NotIn: 'notIn',
+    StartsWith: 'startsWith',
+    GreaterThan: '>',
+    GreaterThanEqual: '>=',
+    LessThan: '<',
+    LessThanEqual: '<='
+};
+const InputTypes = {
+    Currency: 'currency',
+    Date: 'date',
+    Link: 'link',
+    Password: 'password',
+    Percent: 'percent',
+    Text: 'text'
+};

package/dist/src/contents/index.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseInput", {
+    enumerable: true,
+    get: function() {
+        return parseInput;
+    }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _ = require("../");
+const _fixefyuicomponents = require("@fixefy/fixefy-ui-components");
+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;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+const parseInput = (_param)=>{
+    var { client, fetcher, control, structure, droppedItem, state, onInputChange, classes, args } = _param, rest = _object_without_properties(_param, [
+        "client",
+        "fetcher",
+        "control",
+        "structure",
+        "droppedItem",
+        "state",
+        "onInputChange",
+        "classes",
+        "args"
+    ]);
+    const { type, children } = structure;
+    const { AsyncDropdown, Textfield, clear, dropdownOptions } = _.ComponentTypes;
+    switch(type){
+        case AsyncDropdown:
+            {
+                return /*#__PURE__*/ (0, _jsxruntime.jsx)(_fixefyuicomponents.FxAsyncDropdown, _object_spread({
+                    classes: classes,
+                    structure: structure,
+                    fetcher: fetcher,
+                    onChange: ()=>{}
+                }, rest));
+            }
+        case Textfield:
+            {
+                return /*#__PURE__*/ (0, _jsxruntime.jsx)(_fixefyuicomponents.FxTextField, _object_spread({
+                    autoFocus: true,
+                    droppedItem: droppedItem,
+                    defaultValue: args && args.data && args.data.default_value,
+                    onChange: (e)=>onInputChange({
+                            structure,
+                            value: e.target.value
+                        }),
+                    structure: structure
+                }, rest));
+            }
+        case dropdownOptions:
+            return children.map((child)=>{
+                return parseInput(_object_spread({
+                    client,
+                    control,
+                    structure: child,
+                    droppedItem,
+                    state,
+                    onInputChange,
+                    classes,
+                    args
+                }, rest));
+            });
+        case clear:
+            return /*#__PURE__*/ (0, _jsxruntime.jsx)(_fixefyuicomponents.FxButton, _object_spread_props(_object_spread({}, rest), {
+                children: structure.name
+            }));
+    }
+};

package/dist/src/files/index.js

@@ -0,0 +1,41 @@
+"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, {
+    convertFileSize: function() {
+        return convertFileSize;
+    },
+    convertFileTypeToIcon: function() {
+        return convertFileTypeToIcon;
+    }
+});
+const convertFileSize = (fileSize)=>{
+    if (fileSize < 10000) {
+        return `${(fileSize / 1000).toFixed(1)} KB`;
+    } else if (fileSize < 10000000) {
+        return `${(fileSize / 1000000).toFixed(1)} MB`;
+    } else {
+        return 0;
+    }
+};
+const convertFileTypeToIcon = (fileType)=>{
+    switch(fileType){
+        case 'text/csv':
+            return 'uploader/file_type_csv.svg';
+        case 'text/xml':
+            return 'uploader/file_type_xml.svg';
+        case 'text/json':
+            return 'uploader/file_type_json.svg';
+        case 'text/xls':
+            return 'uploader/file_type_xls.svg';
+        default:
+            return 'uploader/file_type_csv.svg';
+    }
+};