@onetype/framework 2.0.20

package/addons/modules/schedules/front/functions/start.js

@@ -0,0 +1,126 @@
+import schedules from '../addon.js';
+
+schedules.Fn('start', function(id)
+{
+    this.methods.single = (id) =>
+    {
+        const item = this.ItemGet(id);
+
+        if(!item || !item.Get('enabled'))
+        {
+            return false;
+        }
+
+        if(item.Get('timer'))
+        {
+            return false;
+        }
+
+        const type = item.Get('type');
+
+        if(type === 'once')
+        {
+            this.methods.once(item);
+        }
+        else if(type === 'interval')
+        {
+            this.methods.interval(item);
+        }
+        else if(type === 'cron')
+        {
+            this.methods.cron(item);
+        }
+
+        return true;
+    };
+
+    this.methods.once = (item) =>
+    {
+        const time = item.Get('time');
+        const target = typeof time === 'string' ? new Date(time).getTime() : time;
+        const delay = target - Date.now();
+
+        if(delay <= 0)
+        {
+            this.Fn('trigger', item.Get('id'));
+            return;
+        }
+
+        const next = new Date(target).toISOString();
+        item.Set('next', next);
+
+        const timer = setTimeout(() =>
+        {
+            this.Fn('trigger', item.Get('id'));
+            item.Set('timer', null);
+            item.Set('next', null);
+        }, delay);
+
+        item.Set('timer', timer);
+    };
+
+    this.methods.interval = (item) =>
+    {
+        const time = item.Get('time');
+        const ms = typeof time === 'string' ? parseInt(time, 10) : time;
+
+        const next = new Date(Date.now() + ms).toISOString();
+        item.Set('next', next);
+
+        const timer = setInterval(() =>
+        {
+            if(!item.Get('enabled'))
+            {
+                clearInterval(item.Get('timer'));
+                item.Set('timer', null);
+                item.Set('next', null);
+                return;
+            }
+
+            this.Fn('trigger', item.Get('id'));
+
+            const nextRun = new Date(Date.now() + ms).toISOString();
+            item.Set('next', nextRun);
+        }, ms);
+
+        item.Set('timer', timer);
+    };
+
+    this.methods.cron = (item) =>
+    {
+        const next = this.Fn('next', item.Get('id'));
+
+        if(!next)
+        {
+            return;
+        }
+
+        const delay = next - Date.now();
+        item.Set('next', new Date(next).toISOString());
+
+        const timer = setTimeout(() =>
+        {
+            this.Fn('trigger', item.Get('id'));
+            item.Set('timer', null);
+
+            if(item.Get('enabled'))
+            {
+                this.methods.cron(item);
+            }
+        }, delay);
+
+        item.Set('timer', timer);
+    };
+
+    if(id)
+    {
+        return this.methods.single(id);
+    }
+
+    for(const itemId in this.items.data)
+    {
+        this.methods.single(itemId);
+    }
+
+    return true;
+});

package/addons/modules/schedules/front/functions/stop.js

@@ -0,0 +1,38 @@
+import schedules from '../addon.js';
+
+schedules.Fn('stop', function(id)
+{
+    this.methods.single = (id) =>
+    {
+        const item = this.ItemGet(id);
+
+        if(!item)
+        {
+            return false;
+        }
+
+        const timer = item.Get('timer');
+
+        if(timer)
+        {
+            clearTimeout(timer);
+            clearInterval(timer);
+            item.Set('timer', null);
+            item.Set('next', null);
+        }
+
+        return true;
+    };
+
+    if(id)
+    {
+        return this.methods.single(id);
+    }
+
+    for(const itemId in this.items.data)
+    {
+        this.methods.single(itemId);
+    }
+
+    return true;
+});

package/addons/modules/schedules/front/functions/trigger.js

@@ -0,0 +1,161 @@
+import onetype from '#onetype';
+import schedules from '../addon.js';
+
+schedules.Fn('trigger', function(id, props = {})
+{
+    this.resolve = null;
+    this.item = null;
+    this.events = onetype.AddonGet('events');
+    this.commands = onetype.AddonGet('commands');
+    this.actions = onetype.AddonGet('actions');
+
+    this.methods.init = async (resolve) =>
+    {
+        this.resolve = resolve;
+        this.item = this.ItemGet(id);
+
+        if(!this.item)
+        {
+            return this.methods.done(null, `Schedule "${id}" not found.`, 404);
+        }
+
+        if(!this.item.Get('enabled'))
+        {
+            return this.methods.done(null, `Schedule "${id}" is disabled.`, 403);
+        }
+
+        this.methods.emit();
+        this.methods.track();
+
+        const callback = this.item.Get('callback');
+        const command = this.item.Get('command');
+        const action = this.item.Get('action');
+
+        if(callback)
+        {
+            await this.methods.callback(callback, props);
+        }
+        else if(command)
+        {
+            await this.methods.command(command, props);
+        }
+        else if(action)
+        {
+            await this.methods.action(action, props);
+        }
+        else
+        {
+            return this.methods.done(null, `Schedule "${id}" has no callback, command, or action.`, 400);
+        }
+    };
+
+    this.methods.emit = () =>
+    {
+        if(this.events)
+        {
+            this.events.Fn('emit', 'schedule.triggered', {
+                id,
+                type: this.item.Get('type'),
+                runs: this.item.Get('runs')
+            });
+        }
+    };
+
+    this.methods.track = () =>
+    {
+        const runs = this.item.Get('runs') || 0;
+        const repeat = this.item.Get('repeat');
+        const type = this.item.Get('type');
+
+        this.item.Set('runs', runs + 1);
+        this.item.Set('last', new Date().toISOString());
+
+        if(type === 'once')
+        {
+            this.Fn('disable', id);
+        }
+        else if(repeat !== null && runs + 1 >= repeat)
+        {
+            this.Fn('disable', id);
+        }
+    };
+
+    this.methods.callback = async (fn, props) =>
+    {
+        try
+        {
+            const data = await fn(props);
+            return this.methods.done(data, 'Schedule executed.', 200);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.command = async (command, props) =>
+    {
+        if(!this.commands)
+        {
+            return this.methods.done(null, 'Commands addon not available.', 500);
+        }
+
+        const commandId = typeof command === 'string' ? command : command.id;
+        const merged = typeof command === 'object' ? { ...command, ...props, id: undefined } : props;
+
+        const item = this.commands.ItemGet(commandId);
+
+        if(!item)
+        {
+            return this.methods.done(null, `Command "${commandId}" not found.`, 404);
+        }
+
+        try
+        {
+            const result = await item.Fn('run', merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.action = async (action, props) =>
+    {
+        if(!this.actions)
+        {
+            return this.methods.done(null, 'Actions addon not available.', 500);
+        }
+
+        const actionId = typeof action === 'string' ? action : action.id;
+        const merged = typeof action === 'object' ? { ...action, ...props, id: undefined } : props;
+
+        try
+        {
+            const result = await this.actions.Fn('run', actionId, merged);
+            return this.methods.done(result.data, result.message, result.code);
+        }
+        catch(error)
+        {
+            return this.methods.done(null, error.message, 500);
+        }
+    };
+
+    this.methods.done = (data, message, code) =>
+    {
+        this.resolve({ data, message, code });
+    };
+
+    return new Promise((resolve) =>
+    {
+        try
+        {
+            this.methods.init(resolve);
+        }
+        catch(error)
+        {
+            resolve({ data: null, message: error.message, code: 500 });
+        }
+    });
+});

package/addons/modules/schedules/front/load.js

@@ -0,0 +1,10 @@
+import schedules from './addon.js';
+
+import './functions/start.js';
+import './functions/stop.js';
+import './functions/trigger.js';
+import './functions/enable.js';
+import './functions/disable.js';
+import './functions/next.js';
+
+export default schedules;

package/addons/modules/shortcuts/front/#register/addon.js

@@ -0,0 +1,22 @@
+import onetype from '#onetype';
+
+const shortcuts = onetype.Addon('shortcuts', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null]);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('key', ['string']);
+    addon.Field('context', ['string', null]);
+    addon.Field('target', ['string', null]);
+    addon.Field('action', ['string|object', null]);
+    addon.Field('command', ['string|object', null]);
+    addon.Field('callback', ['function', null]);
+    addon.Field('condition', ['string|function', null]);
+    addon.Field('enabled', ['boolean', true]);
+    addon.Field('prevent', ['boolean', true]);
+    addon.Field('stop', ['boolean', false]);
+    addon.Field('priority', ['number', 0]);
+});
+
+export default shortcuts;

package/addons/modules/shortcuts/front/functions/context.js

@@ -0,0 +1,13 @@
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('context', function(name)
+{
+    if(name === undefined)
+    {
+        return this.StoreGet('context');
+    }
+
+    this.StoreSet('context', name);
+
+    return name;
+});

package/addons/modules/shortcuts/front/functions/disable.js

@@ -0,0 +1,15 @@
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('disable', function(id)
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return false;
+    }
+
+    item.Set('enabled', false);
+
+    return true;
+});

package/addons/modules/shortcuts/front/functions/enable.js

@@ -0,0 +1,15 @@
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('enable', function(id)
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return false;
+    }
+
+    item.Set('enabled', true);
+
+    return true;
+});

package/addons/modules/shortcuts/front/functions/register.js

@@ -0,0 +1,170 @@
+import onetype from '#onetype';
+import shortcuts from '../addon.js';
+
+shortcuts.Fn('register', function()
+{
+    if(this.StoreGet('registered'))
+    {
+        return;
+    }
+
+    this.StoreSet('registered', true);
+    this.StoreSet('context', null);
+
+    this.vars = onetype.AddonGet('variables');
+
+    this.methods.handler = (e) =>
+    {
+        const key = this.methods.parse(e);
+        const items = this.methods.match(key);
+
+        for(const item of items)
+        {
+            if(this.methods.check(item, e))
+            {
+                if(item.Get('prevent'))
+                {
+                    e.preventDefault();
+                }
+
+                if(item.Get('stop'))
+                {
+                    e.stopPropagation();
+                }
+
+                this.Fn('trigger', item.Get('id'));
+            }
+        }
+    };
+
+    this.methods.parse = (e) =>
+    {
+        const parts = [];
+
+        if(e.ctrlKey) parts.push('ctrl');
+        if(e.altKey) parts.push('alt');
+        if(e.shiftKey) parts.push('shift');
+        if(e.metaKey) parts.push('meta');
+
+        const name = e.key.toLowerCase();
+
+        if(!['control', 'alt', 'shift', 'meta'].includes(name))
+        {
+            parts.push(name);
+        }
+
+        return parts.join('+');
+    };
+
+    this.methods.match = (key) =>
+    {
+        const items = [];
+
+        for(const id in this.items.data)
+        {
+            const item = this.items.data[id];
+            const itemKey = item.Get('key');
+
+            if(itemKey && itemKey.toLowerCase() === key)
+            {
+                items.push(item);
+            }
+        }
+
+        items.sort((a, b) => b.Get('priority') - a.Get('priority'));
+
+        return items;
+    };
+
+    this.methods.check = (item, e) =>
+    {
+        if(!item.Get('enabled'))
+        {
+            return false;
+        }
+
+        if(!this.methods.context(item))
+        {
+            return false;
+        }
+
+        if(!this.methods.target(item))
+        {
+            return false;
+        }
+
+        if(!this.methods.condition(item, e))
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.context = (item) =>
+    {
+        const context = item.Get('context');
+        const current = this.StoreGet('context');
+
+        if(context && context !== current)
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.target = (item) =>
+    {
+        const target = item.Get('target');
+
+        if(!target)
+        {
+            return true;
+        }
+
+        const element = document.querySelector(target);
+
+        if(!element || !element.contains(document.activeElement))
+        {
+            return false;
+        }
+
+        return true;
+    };
+
+    this.methods.condition = (item, e) =>
+    {
+        const condition = item.Get('condition');
+
+        if(!condition)
+        {
+            return true;
+        }
+
+        if(typeof condition === 'function')
+        {
+            return condition(e);
+        }
+
+        if(typeof condition === 'string' && this.vars)
+        {
+            const processed = this.vars.Fn('process', condition);
+
+            try
+            {
+                return onetype.Function(`return ${processed}`)();
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        return true;
+    };
+
+    document.addEventListener('keydown', this.methods.handler);
+
+    this.StoreSet('handler', this.methods.handler);
+});