divhunt 2.0.0

package/lib/src/classes/addon/mixins/find.js

@@ -0,0 +1,14 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonFind =
+{
+    Find(connection = 'primary')
+    {
+        const value = {addon: this, table: this.TableGet(), response: null, connection};
+        this.divhunt.Middleware('addon.items.find', value);
+
+        return value.response;
+    }
+};
+
+export default AddonFind;

package/lib/src/classes/addon/mixins/functions.js

@@ -0,0 +1,131 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonFunctions =
+{
+    FnAdd(name, callback)
+    {
+        if(typeof name === 'object')
+        {
+            Object.entries(name).forEach(([key, value]) => this.FnAdd(key, value));
+            return this;
+        }
+
+        name = name.toLowerCase();
+
+        if (typeof callback !== 'function')
+        {
+            this.divhunt.LogWarn('Function "' + name + '" callback is not a function.');
+            return this;
+        }
+
+        this.functions.data[name] = {callback, name};
+
+        try
+        {
+            this.functions.callbacks.add.forEach(callback => callback.call(this, this.functions.data[name]));
+            this.divhunt.Emit('addon.function.add', name);
+        }
+        catch(error)
+        {
+            this.divhunt.LogError('Error in function "' + name + '" callback add.', {}, error);
+        }
+
+        return this;
+    },
+
+    FnGet(name)
+    {
+        name = name.toLowerCase();
+        return this.functions.data[name] || null;
+    },
+
+    FnRun(name, ...data)
+    {
+        name = name.toLowerCase();
+
+        const fn = this.FnGet(name);
+
+        if (!fn)
+        {
+            this.divhunt.LogError('Function not found.', {name});
+            return null;
+        }
+
+        let response = null;
+
+        const context = Object.create(this);
+        context.methods = {};
+
+        try
+        {
+            this.functions.callbacks.before.forEach(callback => callback.call(context, fn, ...data));
+            this.divhunt.Emit('addon.function.before', this, fn, response, ...data);
+        }
+        catch(error)
+        {
+            this.divhunt.LogError('Error in function callback before.', {name}, error);
+        }
+       
+        response = fn.callback.call(context, ...data);
+
+        try
+        {
+            this.functions.callbacks.after.forEach(callback => callback.call(context, fn, response, ...data));
+            this.divhunt.Emit('addon.function.after', context, fn, response, ...data);
+        }
+        catch(error)
+        {
+            this.divhunt.LogError('Error in function callback after.', {name}, error);
+        }
+
+        return response;
+    },
+    
+    FnRemove(name)
+    {
+        const fn = this.FnGet(name);
+
+        if (!fn)
+        {
+            return this;
+        }
+
+        try
+        {
+            this.functions.callbacks.remove.forEach(callback => callback.call(this, fn));
+            this.divhunt.Emit('addon.function.remove', this, fn);
+        }
+        catch(error)
+        {
+            this.divhunt.LogError('Error in function callback remove.', {name: fn.name}, error);
+        }
+
+        delete this.functions.data[fn.name];
+
+        return this;
+    },
+
+    FnOn(type, callback)
+    {
+        if(!(type in this.functions.callbacks))
+        {
+            return this.LogWarn('Item catcher not found.', {type});
+        }
+
+        this.functions.callbacks[type].push(callback);
+    },
+
+    Fn(name, ...data)
+    {
+        if(!this.FnGet(name) && data.length && typeof data[0] === 'function')
+        {
+            return this.FnAdd(name, ...data);
+        }
+        else
+        {
+            return this.FnRun(name, ...data);
+        }
+    }
+};
+
+export default AddonFunctions;

package/lib/src/classes/addon/mixins/get.js

@@ -0,0 +1,11 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonGet =
+{
+    GetName()
+    {
+        return this.name;
+    },
+};
+
+export default AddonGet;

package/lib/src/classes/addon/mixins/items.js

@@ -0,0 +1,176 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import DivhuntAddonItem from '../classes/item/class.js';
+
+const AddonItems =
+{
+    Item(identifierOrObject, map = null, then = null, callback = true)
+    {
+        if(identifierOrObject && typeof identifierOrObject === 'object')
+        {
+            return this.ItemAdd(identifierOrObject, then, callback);
+        }
+        else
+        {
+            return this.ItemGet(identifierOrObject, map, then);
+        }
+    },
+
+    Items()
+    {
+        return this.items.data;
+    },
+
+    ItemGet(identifier, map = null, then = null)
+    {
+        if(map)
+        {
+            if(!(map in this.items.map) || !(identifier in this.items.map[map])) 
+            {
+                return null;
+            }
+
+            return this.ItemGet(this.items.map[map][identifier], null, then);
+        }
+        
+        if(!(identifier in this.items.data))
+        {
+            return null;
+        }
+
+        then && then(this.items.data[identifier]);
+
+        return this.items.data[identifier];
+    },
+
+    ItemGetByMap(identifier, then = null)
+    {
+        if(!(identifier in this.items.data))
+        {
+            return null;
+        }
+
+        then && then(this.items.data[identifier]);
+
+        return this.items.data[identifier];
+    },
+
+    ItemAdd(object, then = null, callback = true, set = true)
+    {
+        if(!this.FieldGet('id'))
+        {
+            this.FieldAdd('id', ['number']);
+        }
+
+        let item = new DivhuntAddonItem(this, {});
+
+        if(!('id' in object))
+        {
+            object.id = this.items.id++;
+        }
+
+        item.SetData(object, false);
+
+        if(callback)
+        {
+            this.items.callbacks.add.forEach(callback => callback.call(this, item));
+            this.divhunt.Emit('addon.item.add', this, item);
+        }
+
+        then && then(item);
+
+        if(set)
+        {
+            this.items.data[item.Get('id') || this.items.id++] = item;
+        }
+
+        if(callback)
+        {
+            this.items.callbacks.added.forEach(callback => callback.call(this, item));
+            this.divhunt.Emit('addon.item.added', this, item);
+        }
+
+        return item;
+    },
+
+    ItemsAdd(items, then = null, callback = true)
+    {
+        const added = [];
+
+        for (const item of items)
+        {
+            added.push(this.ItemAdd(item, null, callback));
+        }
+
+        then && then(added);
+
+        return added;
+    },
+
+    ItemRemove(id, callback = true)
+    {
+        const item = this.ItemGet(id);
+
+        if(!item)
+        {
+            return;
+        }
+
+        Object.values(this.fields.data).forEach((field) =>
+        {
+            if(field.map)
+            {
+                delete this.items.map[field.name][item.Get(field.name)]
+            }
+        })
+
+        if(callback)
+        {
+            this.items.callbacks.remove.forEach(callback => callback.call(this, item));
+            this.divhunt.Emit('addon.item.remove', this, item);
+        }
+
+        delete this.items.data[id];
+
+        if(callback)
+        {
+            this.items.callbacks.removed.forEach(callback => callback.call(this, item));
+            this.divhunt.Emit('addon.item.removed', this, item);
+        }
+    },
+
+
+    ItemsRemove(callback = true)
+    {
+        if(!callback)
+        {
+            this.items.data = {};
+        }
+        else
+        {
+            for(let id in this.items.data)
+            {
+                this.ItemRemove(id, callback);
+            }
+        }
+    },
+
+    ItemOn(type, callback, id = null)
+    {
+        if(!(type in this.items.callbacks))
+        {
+            this.LogWarn('Item catcher not found for: ' + type + '.');
+            return this;
+        }
+
+        if(id)
+        {
+            this.items.callbacks[type] = this.items.callbacks[type].filter(cb => cb._id !== id);
+            callback._id = id;
+        }
+
+        this.items.callbacks[type].push(callback);
+    }
+};
+
+export default AddonItems;

package/lib/src/classes/addon/mixins/remove.js

@@ -0,0 +1,12 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonRemove =
+{
+    Remove(callback = true)
+    {
+        this.divhunt.AddonRemove(this.name, callback);
+    }
+};
+
+export default AddonRemove;
+

package/lib/src/classes/addon/mixins/render.js

@@ -0,0 +1,57 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import DivhuntAddonRender from '../classes/render/class.js';
+
+const AddonRender =
+{
+    Render(name, data = {}, attributes = {}, slots = {}, item = null)
+    {
+        if(typeof data === 'function')
+        {
+            return this.RenderAdd(name, data);
+        }
+        else
+        {
+            return this.RenderRun(name, data, attributes, slots, item);
+        }
+    },
+
+    RenderAdd(name, callback)
+    {
+        this.FnAdd('render.' + name, function(data, attributes, slots, item)
+        {
+            const render = new DivhuntAddonRender(this, name, callback);
+
+            render.SetData(data).SetAttributes(attributes).SetSlots(slots).SetItem(item);
+
+            return render.Process();
+        });
+
+        return this;
+    },
+
+    RenderRun(name, data = {}, attributes = {}, slots = {}, item = null)
+    {
+        const fn = this.FnGet('render.' + name);
+
+        if(!fn)
+        {
+            throw new Error('Render ' + name +' doesn\'t exist.');
+        }
+
+        return fn.callback.call(this, data, attributes, slots, item);
+    },
+
+    RenderRemove(name)
+    {
+        this.FnRemove('render.' + name);
+        return this;
+    },
+    
+    RenderExists(name)
+    {
+        return !!this.FnGet('render.' + name);
+    }
+};
+
+export default AddonRender;

package/lib/src/classes/addon/mixins/store.js

@@ -0,0 +1,52 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from "#framework/load.js";
+
+const AddonStore =
+{
+    StoreGet(key, value = undefined)
+    {
+        if(key === undefined)
+        {
+            return this.Store;
+        }
+
+        if(value !== undefined)
+        {
+            return divhunt.DataDefineOne(this.Store[key], [typeof value]);
+        }
+
+        return this.Store[key];
+    },
+
+    StoreSet(key, value)
+    {
+        if(typeof key === 'object')
+        {
+            Object.assign(this.Store, key);
+            return this;
+        }
+
+        this.Store[key] = value;
+        return this;
+    },
+
+    StoreHas(key)
+    {
+        return key in this.Store;
+    },
+
+    StoreDelete(key)
+    {
+        delete this.Store[key];
+        return this;
+    },
+
+    StoreClear()
+    {
+        this.Store = {};
+        return this;
+    }
+};
+
+export default AddonStore;

package/lib/src/classes/addon/mixins/table.js

@@ -0,0 +1,37 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonTable =
+{
+    Table(name = null, prefix = null)
+    {
+        if(name === null)
+        {
+            return this.TableGet();
+        }
+        else
+        {
+            return this.TableSet(name, prefix);
+        }
+    },
+
+    TableSet(name, prefix = null)
+    {
+        this.table.name = name;
+        this.table.prefix = prefix;
+    },
+
+    TableGet()
+    {
+        return this.table;
+    },
+
+    TableOn(type, callback)
+    {
+        if(type in this.table.callbacks)
+        {
+            this.table.callbacks.on(type, callback);
+        }
+    }
+};
+
+export default AddonTable;

package/lib/src/divhunt.js

@@ -0,0 +1,84 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import DivhuntAddons from './mixins/addons.js';
+import DivhuntGenerate from './mixins/generate.js';
+import DivhuntRequest from './mixins/request.js';
+import DivhuntData from './mixins/data.js';
+import DivhuntBinaries from './mixins/binaries.js';
+import DivhuntString from './mixins/string.js';
+import DivhuntEmitter from './mixins/emitter.js';
+import DivhuntMiddleware from './mixins/middleware.js';
+import DivhuntLogger from './mixins/logger.js';
+import DivhuntDependencies from './mixins/dependencies.js';
+import DivhuntFunction from './mixins/function.js';
+import DivhuntOverrides from './mixins/overrides.js';
+import DivhuntDOM from './mixins/dom.js';
+import DivhuntValidate from './mixins/validate.js';
+import DivhuntHelper from './mixins/helper.js';
+import DivhuntRoute from './mixins/route.js';
+
+class Divhunt
+{
+    constructor()
+    {
+        this.emitters = {};
+        this.middleware = {};
+
+        this.addons =
+        {
+            data: {},
+            callbacks:
+            {
+                add: [],
+                remove: []
+            }
+        };
+
+        this.dependencies = {
+            items: {},
+            callbacks: {
+                add: [],
+                remove: []
+            }
+        };
+
+        this.logger =
+        {
+            levels:
+            {
+                error: 0,
+                warn: 1,
+                info: 2,
+                http: 3,
+                verbose: 4,
+                debug: 5,
+                silly: 6
+            },
+            level: 'error'
+        };
+
+        this.data =
+        {
+            schemas: {},
+        };
+    }
+}
+
+Object.assign(Divhunt.prototype, DivhuntAddons);
+Object.assign(Divhunt.prototype, DivhuntEmitter);
+Object.assign(Divhunt.prototype, DivhuntGenerate);
+Object.assign(Divhunt.prototype, DivhuntRequest);
+Object.assign(Divhunt.prototype, DivhuntData);
+Object.assign(Divhunt.prototype, DivhuntBinaries);
+Object.assign(Divhunt.prototype, DivhuntString);
+Object.assign(Divhunt.prototype, DivhuntMiddleware);
+Object.assign(Divhunt.prototype, DivhuntLogger);
+Object.assign(Divhunt.prototype, DivhuntDependencies);
+Object.assign(Divhunt.prototype, DivhuntFunction);
+Object.assign(Divhunt.prototype, DivhuntOverrides);
+Object.assign(Divhunt.prototype, DivhuntDOM);
+Object.assign(Divhunt.prototype, DivhuntValidate);
+Object.assign(Divhunt.prototype, DivhuntHelper);
+Object.assign(Divhunt.prototype, DivhuntRoute);
+
+export default Divhunt;