@fixefy/fixefy-ui-utils 0.0.1

package/dist-es/commander/commander.jsx

@@ -0,0 +1,254 @@
+import NumericHelper from '@fixefy/fixefy-numeric';
+import { format } from "date-fns";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { EntityTypes } from "../constants";
+export function 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;
+}
+export 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);
+};
+export function convertToString(input) {
+    if (input) {
+        return typeof input === "string" ? input : String(input);
+    }
+}
+export 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;
+};
+export function formatNumberWithCommas(number) {
+    return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+export function 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;
+}
+export const getStringValueByValueType = ({ value, name }) => {
+    let rv;
+    switch (typeof value) {
+        case "boolean":
+            rv = value === true ? "YES" : "NO";
+            break;
+        case "number":
+            if (isValidTimestamp(value)) {
+                rv = normalizeTimestamp(value, false);
+                break;
+            }
+            let _rv = Number(value) === value && value % 1 === 0 ? value : value.toFixed(2);
+            if (name === "variance") {
+                _rv = (_rv * 100).toFixed(1);
+                rv = `${_rv}%`;
+            }
+            else {
+                rv = _rv;
+            }
+            break;
+        case "object":
+            if (Array.isArray(value)) {
+                rv = value.join(", ");
+            }
+            else {
+                const entity_type = value && value.__typename && value.__typename.toLowerCase();
+                rv = titleCase(value[getNormalizationKeyForEntity(entity_type)]);
+            }
+            break;
+        case "string":
+            rv = titleCase(value);
+            break;
+    }
+    return rv;
+};
+export function getVal(val) {
+    if (typeof val === "number")
+        return val;
+    if (typeof val === "string")
+        return `"${val}"`;
+    return val;
+}
+export const isInServer = () => typeof window === "undefined";
+export const isValidTimestamp = (_timestamp) => {
+    const parsedNumber = typeof _timestamp == "string" ? parseInt(_timestamp) : _timestamp;
+    const newTimestamp = new Date(parsedNumber).getTime();
+    const rv = NumericHelper.isFloat(newTimestamp) && newTimestamp.toString().length >= 10;
+    return rv;
+};
+export function lineString(level, name) {
+    let str = "";
+    for (let i = 0; i < level; i++) {
+        str += "  ";
+    }
+    if (name) {
+        str += name + ": ";
+    }
+    return str;
+}
+export function makeString(len = 5) {
+    var text = "";
+    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (var i = 0; i < len; i++)
+        text += possible.charAt(Math.floor(Math.random() * possible.length));
+    return text;
+}
+export const nest = ({ items }) => {
+    let mappedArray = Object.create(null);
+    items.forEach((item) => (mappedArray[item.id] = { ...item, children: [] }));
+    let 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;
+};
+export function normalizeTimestamp(timestamp, options) {
+    const { dateOnly, format: _format } = options || {};
+    const _timestamp = typeof timestamp == "string" ? parseInt(timestamp) : timestamp;
+    const rv = format(new Date(_timestamp), _format ? _format : dateOnly ? "dd/MM/yyyy" : "dd/MM/yyyy hh:mm");
+    return rv;
+}
+export function normalizeStringBodyRaw(key, body) {
+    return typeof body[key] === "string" && (key === "body" || key === "raw")
+        ? JSON.parse(body[key])
+        : body[key];
+}
+export function titleCase(str = "") {
+    return str && toPascalCase(str.toString(), true);
+}
+export function toCamelCase(inputArray) {
+    let result = "";
+    for (let i = 0, len = inputArray?.length ?? 0; i < len; i++) {
+        let currentStr = inputArray?.at(i);
+        let tempStr = currentStr.toLowerCase();
+        if (i != 0) {
+            tempStr = tempStr.substr(0, 1).toUpperCase() + tempStr.substr(1);
+        }
+        result += tempStr;
+    }
+    return result;
+}
+export function toCamelCaseString(input) {
+    const words = toWords(input);
+    return toCamelCase(words);
+}
+export const toCurrency = (input) => {
+    return input ? input.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : input;
+};
+export const toInitials = (str) => {
+    if (str === "")
+        return str;
+    var matches = str.match(/\b(\w)/g);
+    return matches?.join("").toUpperCase();
+};
+export function toPascalCase(string, title = false) {
+    return (string &&
+        string.replace(/(_[a-z])?(^[a-z])?(_|\s[a-z])?/g, ($1) => $1.toUpperCase().replace("_", title ? " " : "")));
+}
+export function 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?.match(regex);
+}
+export function trimRuleCode(input) {
+    const stringefied = typeof input == "string" ? input : JSON.stringify(input);
+    let match = stringefied.substring(stringefied.indexOf("{") + 1, stringefied.lastIndexOf("}"));
+    return match ? match : "";
+}
+export const useStatePromisify = (_state) => {
+    const [state, setState] = useState(_state);
+    const resolverRef = useRef(null);
+    useEffect(() => {
+        if (resolverRef.current) {
+            resolverRef.current(state);
+            resolverRef.current = null;
+        }
+    }, [resolverRef.current, state]);
+    const handleSetState = useCallback((stateAction) => {
+        setState(stateAction);
+        return new Promise((resolve) => {
+            resolverRef.current = resolve;
+        });
+    }, [setState]);
+    return [state, handleSetState];
+};
+export 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-es/commander/index.js

@@ -0,0 +1 @@
+export * from './commander';

package/dist-es/constants/index.js

@@ -0,0 +1,84 @@
+export 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",
+};
+export 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",
+};
+export const DataTypes = {
+    CSV: "csv",
+    EDI: "edi",
+    JSON: "json",
+    PDF: "pdf",
+    XLS: "xls",
+    XML: "xml",
+};
+export 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",
+};
+export 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: "<=",
+};
+export const InputTypes = {
+    Currency: "currency",
+    Date: "date",
+    Link: "link",
+    Password: "password",
+    Percent: "percent",
+    Text: "text",
+};

package/dist-es/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}