@fixefy/fixefy-ui-utils 0.0.6 → 0.0.8

package/dist-es/commander/index.jsx

@@ -1,19 +1,19 @@
+import { EntityTypes } from '../';
+import { format } from 'date-fns';
+import { useCallback, useEffect, useRef, useState } from 'react';
 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) + "{}");
+        toRender.push(lineString(level, name) + '{}');
         return toRender;
     }
-    toRender.push(lineString(level, name) + "{");
+    toRender.push(lineString(level, name) + '{');
     keys.forEach((key) => {
-        if (key === "__typename")
+        if (key === '__typename')
             return;
-        if (typeof obj[key] === "object" && obj[key] !== null) {
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
             toRender.push(...buildCode(obj[key], level + 1, key));
         }
         else {
@@ -21,65 +21,65 @@ export function buildCode(obj, level = 0, name) {
             toRender.push(lineString(level + 1, key) + val);
         }
     });
-    toRender.push(lineString(level) + "}");
+    toRender.push(lineString(level) + '}');
     return toRender;
 }
 export const copyToClipboard = (str) => {
     if (window == undefined)
         return;
-    const el = document.createElement("textarea");
+    const el = document.createElement('textarea');
     el.value = str;
-    el.setAttribute("readonly", "");
-    el.style.position = "absolute";
-    el.style.left = "-9999px";
+    el.setAttribute('readonly', '');
+    el.style.position = 'absolute';
+    el.style.left = '-9999px';
     document.body.appendChild(el);
     el.select();
-    document.execCommand("copy");
+    document.execCommand('copy');
     document.body.removeChild(el);
 };
 export function convertToString(input) {
     if (input) {
-        return typeof input === "string" ? input : String(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";
+            case 'charged':
+                rv = '../../static/images/transactions/billing.svg';
                 break;
-            case "packed":
-                rv = "../../static/images/transactions/system.svg";
+            case 'packed':
+                rv = '../../static/images/transactions/system.svg';
                 break;
             default:
-                rv = "../../static/images/transactions/user.svg";
+                rv = '../../static/images/transactions/user.svg';
                 break;
         }
     }
     return rv;
 };
 export function formatNumberWithCommas(number) {
-    return number.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+    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";
+            rv = 'username';
             break;
         case EntityTypes.Pricing:
-            rv = "value";
+            rv = 'value';
             break;
         case EntityTypes.Metadata:
-            rv = "title";
+            rv = 'title';
             break;
         case EntityTypes.Transaction:
         case EntityTypes.Transmission:
-            rv = "readable_id";
+            rv = 'readable_id';
             break;
         default:
-            rv = "title";
+            rv = 'title';
             break;
     }
     return rv;
@@ -87,16 +87,16 @@ export function getNormalizationKeyForEntity(entity_type) {
 export const getStringValueByValueType = ({ value, name }) => {
     let rv;
     switch (typeof value) {
-        case "boolean":
-            rv = value === true ? "YES" : "NO";
+        case 'boolean':
+            rv = value === true ? 'YES' : 'NO';
             break;
-        case "number":
+        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") {
+            if (name === 'variance') {
                 _rv = (_rv * 100).toFixed(1);
                 rv = `${_rv}%`;
             }
@@ -104,48 +104,48 @@ export const getStringValueByValueType = ({ value, name }) => {
                 rv = _rv;
             }
             break;
-        case "object":
+        case 'object':
             if (Array.isArray(value)) {
-                rv = value.join(", ");
+                rv = value.join(', ');
             }
             else {
                 const entity_type = value && value.__typename && value.__typename.toLowerCase();
                 rv = titleCase(value[getNormalizationKeyForEntity(entity_type)]);
             }
             break;
-        case "string":
+        case 'string':
             rv = titleCase(value);
             break;
     }
     return rv;
 };
 export function getVal(val) {
-    if (typeof val === "number")
+    if (typeof val === 'number')
         return val;
-    if (typeof val === "string")
+    if (typeof val === 'string')
         return `"${val}"`;
     return val;
 }
-export const isInServer = () => typeof window === "undefined";
+export const isInServer = () => typeof window === 'undefined';
 export const isValidTimestamp = (_timestamp) => {
-    const parsedNumber = typeof _timestamp == "string" ? parseInt(_timestamp) : _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 = "";
+    let str = '';
     for (let i = 0; i < level; i++) {
-        str += "  ";
+        str += '  ';
     }
     if (name) {
-        str += name + ": ";
+        str += name + ': ';
     }
     return str;
 }
 export function makeString(len = 5) {
-    var text = "";
-    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    var text = '';
+    var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     for (var i = 0; i < len; i++)
         text += possible.charAt(Math.floor(Math.random() * possible.length));
     return text;
@@ -157,8 +157,7 @@ export const nest = ({ items }) => {
     items.forEach((item) => {
         if (item) {
             if (item.parent)
-                mappedArray[item.parent] &&
-                    mappedArray[item.parent].children.push(mappedArray[item.id]);
+                mappedArray[item.parent] && mappedArray[item.parent].children.push(mappedArray[item.id]);
             else
                 nestedArray.push(mappedArray[item.id]);
         }
@@ -167,20 +166,18 @@ export const nest = ({ items }) => {
 };
 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");
+    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];
+    return typeof body[key] === 'string' && (key === 'body' || key === 'raw') ? JSON.parse(body[key]) : body[key];
 }
-export function titleCase(str = "") {
+export function titleCase(str = '') {
     return str && toPascalCase(str.toString(), true);
 }
 export function toCamelCase(inputArray) {
-    let result = "";
+    let result = '';
     for (let i = 0, len = inputArray?.length ?? 0; i < len; i++) {
         let currentStr = inputArray?.at(i);
         let tempStr = currentStr.toLowerCase();
@@ -196,17 +193,16 @@ export function toCamelCaseString(input) {
     return toCamelCase(words);
 }
 export const toCurrency = (input) => {
-    return input ? input.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : input;
+    return input ? input.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',') : input;
 };
 export const toInitials = (str) => {
-    if (str === "")
+    if (str === '')
         return str;
     var matches = str.match(/\b(\w)/g);
-    return matches?.join("").toUpperCase();
+    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 ? " " : "")));
+    return string && string.replace(/(_[a-z])?(^[a-z])?(_|\s[a-z])?/g, ($1) => $1.toUpperCase().replace('_', title ? ' ' : ''));
 }
 export function toWords(input) {
     input = convertToString(input);
@@ -214,9 +210,9 @@ export function toWords(input) {
     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 : "";
+    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);
@@ -237,18 +233,18 @@ export const useStatePromisify = (_state) => {
 };
 export const getScoreColor = (value) => {
     if (value <= 20) {
-        return "bad";
+        return 'bad';
     }
     else if (value <= 40) {
-        return "low";
+        return 'low';
     }
     else if (value <= 60) {
-        return "medium";
+        return 'medium';
     }
     else if (value <= 80) {
-        return "high";
+        return 'high';
     }
     else {
-        return "excellent";
+        return 'excellent';
     }
 };

package/dist-es/contents/index.jsx

@@ -0,0 +1,31 @@
+import React from 'react';
+import { ComponentTypes } from '../';
+import { FxAsyncDropdown, FxButton, FxTextField } from '@fixefy/fixefy-ui-components';
+export const parseInput = ({ client, fetcher, control, structure, droppedItem, state, onInputChange, classes, args, ...rest }) => {
+    const { type, children } = structure;
+    const { AsyncDropdown, Textfield, clear, dropdownOptions } = ComponentTypes;
+    switch (type) {
+        case AsyncDropdown: {
+            return <FxAsyncDropdown classes={classes} structure={structure} fetcher={fetcher} onChange={() => { }} {...rest}/>;
+        }
+        case Textfield: {
+            return <FxTextField 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({
+                    client,
+                    control,
+                    structure: child,
+                    droppedItem,
+                    state,
+                    onInputChange,
+                    classes,
+                    args,
+                    ...rest,
+                });
+            });
+        case clear:
+            return <FxButton {...rest}>{structure.name}</FxButton>;
+    }
+};

package/dist-es/files/index.js

@@ -0,0 +1,22 @@
+export const convertFileSize = (fileSize) => {
+    if (fileSize < 10000) {
+        return `${(fileSize / 1000).toFixed(1)} KB`;
+    }
+    else if (fileSize < 10000000) {
+        return `${(fileSize / 1000000).toFixed(1)} MB`;
+    }
+};
+export 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';
+    }
+};

package/dist-es/graphql/index.js

@@ -0,0 +1,235 @@
+import pluralize from 'pluralize';
+import { Kind } from 'graphql/language';
+export const operationTypes = {
+    MUTATIONS: {
+        CREATE: 'mutations.create',
+        DELETE: 'mutations.delete',
+        UPDATE: 'mutations.update',
+        ACTION: 'mutations.action',
+    },
+    QUERIES: 'queries',
+    SUBSCRIPTIONS: 'subscriptions',
+};
+export const draggableTypes = {
+    ACTION: 'action',
+    ENTITY: 'entity',
+    FRAGMENT: 'fragment',
+    VARIABLES: 'variables',
+};
+export const getFields = ({ arg }) => (arg.type.getFields ? arg.type.getFields() : arg.type._nameLookup ? arg.type._nameLookup : arg.type.ofType && arg.type.ofType.getFields ? arg.type.ofType.getFields() : arg.type.ofType && arg.type.ofType.ofType && arg.type.ofType.ofType.getFields ? arg.type.ofType.ofType.getFields() : {});
+export const getFieldsStringified = ({ arg }) => (arg.type.getFields ? Object.keys(arg.type.getFields()) : arg.type.getValues ? Object.keys(arg.type.getValues()) : arg.type.ofType && arg.type.ofType.getFields ? Object.keys(arg.type.ofType.getFields()) : []);
+export const getTypeKind = (object) => {
+    return object && object.astNode && object.astNode.type && object.astNode.type.kind ? object.astNode.type.kind : object && object.astNode && object.astNode.kind ? object.astNode.kind : undefined;
+};
+export const getTypeName = (object) => {
+    return object && object.type ? (object.type.ofType ? object.type.ofType.name : object && object.type.name && object.type.name) : object.astNode && object.astNode.name;
+};
+export const getOperationObjectFromSchema = ({ operationName, schema }) => {
+    const queries = schema.getQueryType().getFields();
+    const mutations = schema.getMutationType().getFields();
+    const subscriptions = schema.getSubscriptionType().getFields();
+    let operationType;
+    let rv;
+    if (operationName in mutations) {
+        operationType = getOperationTypeForMutation({ operationName });
+        rv = mutations[operationName];
+    }
+    else if (operationName in queries) {
+        operationType = operationTypes.QUERIES;
+        rv = queries[operationName];
+    }
+    else if (operationName in subscriptions) {
+        operationType = operationTypes.SUBSCRIPTIONS;
+        rv = subscriptions[operationName];
+    }
+    return [rv, operationType];
+};
+export const getOperationTypeForMutation = ({ operationName }) => {
+    let operationType;
+    if (operationName.includes('create')) {
+        operationType = operationTypes.MUTATIONS.CREATE;
+    }
+    else if (operationName.includes('update')) {
+        operationType = operationTypes.MUTATIONS.UPDATE;
+    }
+    else if (operationName.includes('delete')) {
+        operationType = operationTypes.MUTATIONS.DELETE;
+    }
+    else {
+        operationType = operationTypes.MUTATIONS.ACTION;
+    }
+    return operationType;
+};
+export const getVariablesKeys = ({ variables, operationType }) => {
+    if (variables && variables != '') {
+        variables = JSON.parse(variables);
+        switch (operationType) {
+            case operationTypes.QUERIES:
+                const where = variables && variables.where;
+                return where && typeof where === 'object' ? Object.keys(where) : undefined;
+            case operationTypes.MUTATIONS.CREATE:
+                const data = variables && variables['data'];
+                return data && Array.isArray(data) ? Object.keys(data[0]) : typeof data === 'object' ? Object.keys(data) : undefined;
+            default:
+                const obj = (variables && variables['data']) || variables.where;
+                return obj && Array.isArray(obj) && obj.length > 0 ? Object.keys(obj[0]) : typeof obj === 'object' ? Object.keys(obj) : undefined;
+        }
+    }
+};
+export const insertNewVariable = ({ operationName, schema, key, value, _variables, action, ctx }) => {
+    const [raw, _] = getOperationObjectFromSchema({ operationName, schema });
+    Object.keys(_variables).forEach((upper_key) => {
+        if (raw) {
+            parseArgs({ raw, _variables, upper_key, key, action, value });
+        }
+        else {
+            throw `No Schema Action - '${operationName} - Go check the schema again'`;
+        }
+    });
+};
+export const isArgMandatory = (arg) => {
+    const kind = getTypeKind(arg);
+    const rv = kind === Kind.NON_NULL_TYPE;
+    return rv;
+};
+export const parseInputDataToDataObject = ({ key, value, parent, method, list, state, ...rest }) => {
+    let rv = state;
+    const type = typeof value;
+    switch (type) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            rv = parent
+                ? {
+                    ...rv,
+                    [parent]: {
+                        ...rv[parent],
+                        [method]: {
+                            ...rv[parent][method],
+                            [key]: value,
+                        },
+                    },
+                }
+                : {
+                    ...rv,
+                    [key]: value,
+                };
+            break;
+        case 'object':
+            rv = parent
+                ? {
+                    [parent]: {
+                        ...rv[parent],
+                        [method]: {
+                            ...rv[parent][method],
+                        },
+                    },
+                }
+                : {
+                    ...rv,
+                    [key]: {
+                        [method]: list ? value.map(({ id }) => ({ id })) : { id: value.id },
+                    },
+                };
+            break;
+    }
+    return rv;
+};
+const buildValue = ({ name, value }) => {
+    let rv;
+    switch (name) {
+        case 'Float':
+            rv = value || 0.0;
+            break;
+        case 'Int':
+            rv = value || 0;
+            break;
+        case 'ID':
+            rv = value || '000000000000000000000000';
+            break;
+        case 'String':
+            rv = value || '';
+            break;
+        default:
+            rv = name.includes('many') ? { connect: [{ id: value || '' }] } : { connect: { id: value || '' } };
+            break;
+    }
+    return rv;
+};
+const parseArgs = ({ raw, _variables, upper_key, key, action, value }) => {
+    raw.args.forEach((arg) => {
+        if (upper_key === arg.name) {
+            const fields = getFieldsStringified({ arg });
+            const fields_obj = getFields({ arg });
+            if (fields.length > 0) {
+                parseFields({
+                    fields,
+                    fields_obj,
+                    _variables,
+                    upper_key,
+                    key,
+                    action,
+                    value,
+                });
+            }
+            else {
+                throw `Schema Object/Action Does Not Have Any Fields`;
+            }
+        }
+    });
+};
+const parseFields = ({ fields, fields_obj, key, _variables, upper_key, value, action }) => {
+    let _existsInFields = false;
+    fields.forEach((field) => {
+        const _key = pluralize(key);
+        const exists = field.includes(_key.toLowerCase()) || field.includes(key.toLowerCase());
+        if (exists === true) {
+            _existsInFields = true;
+            const kind = getTypeName(fields_obj[field]);
+            if (action === 'mutation') {
+                setMutationEntityVariables({
+                    field,
+                    kind,
+                    _variables,
+                    upper_key,
+                    value,
+                });
+            }
+            else {
+                setQueryEntityVariables({
+                    field,
+                    kind,
+                    _variables,
+                    upper_key,
+                    value,
+                });
+            }
+        }
+    });
+    if (_existsInFields === false)
+        throw `Schema Object/Action Does Not Support - '${key}'`;
+};
+const setMutationEntityVariables = ({ field, kind, _variables, upper_key, value }) => {
+    Array.isArray(_variables[upper_key])
+        ?
+            (_variables[upper_key] = _variables[upper_key].map((item, i) => ({
+                ...item,
+                [field.toLowerCase()]: buildValue({ name: kind, value }),
+            })))
+        : (_variables[upper_key] = {
+            ..._variables[upper_key],
+            [field.toLowerCase()]: buildValue({ name: kind, value }),
+        });
+};
+const setQueryEntityVariables = ({ field, kind, _variables, upper_key, value }) => {
+    field.includes('some')
+        ? (_variables[upper_key] = {
+            ..._variables[upper_key],
+            [field]: { id_in: [value] },
+        })
+        : (_variables[upper_key] = {
+            ..._variables[upper_key],
+            [field]: value,
+        });
+};

package/dist-es/images/index.js

@@ -1 +1,9 @@
-export { imageLoader } from "./image_loader";
+export const imageLoader = ({ src, root }) => {
+    const transformedSrc = src.split('/');
+    transformedSrc.splice(transformedSrc.length - 1, 1, transformedSrc[transformedSrc.length - 1]
+        .split(/(?=[A-Z])/)
+        .join('_')
+        .toLowerCase());
+    const url = transformedSrc.join('/');
+    return `${root}${url}`;
+};

package/dist-es/index.js

@@ -1,6 +1,14 @@
+export * from './auth';
+export * from './aws';
 export * from './commander';
 export * from './constants';
+export * from './contents';
+export * from './graphql';
 export * from './headers';
 export * from './images';
+export * from './json';
 export * from './page_context';
+export * from './redirect';
+export * from './renderer';
 export * from './types';
+export * from './validate';