@radiantabyss/vue 3.0.7

package/babel.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  presets: [
+    '@vue/app'
+  ]
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@radiantabyss/vue",
+    "version": "3.0.7",
+    "author": "radiantabyss.com",
+    "license": "ISC",
+    "eslintConfig": {
+        "root": true,
+        "env": {
+            "node": true
+        },
+        "extends": [
+            "plugin:vue/essential",
+            "eslint:recommended"
+        ],
+        "rules": {},
+        "parserOptions": {
+            "parser": "babel-eslint"
+        },
+        "globals": {
+            "Alert": "writable",
+            "Cookie": "writable",
+            "Item": "writable",
+            "Items": "writable",
+            "Request": "writable",
+            "StorageHandler": "writable"
+        }
+    }
+}

package/src/Alert.js

@@ -0,0 +1,35 @@
+let self = {
+    show(message, type = 'success', duration = null) {
+        if ( typeof message != 'string' ) {
+            message = message.join('<br/>');
+        }
+
+        window.dispatchEvent(new CustomEvent('alert', { detail: {
+            message,
+            type,
+            duration,
+        }}));
+    },
+
+    success(message, duration = null) {
+        self.show(message, 'success', duration);
+    },
+
+    error(message, duration = null) {
+        self.show(message, 'error', duration);
+    },
+
+    info(message, duration = null) {
+        self.show(message, 'info', duration);
+    },
+
+    warning(message, duration = null) {
+        self.show(message, 'warning', duration);
+    },
+
+    hide() {
+        window.dispatchEvent(new Event('alert-hide'));
+    },
+};
+
+export default self;

package/src/Bootstrap.js

@@ -0,0 +1,42 @@
+import Components from './Components';
+import Directives from './Directives';
+import Mixins from './Mixins';
+import Modals from './Modals';
+
+import Alert from './Alert';
+import Cookie from './Support/Cookie';
+import Confirm from './Confirm';
+import Gate from './Support/Gate';
+import Helpers from './Support/Helpers';
+import Item from './Support/Item';
+import Items from './Support/Items';
+import Request from './Request';
+import ReactiveStorage from './Support/ReactiveStorage';
+import Str from './Support/Str';
+
+import Store from './Store';
+
+export default async (app) => {
+    await Components(app);
+    await Directives(app);
+    await Mixins(app);
+    await Modals(app);
+
+    window.Alert = Alert;
+    window.Cookie = Cookie;
+    window.Confirm = Confirm;
+    window.Gate = Gate;
+    window.Item = Item;
+    window.Items = Items;
+    window.Request = Request;
+    window.ReactiveStorage = ReactiveStorage;
+    window.Str = Str;
+
+    //make usable inside template
+    app.config.globalProperties.Item = Item;
+    app.config.globalProperties.Items = Items;
+    app.config.globalProperties.Gate = Gate;
+    app.config.globalProperties.Str = Str;
+
+    await Store(app);
+};

package/src/Components.js

@@ -0,0 +1,44 @@
+import Str from './Support/Str';
+
+let context_ra = import.meta.glob('@ra-components/Components/**/*.vue');
+let context = import.meta.glob('@/Components/**/*.vue');
+
+function getComponentName(file) {
+    let split = file.split('/');
+    let name = split[split.length - 1].replace('.vue', '')
+        .replace(/Component$/, '')
+        .replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2')
+        .toLowerCase();
+
+    return Str.trim(name, '-');
+}
+
+export default async (app) => {
+    //load src components
+    let files = Object.keys(context);
+    let components = [];
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let component = getComponentName(files[i]);
+        components.push(component);
+
+        let module = await context[files[i]]();
+        app.component(component, module.default);
+    }
+
+    //load ra vue components
+    files = Object.keys(context_ra);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let component = getComponentName(files[i]);
+
+        //enable component overloading. if component is already defined in src, continue
+        if ( components.includes(component) ) {
+            continue;
+        }
+
+        let module = await context_ra[files[i]]();
+        components.push(component);
+        app.component(component, module.default);
+    }
+}

package/src/Confirm.js

@@ -0,0 +1,8 @@
+export default function(params = {}) {
+    return new Promise(resolve => {
+        window.dispatchEvent(new CustomEvent('confirm', { detail: {
+            resolve,
+            params,
+        }}));
+    });
+}

package/src/Directives.js

@@ -0,0 +1,20 @@
+import Str from './Support/Str';
+
+let context = import.meta.glob('/src/Directives/**/*.js');
+
+export default async (app) => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '')
+            .replace(/Directive$/, '')
+            .replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2')
+            .toLowerCase();
+
+        name = Str.trim(name, '-');
+
+        let module = await context[files[i]]();
+        app.directive(name, module.default);
+    }
+}

package/src/Mixins.js

@@ -0,0 +1,16 @@
+let Mixins = {};
+let context = import.meta.glob('/src/Mixins/**/*.js');
+
+export default async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '')
+            .replace(/Mixin$/, '');
+
+        let module = await context[files[i]]();
+        Mixins[name] = module.default;
+    }
+    window.Mixins = Mixins;
+}

package/src/Modals.js

@@ -0,0 +1,19 @@
+import Str from './Support/Str';
+
+let context = import.meta.glob('/src/Modals/**/*.vue');
+
+export default async (app) => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.vue', '')
+            .replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2')
+            .toLowerCase();
+
+        name = Str.trim(name, '-');
+
+        let module = await context[files[i]]();
+        app.component(name, module.default);
+    }
+}

package/src/Request.js

@@ -0,0 +1,210 @@
+let sprite_version = import.meta.env.VITE_SPRITE_VERSION;
+
+const formatErrors = function(response) {
+    let errors = [];
+    if ( response && response.errors ) {
+        for ( let i in response.errors ) {
+            if ( typeof response.errors[i] === 'object' ) {
+                for (let j in response.errors[i]) {
+                    errors.push(response.errors[i][j]);
+                }
+            }
+            else {
+                errors.push(response.errors[i]);
+            }
+        }
+    }
+    else if ( response.statusText ) {
+        errors.push(response.statusText);
+    }
+
+    return errors;
+};
+
+const serializeToURLEncoded = (obj, prefix) => {
+    const str = [];
+    for ( let p in obj ) {
+        if ( obj.hasOwnProperty(p) ) {
+            const key = prefix ? `${prefix}[${p}]` : p;
+            const value = obj[p];
+
+            if ( typeof value === "object" ) {
+                str.push(serializeToURLEncoded(value, key));
+            }
+            else {
+                str.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+            }
+        }
+    }
+    return str.join("&");
+};
+
+const appendFormData = (formData, key, value) => {
+    if ( Array.isArray(value) ) {
+        value.forEach((v) => formData.append(`${key}[]`, v));
+    }
+    else if ( typeof value === 'object' && value !== null ) {
+        for ( let subKey in value ) {
+            appendFormData(formData, `${key}[${subKey}]`, value[subKey]);
+        }
+    }
+    else {
+        formData.append(key, value);
+    }
+};
+
+const request = function(method, edge, payload = {}, display_errors = false, base_url = null, auth_token = null, headers = {}, upload_progress = null) {
+    return new Promise((resolve, reject) => {
+        if ( !base_url ) {
+            base_url = import.meta.env.VITE_BACK_URL;
+        }
+
+        if ( !auth_token ) {
+            auth_token = localStorage.getItem('jwt_token');
+        }
+
+        if ( method === 'POST' ) {
+            Alert.hide();
+        }
+
+        if ( !Object.keys(headers).length ) {
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+        }
+
+        let _button;
+        if ( payload._button !== undefined ) {
+            _button = payload._button;
+            delete payload._button;
+        }
+
+        let _event;
+        if ( payload._event !== undefined ) {
+            _event = payload._event;
+            _event.preventDefault();
+
+            if ( _button === undefined ) {
+                _button = _event.target;
+            }
+
+            delete payload._event;
+        }
+
+        if ( _button !== undefined ) {
+            if ( _button.disabled ) {
+                return;
+            }
+            _button.disabled = true;
+        }
+
+        let data;
+        let url = base_url + edge;
+
+        if ( method === 'GET' ) {
+            url += '?' + new URLSearchParams(payload).toString();
+        }
+        else if ( method === 'POST' ) {
+            if ( headers['Content-Type'] === 'multipart/form-data' ) {
+                data = new FormData();
+
+                for (let key in payload) {
+                    appendFormData(data, key, payload[key]);
+                }
+
+                delete headers['Content-Type'];
+            }
+            else if ( headers['Content-Type'] === 'application/x-www-form-urlencoded' ) {
+                data = serializeToURLEncoded(payload).replace(/\&+$/, '');
+            }
+            else {
+                data = JSON.stringify(payload);
+                headers['Content-Type'] = 'application/x-www-form-urlencoded';
+            }
+        }
+
+        if ( auth_token ) {
+            if ( typeof auth_token !== 'object' ) {
+                auth_token = { jwt_token: auth_token };
+            }
+            for ( let key in auth_token ) {
+                if ( auth_token[key] !== '' && auth_token[key] !== null ) {
+                    url += url.includes('?') ? '&' : '?';
+                    url += `${key}=${auth_token[key]}`;
+                }
+            }
+        }
+
+        let _button_html;
+        if ( typeof _button !== 'undefined' ) {
+            _button_html = _button.innerHTML;
+
+            if ( payload._replace_html ) {
+                _button.innerHTML = `<svg class="svg-request-spinner"><use xlink:href="/sprites.svg?v=${sprite_version}#request-spinner"></use></svg>`;
+            }
+            else {
+                _button.innerHTML += `&nbsp;<svg class="svg-request-spinner"><use xlink:href="/sprites.svg?v=${sprite_version}#request-spinner"></use></svg>`;
+            }
+        }
+
+        fetch(url, {
+            method,
+            headers,
+            body: method === 'GET' ? undefined : data,
+        })
+        .then(async (response) => {
+            if ( _button !== undefined ) {
+                _button.disabled = false;
+                _button.innerHTML = _button_html;
+            }
+
+            const response_data = await response.json();
+
+            if ( edge.match(/\.json/) ) {
+                return resolve(response_data);
+            }
+
+            if ( response.ok && response_data.success ) {
+                return resolve(response_data.data);
+            }
+
+            const errors = formatErrors(response_data);
+            if ( display_errors ) {
+                Alert.error(errors.join('<br/>'), 7000);
+            }
+
+            reject(errors);
+        })
+        .catch((error) => {
+            let errors = [error.message];
+
+            if ( display_errors ) {
+                Alert.error(errors.join('<br/>'), 7000);
+            }
+
+            if ( _button !== undefined ) {
+                _button.disabled = false;
+                _button.innerHTML = _button_html;
+            }
+
+            reject(errors);
+        });
+    });
+};
+
+let self = {
+    get(edge, payload = {}, display_errors = false, base_url = null, auth_token = null, headers = {}) {
+        return request('GET', edge, payload, display_errors, base_url, auth_token, headers);
+    },
+
+    post(edge, payload = {}, display_errors = false, base_url = null, auth_token = null, headers = {}) {
+        return request('POST', edge, payload, display_errors, base_url, auth_token, headers);
+    },
+
+    upload(edge, payload = {}, display_errors = false, upload_progress, base_url = null, auth_token = null, headers = {}) {
+        headers['Content-Type'] = 'multipart/form-data';
+        return request('POST', edge, payload, display_errors, base_url, auth_token, headers, upload_progress);
+    },
+};
+
+export default self;

package/src/Routing/Actions.js

@@ -0,0 +1,47 @@
+let Actions = {};
+let context = import.meta.glob('/src/Domains/**/*.vue');
+
+const loadModules = async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        split.shift();
+        let name = split[split.length - 1].replace('.vue', '');
+        split.pop();
+        split.pop();
+        split.shift();
+        split.shift();
+
+        if ( !name.match(/Action$/) || name == 'Action' ) {
+            continue;
+        }
+
+        let module = await context[files[i]]();
+        setNamespace(Actions, name, split, module);
+    }
+}
+
+function setNamespace(Actions, name, namespace, module) {
+    if ( !namespace.length ) {
+        Actions[name] = module.default;
+        return;
+    }
+
+    let first = namespace[0].replace(/-/g, ' ').replace(/_/g, ' ').replace(/(^([a-zA-Z\p{M}]))|([ -][a-zA-Z\p{M}])/g,function(s) {
+        return s.toUpperCase();
+    }).replace(/ /g, '');
+
+    namespace.shift();
+
+    if ( !Actions[first] ) {
+        Actions[first] = {};
+    }
+
+    setNamespace(Actions[first], name, namespace, module);
+}
+
+export default async () => {
+    await loadModules();
+    return Actions;
+}

package/src/Routing/Middleware.js

@@ -0,0 +1,41 @@
+let Middleware = {};
+let context = import.meta.glob('/src/Http/Middleware/**/*.js');
+
+const loadModules = async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '').replace('Middleware', '');
+        let module = await context[files[i]]();
+        Middleware[name] = module.default;
+    }
+}
+
+let runMiddleware = async (to, from, i = 0) => {
+    //reached end, then everything passed
+    if ( i == to.meta.middleware.length ) {
+        return;
+    }
+
+    //middleware doesnt exist
+    if ( !Middleware[to.meta.middleware[i]] ) {
+        throw new Error(`${to.meta.middleware[i]} Middleware not found.`);
+    }
+
+    //run middleware
+    await Middleware[to.meta.middleware[i]](to, from);
+    await runMiddleware(to, from, i + 1);
+}
+
+export default async () => {
+    await loadModules();
+
+    return async (to, from) => {
+        if ( !to.meta || !to.meta.middleware ) {
+            return;
+        }
+
+        return runMiddleware(to, from);
+    };
+}

package/src/Routing/Route.js

@@ -0,0 +1,75 @@
+let group_middleware = null;
+
+function addRoute(path, action, middleware, name, throw_error) {
+    if ( !action ) {
+        throw `Action missing for ${path}`;
+    }
+
+    //format path
+    path = path.replace(/\{([\s\S]+?)\}/g, ':$1');
+
+    //get action
+    action = action.replace(/\\/g, '.').replace(/\//g, '.');
+    let split = action.split('.');
+    let namespace = split.slice(0, -1);
+    let action_name = name || split[split.length - 1];
+    let domain = namespace.length ? Str.slug(namespace[0]) : '';
+
+    if ( namespace.length ) {
+        action_name = namespace.join('/') + '/' + action_name;
+    }
+
+    let component;
+    try {
+        component = getAction(Actions, split[split.length - 1], namespace, action_name);
+    }
+    catch(e) {
+        if ( throw_error ) {
+            throw `Action ${action_name} doesn't exist.`;
+        }
+        return;
+    }
+
+    RouteFiles[__route_file].push({
+        name: action_name,
+        component,
+        path,
+        meta: {
+            domain,
+            middleware,
+            settings: component.settings ? component.settings : {},
+        },
+    });
+}
+
+function getAction(Actions, name, namespace, action_name) {
+    if ( !namespace.length ) {
+        let action = Actions[name];
+
+        action.name = action_name.replace(/\\/g, '.');
+        return action;
+    }
+
+    let first = namespace[0];
+    namespace.shift();
+
+    return getAction(Actions[first], name, namespace, action_name);
+}
+
+let self = {
+    get(path, action, middleware = [], name = '', throw_error = true) {
+        if ( group_middleware ) {
+            middleware = middleware.concat(group_middleware);
+        }
+
+        addRoute(path, action, middleware, name, throw_error);
+    },
+
+    group(middleware, callback) {
+        group_middleware = middleware;
+        callback();
+        group_middleware = null;
+    },
+}
+
+export default self;

package/src/Routing/RouteCrud.js

@@ -0,0 +1,15 @@
+import Str from './../Support/Str';
+
+let self = {
+    run(domain) {
+        domain = domain.replace(/\\/g, '.').replace(/\//g, '.');
+        let prefix = Str.kebab(domain).replace(/\./g, '/');
+
+        Route.get(`/${prefix}`, `${domain}.ListAction`, [], '', false);
+        Route.get(`/${prefix}/new/{id?}`, `${domain}.NewAction`, [], '', false);
+        Route.get(`/${prefix}/edit/{id}`, `${domain}.EditAction`, [], '', false);
+        Route.get(`/${prefix}/single/{id}`, `${domain}.SingleAction`, [], '', false);
+    }
+}
+
+export default self;

package/src/Routing/RouteFiles.js

@@ -0,0 +1 @@
+export default {};