@radiantabyss/vue 3.0.7

package/src/Routing/Router.js

@@ -0,0 +1,83 @@
+import { createRouter, createWebHistory } from 'vue-router';
+import Str from './../Support/Str';
+import Actions from './Actions';
+import Middleware from './Middleware';
+import RouteFiles from './RouteFiles';
+import Route from './Route';
+import RouteCrud from './RouteCrud';
+
+window.RouteFiles = RouteFiles;
+window.Route = Route;
+window.RouteCrud = RouteCrud;
+
+//load route files
+let context = import.meta.glob('/src/Routes/**/*.js');
+
+const loadModules = async () => {
+    window.Actions = await Actions();
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let file = files[i].replace('/src/Routes/', '').replace(/\.js$/, '');
+        window.__route_file = file;
+
+        if ( !RouteFiles[__route_file] ) {
+            RouteFiles[__route_file] = [];
+        }
+
+        await context[files[i]]();
+    }
+}
+
+export default async () => {
+    let runMiddleware = await Middleware();
+
+    await loadModules();
+
+    //create router
+    const Router = createRouter({
+        history: createWebHistory(),
+        routes: [],
+        duplicateNavigationPolicy: 'reload',
+        scrollBehavior(to, from, scroll) {
+            if ( (to.meta.settings && to.meta.settings.disable_scroll)
+                || (from.name == to.name && (!to.meta.settings || !to.meta.settings.force_scroll)) ) {
+                return scroll;
+            }
+
+            return {
+                x: 0,
+                y: 0
+            }
+        },
+    });
+
+    //run middleware
+    Router.beforeEach(async (to, from, next) => {
+        try {
+            await runMiddleware(to, from);
+            next();
+        }
+        catch(redirect) {
+            if ( redirect === false || to.path == redirect ) {
+                return next();
+            }
+
+            next({path: redirect});
+        }
+    });
+
+    Router.afterEach((to, from) => {
+        //save previous route
+        localStorage.setItem('_previous_route', from.fullPath != '/' ? from.fullPath : '');
+
+        //change document title
+        let title = to.name.replace(/\//g, ' / ').replace(/Action$/, '');
+        if ( to.meta.settings.title ) {
+            title = to.meta.settings.title;
+        }
+        document.title = `${title} :: ${import.meta.env.VITE_NAME}`;
+    });
+
+    return { Router, RouteFiles };
+};

package/src/Store.js

@@ -0,0 +1,54 @@
+import { createStore } from 'vuex';
+
+const Modules = {};
+let context = import.meta.glob('/src/Store/**/*.js');
+
+const loadModules = async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        split.shift();
+        split.shift();
+        split.shift();
+
+        let name = split[split.length - 1].replace('.js', '');
+        split.pop();
+
+        let module = await context[files[i]]();
+        setNamespace(Modules, name, split, module);
+    }
+}
+
+function setNamespace(Modules, name, namespace, module) {
+    if ( !namespace.length ) {
+        Modules[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 ( !Modules[first] ) {
+        Modules[first] = {
+            namespaced: true,
+            modules: {},
+        };
+    }
+
+    setNamespace(Modules[first].modules, name, namespace, module);
+}
+
+export default async (app) => {
+    await loadModules();
+
+    const Store = createStore({
+        modules: Modules,
+    });
+
+    window.Store = Store;
+    app.use(Store);
+};

package/src/Support/Cookie.js

@@ -0,0 +1,28 @@
+let self = {
+    get(key) {
+        key = key + "=";
+        var ca = document.cookie.split(';');
+        for(var i=0;i < ca.length;i++) {
+            var c = ca[i];
+            while (c.charAt(0)==' ') c = c.substring(1,c.length);
+            if (c.indexOf(key) == 0) return c.substring(key.length,c.length);
+        }
+        return null;
+    },
+
+    set(key, value, duration = 1) {
+        var expires = "";
+        if ( duration ) {
+            var date = new Date();
+            date.setTime(date.getTime() + (duration*24*60*60*1000));
+            expires = "; expires=" + date.toUTCString();
+        }
+        document.cookie = key + "=" + (value || "")  + expires + "; path=/;domain="+window.location.host.replace(':8080', '');
+    },
+
+    delete(key) {
+        self.set(key, null, -1);
+    },
+};
+
+export default self;

package/src/Support/Gate.js

@@ -0,0 +1,47 @@
+let self = {
+    gates: {},
+
+    allows(gate, param = null) {
+        self.check(gate);
+        return self.gates[gate](param);
+    },
+
+    denies(gate, param = null) {
+        self.check(gate);
+        return !self.gates[gate](param);
+    },
+
+    any(gates, param = null) {
+        for ( let gate of gates ) {
+            self.check(gate);
+            if ( self.gates[gate](param) ) {
+                return true;
+            }
+        }
+
+        return false;
+    },
+
+    none(gates, param = null) {
+        for ( let gate of gates ) {
+            self.check(gate);
+            if ( self.gates[gate](param) ) {
+                return false;
+            }
+        }
+
+        return true;
+    },
+
+    define(name, gate) {
+        self.gates[name] = gate;
+    },
+
+    check(gate) {
+        if ( typeof self.gates[gate] !== 'function' ) {
+            throw `Gate ${gate} does not exist.`;
+        }
+    }
+}
+
+export default self;

package/src/Support/Helpers.js

@@ -0,0 +1,36 @@
+let self = {
+    dmp(text) {
+        // eslint-disable-next-line
+        console.log(text);
+    },
+
+    handleEmpty(items) {
+        if ( items === false ) {
+            return false;
+        }
+
+        if ( items === null ) {
+            return null;
+        }
+
+        if ( Array.isArray(items) && !items.length ) {
+            return [];
+        }
+
+        if ( !Array.isArray(items) && !Object.keys(items).length ) {
+            return {};
+        }
+
+        return true;
+    },
+
+    array_unique(arr) {
+        return [...new Set(arr)];
+    },
+}
+
+for ( let helper in self ) {
+    window[helper] = self[helper];
+}
+
+export default self;

package/src/Support/Item.js

@@ -0,0 +1,63 @@
+let self = {
+	patch(item, data) {
+		return self.setKeys(item, Object.keys(data), Object.values(data));
+	},
+
+    setKey(item, key, value) {
+        return self.setKeys(item, key, value);
+    },
+
+    setKeys(item, keys, values) {
+        let not_empty = window.handleEmpty(item);
+        if ( not_empty !== true ) {
+            item = {};
+        }
+
+		if ( Array.isArray(keys) && !Array.isArray(values) ) {
+			let array_values = [];
+			for ( let key of keys ) {
+				array_values.push(values);
+			}
+			values = array_values;
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+			values = [values];
+        }
+
+        for ( let i = 0; i < keys.length; i++ ) {
+            item[keys[i]] = values[i];
+        }
+
+        return {...item};
+    },
+
+	removeEmptyKeys(item) {
+		let new_item = Array.isArray(item) ? [] : {};
+        let count = Array.isArray(item) ? item.length : Object.keys(item).length;
+		for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(item) ? i : Object.keys(item)[i];
+
+            if ( item[index] !== '' ) {
+                new_item[index] = item[index];
+            }
+        }
+
+        return new_item;
+	},
+
+    deleteKeys(item, keys) {
+		for ( let key of keys ) {
+	        delete item[key];
+		}
+
+		return {...item};
+    },
+
+    deleteKey(item, key) {
+		return self.deleteKeys(item, [key]);
+    },
+};
+
+export default self;

package/src/Support/Items.js

@@ -0,0 +1,363 @@
+const self = {
+    pluck(items, key = 'id') {
+        let plucked = [];
+        for (let i = 0; i < items.length; i++) {
+            plucked.push(items[i][key]);
+        }
+
+        return plucked;
+    },
+
+    spread(items) {
+        return JSON.parse(JSON.stringify(items));
+    },
+
+    keyBy(items, key = 'id') {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+            new_items[items[index][key]] = items[index];
+        }
+
+        return new_items;
+    },
+
+    groupBy(items, key = 'id') {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if (typeof new_items[items[index][key]] === 'undefined') {
+                new_items[items[index][key]] = [];
+            }
+
+            new_items[items[index][key]].push(items[index]);
+        }
+
+        return new_items;
+    },
+
+    find(items, ids) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return false;
+        }
+
+        let single = false;
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+            single = true;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                if ( Array.isArray(items) ) {
+                    new_items.push(items[index]);
+                }
+                else {
+                    new_items[index] = items[index];
+                }
+            }
+        }
+
+        if ( single ) {
+            if ( Array.isArray(new_items) && new_items.length ) {
+                return new_items[0];
+            }
+            else if ( !Array.isArray(new_items) && Object.keys(new_items).length ) {
+                return new_items[Object.keys(new_items)[0]];
+            }
+
+            return false;
+        }
+
+        return new_items;
+    },
+
+    findByKey(items, key, value = true, single = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return false;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index][key] == value ) {
+                if ( Array.isArray(items) ) {
+                    new_items.push(items[index]);
+                }
+                else {
+                    new_items[index] = items[index];
+                }
+            }
+        }
+
+        if ( single ) {
+            if ( Array.isArray(new_items) && new_items.length ) {
+                return new_items[0];
+            }
+            else if ( !Array.isArray(new_items) && Object.keys(new_items).length ) {
+                return new_items[Object.keys(new_items)[0]];
+            }
+
+            return false;
+        }
+
+        return new_items;
+    },
+
+    add(items, item, at_first_position = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            items = [];
+        }
+
+        if ( at_first_position ) {
+            items.unshift(item);
+        }
+        else {
+            items.push(item);
+        }
+
+        return items;
+    },
+
+    addMany(items, added, at_first_position = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            items = [];
+        }
+
+        if ( at_first_position ) {
+            return added.concat(items);
+        }
+        else {
+            return items.concat(added);
+        }
+    },
+
+    patch(items, data) {
+        if ( !data.id ) {
+            throw 'ID is required.';
+        }
+
+        let id = data.id;
+        delete data.id;
+
+        return self.setKeys(items, id, Object.keys(data), Object.values(data));
+    },
+
+    replace(items, item) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index].id == item.id ) {
+                new_items[index] = item;
+            }
+            else {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    delete(items, ids) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                continue;
+            }
+
+            if ( Array.isArray(items) ) {
+                new_items.push(items[index]);
+            }
+            else {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    deleteByKey(items, key, value) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index][key] != value ) {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    setKey(items, id, key, value) {
+        return self.setKeys(items, id, key, value);
+    },
+
+    setKeys(items, ids, keys, values) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        if ( Array.isArray(keys) && !Array.isArray(values) ) {
+			let array_values = [];
+			for ( let key of keys ) {
+				array_values.push(values);
+			}
+			values = array_values;
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+			values = [values];
+        }
+
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                for ( let j = 0; j < keys.length; j++ ) {
+                    items[i][keys[j]] = values[j];
+                }
+            }
+        }
+
+        return items;
+    },
+
+    toggleKey(items, id, key) {
+        return self.toggleKeys(items, id, key);
+    },
+
+    toggleKeys(items, ids, keys) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+        }
+
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                for ( let j = 0; j < keys.length; j++ ) {
+                    items[index][keys[j]] = !items[index][keys[j]];
+                }
+            }
+        }
+
+        return items;
+    },
+
+    sort(items, from, to) {
+        const copy = [...items];
+        const valueToMove = copy.splice(from, 1)[0];
+        copy.splice(to, 0, valueToMove);
+
+        return copy;
+    },
+
+    next(items, current, key = 'id')  {
+        for ( let i = 0; i < items.length; i++ ) {
+            if ( items[i][key] == current[key] && i < items.length - 1 ) {
+                return items[i + 1];
+            }
+        }
+
+        return false;
+    },
+
+    prev(items, current, key = 'id')  {
+        for ( let i = items.length - 1; i >= 0; i-- ) {
+            if ( items[i][key] == current[key] && i > 0 ) {
+                return items[i - 1];
+            }
+        }
+
+        return false;
+    },
+};
+
+window.pluck = self.pluck;
+window.spread = self.spread;
+window.keyBy = self.keyBy;
+window.groupBy = self.groupBy;
+
+export default self;

package/src/Support/ReactiveStorage.js

@@ -0,0 +1,30 @@
+import { reactive } from 'vue';
+
+const self = {
+    state: reactive({
+        data: {}
+    }),
+
+    setItem(key, value) {
+        localStorage.setItem(key, value);
+        self.state.data[key] = value;
+    },
+
+    getItem(key) {
+        if (!self.state.data[key]) {
+            const value = localStorage.getItem(key);
+            if (value) {
+                self.state.data[key] = value;
+            }
+        }
+
+        return self.state.data[key];
+    },
+
+    removeItem(key) {
+        localStorage.removeItem(key);
+        delete self.state.data[key];
+    }
+};
+
+export default self;