@fixefy/fixefy-ui-utils 0.0.334 → 0.0.336

package/dist/src/graphql/index.js

@@ -0,0 +1,382 @@
+"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, {
+    draggableTypes: function() {
+        return draggableTypes;
+    },
+    getFields: function() {
+        return getFields;
+    },
+    getFieldsStringified: function() {
+        return getFieldsStringified;
+    },
+    getOperationObjectFromSchema: function() {
+        return getOperationObjectFromSchema;
+    },
+    getOperationTypeForMutation: function() {
+        return getOperationTypeForMutation;
+    },
+    getTypeKind: function() {
+        return getTypeKind;
+    },
+    getTypeName: function() {
+        return getTypeName;
+    },
+    getVariablesKeys: function() {
+        return getVariablesKeys;
+    },
+    insertNewVariable: function() {
+        return insertNewVariable;
+    },
+    isArgMandatory: function() {
+        return isArgMandatory;
+    },
+    operationTypes: function() {
+        return operationTypes;
+    },
+    parseInputDataToDataObject: function() {
+        return parseInputDataToDataObject;
+    }
+});
+const _pluralize = /*#__PURE__*/ _interop_require_default(require("pluralize"));
+const _language = require("graphql/language");
+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 operationTypes = {
+    MUTATIONS: {
+        CREATE: 'mutations.create',
+        DELETE: 'mutations.delete',
+        UPDATE: 'mutations.update',
+        ACTION: 'mutations.action'
+    },
+    QUERIES: 'queries',
+    SUBSCRIPTIONS: 'subscriptions'
+};
+const draggableTypes = {
+    ACTION: 'action',
+    ENTITY: 'entity',
+    FRAGMENT: 'fragment',
+    VARIABLES: 'variables'
+};
+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() : {};
+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()) : [];
+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;
+};
+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;
+};
+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
+    ];
+};
+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;
+};
+const getVariablesKeys = ({ variables, operationType })=>{
+    let obj;
+    let data;
+    let where;
+    if (variables && variables != '') {
+        variables = JSON.parse(variables);
+        switch(operationType){
+            case operationTypes.QUERIES:
+                where = variables && variables.where;
+                return where && typeof where === 'object' ? Object.keys(where) : undefined;
+            case operationTypes.MUTATIONS.CREATE:
+                data = variables && variables['data'];
+                return data && Array.isArray(data) ? Object.keys(data[0]) : typeof data === 'object' ? Object.keys(data) : undefined;
+            default:
+                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;
+        }
+    } else {
+        return {};
+    }
+};
+const insertNewVariable = ({ operationName, schema, key, value, _variables, action })=>{
+    // get raw action from schema
+    const [raw] = getOperationObjectFromSchema({
+        operationName,
+        schema
+    });
+    //  loop through the _variables keys
+    Object.keys(_variables).forEach((upper_key)=>{
+        // get the args and loop through the arguments
+        if (raw) {
+            parseArgs({
+                raw,
+                _variables,
+                upper_key,
+                key,
+                action,
+                value
+            });
+        } else {
+            throw `No Schema Action - '${operationName} - Go check the schema again'`;
+        }
+    });
+};
+const isArgMandatory = (arg)=>{
+    const kind = getTypeKind(arg);
+    const rv = kind === _language.Kind.NON_NULL_TYPE;
+    return rv;
+};
+const parseInputDataToDataObject = ({ key, value, parent, method, list, state })=>{
+    let rv = state;
+    const type = typeof value;
+    switch(type){
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+            rv = parent ? _object_spread_props(_object_spread({}, rv), {
+                [parent]: _object_spread_props(_object_spread({}, rv[parent]), {
+                    [method]: _object_spread_props(_object_spread({}, rv[parent][method]), {
+                        [key]: value
+                    })
+                })
+            }) : _object_spread_props(_object_spread({}, rv), {
+                [key]: value
+            });
+            break;
+        case 'object':
+            rv = parent ? {
+                [parent]: _object_spread_props(_object_spread({}, rv[parent]), {
+                    [method]: _object_spread({}, rv[parent][method])
+                })
+            } : _object_spread_props(_object_spread({}, rv), {
+                [key]: {
+                    [method]: list ? value.map(({ id })=>({
+                            id
+                        })) : {
+                        id: value.id
+                    }
+                }
+            });
+            break;
+    }
+    return rv;
+};
+/// ================================================================= ///
+/// ============================= LOCAL ============================= ///
+// returns a value of type according to the field
+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;
+};
+/// the first step in adding new variable from entity draggable
+const parseArgs = ({ raw, _variables, upper_key, key, action, value })=>{
+    raw.args.forEach((arg)=>{
+        // check if arg.name is equal to the _variables key
+        if (upper_key === arg.name) {
+            // get all fields keys
+            const fields = getFieldsStringified({
+                arg
+            });
+            const fields_obj = getFields({
+                arg
+            });
+            // check if fields exists
+            // loop through the fields
+            if (fields.length > 0) {
+                parseFields({
+                    fields,
+                    fields_obj,
+                    _variables,
+                    upper_key,
+                    key,
+                    action,
+                    value
+                });
+            } else {
+                // throw `Schema Object/Action Does Not Have Any Fields - '${operationName} - ${getFlower()}'`;
+                throw `Schema Object/Action Does Not Have Any Fields`;
+            }
+        }
+    // if (_exists && raw.args.length > 0 && _exists === false) throw `Schema Object/Action Does Not Support - '${key}'`;
+    });
+};
+/// the second step in adding new variable from entity draggable - take the fields and checks if this key is available / exists than set the entity according the operationType
+const parseFields = ({ fields, fields_obj, key, _variables, upper_key, value, action })=>{
+    let _existsInFields = false;
+    fields.forEach((field)=>{
+        // create a pluralized entity_type value
+        const _key = (0, _pluralize.default)(key);
+        // check if either the single or the pluralized value exists in the key
+        const exists = field.includes(_key.toLowerCase()) || field.includes(key.toLowerCase());
+        // if indeed it exists
+        if (exists === true) {
+            _existsInFields = true;
+            // get kind
+            const kind = getTypeName(fields_obj[field]);
+            // check if mutation or query
+            if (action === 'mutation') {
+                // check if the value is of type array
+                setMutationEntityVariables({
+                    field,
+                    kind,
+                    _variables,
+                    upper_key,
+                    value
+                });
+            } else {
+                // check if the string "some" exists 4in the field - meaning it is an array and format it accordingly
+                setQueryEntityVariables({
+                    field,
+                    kind,
+                    _variables,
+                    upper_key,
+                    value
+                });
+            }
+        }
+    });
+    if (_existsInFields === false) // throw `Schema Object/Action Does Not Support - '${key} - ${getFlower()}'`;
+    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)=>_object_spread_props(_object_spread({}, item), {
+            [field.toLowerCase()]: buildValue({
+                name: kind,
+                value
+            })
+        })) : _variables[upper_key] = _object_spread_props(_object_spread({}, _variables[upper_key]), {
+        [field.toLowerCase()]: buildValue({
+            name: kind,
+            value
+        })
+    });
+};
+const setQueryEntityVariables = ({ field, _variables, upper_key, value })=>{
+    field.includes('some') ? _variables[upper_key] = _object_spread_props(_object_spread({}, _variables[upper_key]), {
+        [field]: {
+            id_in: [
+                value
+            ]
+        }
+    }) : _variables[upper_key] = _object_spread_props(_object_spread({}, _variables[upper_key]), {
+        [field]: value
+    });
+} /// ================================================================= ///
+ /// ============================= To Be Built ========================= ///
+;

package/dist/src/headers/index.js

@@ -0,0 +1,161 @@
+"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, {
+    defaultHeaders: function() {
+        return defaultHeaders;
+    },
+    flushAll: function() {
+        return flushAll;
+    },
+    flushWorkspace: function() {
+        return flushWorkspace;
+    },
+    getCurrency: function() {
+        return getCurrency;
+    },
+    getHeaders: function() {
+        return getHeaders;
+    },
+    getWorkspace: function() {
+        return getWorkspace;
+    },
+    setCurrency: function() {
+        return setCurrency;
+    },
+    setHeaders: function() {
+        return setHeaders;
+    },
+    setWorkspace: function() {
+        return setWorkspace;
+    }
+});
+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 defaultHeaders = {
+    'bundle-name': '',
+    cur: {
+        _id: '5e8c8dfdfca1360007d7b654',
+        value: '5e8c8dfdfca1360007d7b654',
+        code: 'usd',
+        namePlural: 'us dollars',
+        symbol: '$'
+    },
+    hl: 'en',
+    'is-explain': true,
+    'last-activity': 0
+};
+const getHeaders = (ctx)=>{
+    let _headers = (0, _nookies.parseCookies)(ctx)['fixefy:headers'];
+    _headers = _headers && typeof _headers === 'string' ? JSON.parse(_headers) : typeof _headers === 'object' ? _headers : {};
+    const headers = _object_spread_props(_object_spread({}, _headers, defaultHeaders), {
+        ws: getWorkspace(ctx),
+        // mero: getMero(ctx),
+        cur: getCurrency(ctx)._id
+    });
+    return headers;
+};
+const setHeaders = (ctx, _headers)=>{
+    typeof _headers === 'string' ? (0, _nookies.setCookie)(ctx, 'fixefy:headers', _object_spread({}, JSON.parse(_headers)), {
+        maxAge: 7 * 24 * 60 * 60,
+        path: '/'
+    }) : (0, _nookies.setCookie)(ctx, 'fixefy:headers', _object_spread({}, _headers), {
+        maxAge: 7 * 24 * 60 * 60,
+        path: '/'
+    });
+};
+const getWorkspace = (ctx)=>{
+    var _parseCookies_ws;
+    const rv = (_parseCookies_ws = (0, _nookies.parseCookies)(ctx)['ws']) !== null && _parseCookies_ws !== void 0 ? _parseCookies_ws : defaultHeaders['ws'];
+    return rv;
+};
+const setWorkspace = (ctx, ws)=>{
+    (0, _nookies.setCookie)(ctx, 'ws', ws, {
+        maxAge: 7 * 24 * 60 * 60,
+        path: '/'
+    });
+};
+const flushWorkspace = (ctx)=>{
+    (0, _nookies.destroyCookie)(ctx, 'ws', {
+        path: '/'
+    });
+};
+const flushAll = (ctx)=>{
+    // flushLastActivity(ctx)
+    // flushMero(ctx);
+    flushWorkspace(ctx);
+};
+const setCurrency = (ctx, currency)=>{
+    (0, _nookies.setCookie)(ctx, 'cur', JSON.stringify(currency), {
+        maxAge: 7 * 24 * 60 * 60,
+        path: '/'
+    });
+};
+const getCurrency = (ctx)=>{
+    var _parseCookies_cur;
+    const cur = (_parseCookies_cur = (0, _nookies.parseCookies)(ctx)['cur']) !== null && _parseCookies_cur !== void 0 ? _parseCookies_cur : defaultHeaders['cur'];
+    if (cur) {
+        if (cur === 'usd' || cur === 'eur') {
+            setCurrency(ctx, defaultHeaders['cur']);
+        }
+        return typeof cur === 'string' ? JSON.parse(cur) : cur;
+    }
+};

package/dist/src/images/index.js

@@ -0,0 +1,18 @@
+// import React from 'react'
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "imageLoader", {
+    enumerable: true,
+    get: function() {
+        return imageLoader;
+    }
+});
+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('/');
+    // @ts-ignore
+    return `${root}${url}`;
+};

package/dist/src/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPageContext", {
+    enumerable: true,
+    get: function() {
+        return _page_context.default;
+    }
+});
+_export_star(require("./auth"), exports);
+_export_star(require("./aws"), exports);
+_export_star(require("./commander"), exports);
+_export_star(require("./constants"), exports);
+_export_star(require("./contents"), exports);
+_export_star(require("./files"), exports);
+_export_star(require("./graphql"), exports);
+_export_star(require("./headers"), exports);
+_export_star(require("./images"), exports);
+_export_star(require("./json"), exports);
+const _page_context = /*#__PURE__*/ _interop_require_default(_export_star(require("./page_context"), exports));
+_export_star(require("./redirect"), exports);
+_export_star(require("./renderer"), exports);
+_export_star(require("./transform"), exports);
+_export_star(require("./types"), exports);
+_export_star(require("./validate"), 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;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}