divhunt 2.0.0

package/addons/modules/bugs/front/addon.js

@@ -0,0 +1,16 @@
+import divhunt from '#divhunt';
+
+const bugs = divhunt.Addon('bugs', (addon) =>
+{
+    addon.Field('id', ['string|number']);
+    addon.Field('message', ['string']);
+    addon.Field('type', ['string', 'error']);
+    addon.Field('source', ['string', null]);
+    addon.Field('code', ['number', null]);
+    addon.Field('data', ['object', null]);
+    addon.Field('time', ['object', null]);
+    addon.Field('notify', ['string', 'console']);
+    addon.Field('resolved', ['boolean', false]);
+});
+
+export default bugs;

package/addons/modules/bugs/front/functions/clear.js

@@ -0,0 +1,14 @@
+import bugs from '../addon.js';
+
+bugs.Fn('clear', function(source = null)
+{
+    const items = Object.values(this.Items());
+
+    for(const item of items)
+    {
+        if(source === null || item.Get('source') === source)
+        {
+            this.ItemRemove(item.Get('id'));
+        }
+    }
+});

package/addons/modules/bugs/front/functions/push.js

@@ -0,0 +1,15 @@
+import bugs from '../addon.js';
+
+bugs.Fn('push', function(source, message, code = null, data = null, type = 'error', notify = 'console')
+{
+    const item = this.Item({
+        source,
+        message,
+        code,
+        data,
+        type,
+        notify
+    });
+
+    return item;
+});

package/addons/modules/bugs/front/functions/resolve.js

@@ -0,0 +1,13 @@
+import bugs from '../addon.js';
+
+bugs.Fn('resolve', function(id)
+{
+    const item = this.ItemGet(id);
+
+    if(item)
+    {
+        item.Set('resolved', true);
+    }
+
+    return item;
+});

package/addons/modules/bugs/front/item/catch/add.js

@@ -0,0 +1,9 @@
+import bugs from '../../addon.js';
+
+bugs.ItemOn('add', function(item)
+{
+    if(!item.Get('time'))
+    {
+        item.Set('time', new Date());
+    }
+});

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

@@ -0,0 +1,9 @@
+import bugs from './addon.js';
+
+import './item/catch/add.js';
+
+import './functions/push.js';
+import './functions/clear.js';
+import './functions/resolve.js';
+
+export default bugs;

package/addons/modules/events/front/addon.js

@@ -0,0 +1,11 @@
+import divhunt from '#divhunt';
+
+const events = divhunt.Addon('events', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('callbacks', ['array', []]);
+});
+
+export default events;

package/addons/modules/events/front/functions/clear.js

@@ -0,0 +1,9 @@
+import events from '../addon.js';
+
+events.Fn('clear', function()
+{
+    for(const id in this.items.data)
+    {
+        this.ItemRemove(id);
+    }
+});

package/addons/modules/events/front/functions/emit.js

@@ -0,0 +1,60 @@
+import events from '../addon.js';
+
+events.Fn('emit', async function(id, data = {})
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return [];
+    }
+
+    const callbacks = item.Get('callbacks');
+    const results = [];
+    const remove = [];
+
+    const event = {
+        id,
+        data,
+        stopped: false,
+        stop: function() { this.stopped = true; }
+    };
+
+    for(let i = 0; i < callbacks.length; i++)
+    {
+        if(event.stopped)
+        {
+            break;
+        }
+
+        const entry = callbacks[i];
+
+        if(entry.condition && !entry.condition(data, event))
+        {
+            continue;
+        }
+
+        try
+        {
+            const result = await entry.callback(data, event);
+            results.push(result);
+        }
+        catch(error)
+        {
+            results.push({ error: error.message });
+        }
+
+        if(entry.once)
+        {
+            remove.push(entry.id);
+        }
+    }
+
+    if(remove.length > 0)
+    {
+        const cbs = item.Get('callbacks').filter(cb => !remove.includes(cb.id));
+        item.Set('callbacks', cbs);
+    }
+
+    return results;
+});

package/addons/modules/events/front/functions/off.js

@@ -0,0 +1,23 @@
+import events from '../addon.js';
+
+events.Fn('off', function(id, callback = null)
+{
+    const item = this.ItemGet(id);
+
+    if(!item)
+    {
+        return false;
+    }
+
+    if(callback === null)
+    {
+        item.Set('callbacks', []);
+        return true;
+    }
+
+    const callbacks = item.Get('callbacks');
+    const filtered = callbacks.filter(cb => cb.callback !== callback);
+    item.Set('callbacks', filtered);
+
+    return true;
+});

package/addons/modules/events/front/functions/on.js

@@ -0,0 +1,40 @@
+import events from '../addon.js';
+
+events.Fn('on', function(id, callback, opts = {})
+{
+    const priority = opts.priority || 0;
+    const condition = opts.condition || null;
+    const once = opts.once || false;
+
+    let item = this.ItemGet(id);
+
+    if(!item)
+    {
+        item = this.Item({ id });
+    }
+
+    const entry = {
+        id: Date.now() + Math.random(),
+        callback,
+        condition,
+        once,
+        priority
+    };
+
+    const callbacks = item.Get('callbacks');
+    callbacks.push(entry);
+    callbacks.sort((a, b) => b.priority - a.priority);
+    item.Set('callbacks', callbacks);
+
+    return () =>
+    {
+        const cbs = item.Get('callbacks');
+        const index = cbs.findIndex(cb => cb.id === entry.id);
+
+        if(index !== -1)
+        {
+            cbs.splice(index, 1);
+            item.Set('callbacks', cbs);
+        }
+    };
+});

package/addons/modules/events/front/functions/once.js

@@ -0,0 +1,6 @@
+import events from '../addon.js';
+
+events.Fn('once', function(id, callback, opts = {})
+{
+    return this.Fn('on', id, callback, { ...opts, once: true });
+});

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

@@ -0,0 +1,9 @@
+import events from './addon.js';
+
+import './functions/on.js';
+import './functions/once.js';
+import './functions/emit.js';
+import './functions/off.js';
+import './functions/clear.js';
+
+export default events;

package/addons/modules/schedules/back/addon.js

@@ -0,0 +1,26 @@
+import divhunt from '#divhunt';
+
+const schedules = divhunt.Addon('schedules', (addon) =>
+{
+    addon.Table('schedules');
+
+    addon.Field('id', ['string']);
+    addon.Field('name', ['string', null]);
+    addon.Field('group', ['string', null]);
+    addon.Field('description', ['string', null]);
+    addon.Field('type', ['string', 'once']);
+    addon.Field('time', ['string|number']);
+    addon.Field('command', ['string|object', null]);
+    addon.Field('callback', ['function', null]);
+    addon.Field('enabled', ['boolean', true]);
+    addon.Field('repeat', ['number', null]);
+    addon.Field('timezone', ['string', null]);
+    addon.Field('runs', ['number', 0]);
+    addon.Field('timer', ['any', null]);
+    addon.Field('last', ['string', null]);
+    addon.Field('next', ['string', null]);
+    addon.Field('created_at', ['string', null]);
+    addon.Field('updated_at', ['string', null]);
+});
+
+export default schedules;

package/addons/modules/schedules/back/functions/disable.js

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

package/addons/modules/schedules/back/functions/enable.js

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

package/addons/modules/schedules/back/functions/next.js

@@ -0,0 +1,142 @@
+import schedules from '../addon.js';
+
+schedules.Fn('next', function(id)
+{
+    this.item = this.ItemGet(id);
+
+    if(!this.item)
+    {
+        return null;
+    }
+
+    this.type = this.item.Get('type');
+    this.time = this.item.Get('time');
+    this.timezone = this.item.Get('timezone');
+
+    this.methods.once = () =>
+    {
+        const target = typeof this.time === 'string' ? new Date(this.time).getTime() : this.time;
+
+        if(target <= Date.now())
+        {
+            return null;
+        }
+
+        return target;
+    };
+
+    this.methods.interval = () =>
+    {
+        const ms = typeof this.time === 'string' ? parseInt(this.time, 10) : this.time;
+        return Date.now() + ms;
+    };
+
+    this.methods.cron = () =>
+    {
+        const parsed = this.methods.parse(this.time);
+
+        if(!parsed)
+        {
+            return null;
+        }
+
+        return this.methods.calculate(parsed);
+    };
+
+    this.methods.parse = (expr) =>
+    {
+        const parts = expr.trim().split(/\s+/);
+
+        if(parts.length !== 5)
+        {
+            return null;
+        }
+
+        return {
+            minute: parts[0],
+            hour: parts[1],
+            day: parts[2],
+            month: parts[3],
+            weekday: parts[4]
+        };
+    };
+
+    this.methods.calculate = (cron) =>
+    {
+        const now = new Date();
+
+        for(let i = 1; i < 525600; i++)
+        {
+            const next = new Date(now.getTime() + i * 60000);
+
+            if(this.methods.matches(next, cron))
+            {
+                return next.getTime();
+            }
+        }
+
+        return null;
+    };
+
+    this.methods.matches = (date, cron) =>
+    {
+        const minute = date.getMinutes();
+        const hour = date.getHours();
+        const day = date.getDate();
+        const month = date.getMonth() + 1;
+        const weekday = date.getDay();
+
+        return (
+            this.methods.field(cron.minute, minute, 0, 59) &&
+            this.methods.field(cron.hour, hour, 0, 23) &&
+            this.methods.field(cron.day, day, 1, 31) &&
+            this.methods.field(cron.month, month, 1, 12) &&
+            this.methods.field(cron.weekday, weekday, 0, 6)
+        );
+    };
+
+    this.methods.field = (expr, value, min, max) =>
+    {
+        if(expr === '*')
+        {
+            return true;
+        }
+
+        if(expr.includes(','))
+        {
+            const values = expr.split(',').map(v => parseInt(v, 10));
+            return values.includes(value);
+        }
+
+        if(expr.includes('-'))
+        {
+            const [start, end] = expr.split('-').map(v => parseInt(v, 10));
+            return value >= start && value <= end;
+        }
+
+        if(expr.includes('/'))
+        {
+            const [base, step] = expr.split('/');
+            const stepNum = parseInt(step, 10);
+            const startNum = base === '*' ? min : parseInt(base, 10);
+            return (value - startNum) % stepNum === 0 && value >= startNum;
+        }
+
+        return parseInt(expr, 10) === value;
+    };
+
+    if(this.type === 'once')
+    {
+        return this.methods.once();
+    }
+    else if(this.type === 'interval')
+    {
+        return this.methods.interval();
+    }
+    else if(this.type === 'cron')
+    {
+        return this.methods.cron();
+    }
+
+    return null;
+});

package/addons/modules/schedules/back/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/back/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;
+});