divhunt 2.0.0

package/lib/events.js

@@ -0,0 +1,108 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const handleReady = () =>
+{
+    window.divhunt.Emit('document.ready');
+};
+
+const handleLoad = () =>
+{
+    window.divhunt.Emit('document.load');
+};
+
+const handleResize = () =>
+{
+    window.divhunt.Emit('window.resize',
+    {
+        width: window.innerWidth,
+        height: window.innerHeight
+    });
+};
+
+const handleScroll = () =>
+{
+    window.divhunt.Emit('window.scroll',
+    {
+        x: window.scrollX,
+        y: window.scrollY
+    });
+};
+
+const handleVisibility = () =>
+{
+    window.divhunt.Emit('document.visibility',
+    {
+        hidden: document.hidden,
+        state: document.visibilityState
+    });
+};
+
+const handleBeforeUnload = () =>
+{
+    window.divhunt.Emit('window.beforeunload');
+};
+
+const handleFocus = () =>
+{
+    window.divhunt.Emit('window.focus');
+};
+
+const handleBlur = () =>
+{
+    window.divhunt.Emit('window.blur');
+};
+
+const handleOrientation = () =>
+{
+    window.divhunt.Emit('window.orientation',
+    {
+        angle: screen.orientation?.angle || window.orientation,
+        type: screen.orientation?.type || 'unknown'
+    });
+};
+
+const handleOnline = () =>
+{
+    window.divhunt.Emit('navigator.online');
+};
+
+const handleOffline = () =>
+{
+    window.divhunt.Emit('navigator.offline');
+};
+
+const handlePopstate = (event) =>
+{
+    window.divhunt.Emit('history.popstate',
+    {
+        state: event.state,
+        pathname: window.location.pathname
+    });
+};
+
+if (document.readyState === 'loading')
+{
+    document.addEventListener('DOMContentLoaded', handleReady);
+    window.addEventListener('load', handleLoad);
+}
+else if (document.readyState === 'interactive')
+{
+    handleReady();
+    window.addEventListener('load', handleLoad);
+}
+else
+{
+    handleReady();
+    handleLoad();
+}
+
+window.addEventListener('resize', handleResize);
+window.addEventListener('scroll', handleScroll);
+document.addEventListener('visibilitychange', handleVisibility);
+window.addEventListener('beforeunload', handleBeforeUnload);
+window.addEventListener('focus', handleFocus);
+window.addEventListener('blur', handleBlur);
+window.addEventListener('orientationchange', handleOrientation);
+window.addEventListener('online', handleOnline);
+window.addEventListener('offline', handleOffline);
+window.addEventListener('popstate', handlePopstate);

package/lib/load.js

@@ -0,0 +1,39 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import Divhunt from './src/divhunt.js';
+
+const divhunt = new Divhunt()
+
+process.on('SIGINT', async () => 
+{
+    await divhunt.Middleware('sigint');
+    await divhunt.Middleware('shutdown');
+    
+    process.exit(0);
+});
+
+process.on('SIGTERM', async () =>
+{
+    await divhunt.Middleware('sigterm');
+    await divhunt.Middleware('shutdown');
+
+    process.exit(0);
+});
+
+process.on('uncaughtException', async (error) =>
+{
+    await divhunt.Middleware('uncaughtException', { error });
+    await divhunt.Middleware('shutdown');
+
+    console.error('Uncaught Exception:', error);
+});
+
+process.on('unhandledRejection', async (reason, promise) =>
+{
+    await divhunt.Middleware('unhandledRejection', { reason, promise });
+    await divhunt.Middleware('shutdown');
+
+    console.error('Unhandled Rejection:', reason);
+});
+
+export default divhunt;

package/lib/src/classes/addon/class.js

@@ -0,0 +1,86 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import AddonGet from './mixins/get.js';
+import AddonStore from './mixins/store.js';
+import AddonFields from './mixins/fields.js';
+import AddonItems from './mixins/items.js';
+import AddonRemove from './mixins/remove.js';
+import AddonFunctions from './mixins/functions.js';
+import AddonTable from './mixins/table.js';
+import AddonFind from './mixins/find.js';
+import AddonRender from './mixins/render.js';
+
+class DivhuntAddon
+{
+    constructor(divhunt, name)
+    {
+        this.divhunt = divhunt;
+        this.name = name;
+
+        this.Store = {};
+
+        this.table =
+        {
+            name: null,
+            callbacks:
+            {
+                get: [],
+                create: [],
+                update: [],
+                delete: []
+            }
+        };
+
+        this.fields =
+        {
+            data: {},
+            callbacks:
+            {
+                add: [],
+                remove: []
+            }
+        };
+
+        this.functions =
+        {
+            data: {},
+            callbacks:
+            {
+                before: [],
+                after: [],
+                add: [],
+                remove: []
+            }
+        };
+
+        this.items =
+        {
+            data: {},
+            map: {},
+            id: 1,
+            callbacks:
+            {
+                add: [],
+                added: [],
+                remove: [],
+                removed: [],
+                modify: [],
+                modified: [],
+                get: [],
+                set: []
+            }
+        };
+    }
+};
+
+Object.assign(DivhuntAddon.prototype, AddonGet);
+Object.assign(DivhuntAddon.prototype, AddonStore);
+Object.assign(DivhuntAddon.prototype, AddonFields);
+Object.assign(DivhuntAddon.prototype, AddonItems);
+Object.assign(DivhuntAddon.prototype, AddonRemove);
+Object.assign(DivhuntAddon.prototype, AddonFunctions);
+Object.assign(DivhuntAddon.prototype, AddonTable);
+Object.assign(DivhuntAddon.prototype, AddonFind);
+Object.assign(DivhuntAddon.prototype, AddonRender);
+
+export default DivhuntAddon;

package/lib/src/classes/addon/classes/item/class.js

@@ -0,0 +1,27 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import AddonItemGet from './mixins/get.js';
+import AddonItemSet from './mixins/set.js';
+import AddonItemRemove from './mixins/remove.js';
+import AddonItemFunctions from './mixins/functions.js';
+import AddonItemCrud from './mixins/crud.js';
+import AddonItemStore from './mixins/store.js';
+
+class DivhuntAddonItem
+{
+    constructor(addon, data)
+    {
+        this.addon = addon;
+        this.data = data;
+        this.store = {};
+    }
+}
+
+Object.assign(DivhuntAddonItem.prototype, AddonItemGet);
+Object.assign(DivhuntAddonItem.prototype, AddonItemSet);
+Object.assign(DivhuntAddonItem.prototype, AddonItemRemove);
+Object.assign(DivhuntAddonItem.prototype, AddonItemFunctions);
+Object.assign(DivhuntAddonItem.prototype, AddonItemCrud);
+Object.assign(DivhuntAddonItem.prototype, AddonItemStore);
+
+export default DivhuntAddonItem;

package/lib/src/classes/addon/classes/item/mixins/crud.js

@@ -0,0 +1,30 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemCrud =
+{
+    async Create(connection = 'primary')
+    {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.create', value);
+
+        return value.response;
+    },
+
+    async Update(connection = 'primary')
+    {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.update', value);
+
+        return value.response;
+    },
+
+    async Delete(connection = 'primary')
+    {
+        const value = {item: this, table: this.addon.TableGet(), response: null, connection};
+        await this.addon.divhunt.Middleware('item.crud.delete', value);
+
+        return value.response;
+    }
+};
+
+export default AddonItemCrud;

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

@@ -0,0 +1,11 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemFunctions =
+{
+    Fn(name, ...data)
+    {
+        return this.addon.FnRun('item.' + name, this, ...data);
+    }
+};
+
+export default AddonItemFunctions;

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

@@ -0,0 +1,78 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemGet =
+{
+    Get(key, callback = true)
+    {
+        if(Array.isArray(key))
+        {
+            const data = {};
+
+            key.forEach((k) => 
+            {
+                data[k] = this.Get(k, callback);
+            });
+
+            return data;
+        }
+
+        const field = this.addon.FieldGet(key);
+        const any = this.addon.FieldGet('*');
+
+        if(!field && !any && key !== 'id')
+        {
+            return null;
+        }
+
+        let value = this.data[key];
+
+        field?.get.forEach(callback =>
+        {
+            value = callback(value, this);
+        });
+
+        any?.get.forEach(callback =>
+        {
+            value = callback(value, this);
+        });
+
+
+        try 
+        {
+            if(field?.define)
+            {
+                value = this.addon.divhunt.DataDefineOne(value, field.define)
+            }
+            else if(any?.define)
+            {
+                value = this.addon.divhunt.DataDefineOne(value, any.define)
+            }
+        }
+        catch(error)
+        {
+            throw new Error('Error getting value on field ' + key + '. ' + error.message)
+        }
+
+        if(callback)
+        {
+            this.addon.items.callbacks.get.forEach(callback => callback(this, key, value));
+            this.addon.divhunt.Emit('addon.item.get', this, key, value);
+        }
+
+        return value;
+    },
+
+    GetData(callback = true)
+    {
+        let data = {};
+
+        Object.entries(data).forEach(([key, value]) =>
+        {
+            data[key] = this.Get(key, callback);
+        })
+
+        return data;
+    }
+};
+
+export default AddonItemGet;

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

@@ -0,0 +1,11 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemRemove =
+{
+    Remove(callback = true)
+    {
+        this.addon.ItemRemove(this.data.id, callback);
+    },
+};
+
+export default AddonItemRemove;

package/lib/src/classes/addon/classes/item/mixins/set.js

@@ -0,0 +1,69 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemSet =
+{
+    Set(key, value, callback = true)
+    {
+        const field = this.addon.FieldGet(key);
+        const any = this.addon.FieldGet('*');
+
+        if(!field && !any)
+        {
+            return;
+        }
+
+        const prevValue = this.data[key];
+
+        field?.set?.forEach(callback =>
+        {
+            value = callback(value, prevValue, this);
+        });
+
+        any?.set?.forEach(callback =>
+        {
+            value = callback(value, prevValue, this);
+        });
+
+        try 
+        {
+            if(field?.define)
+            {
+                value = this.addon.divhunt.DataDefineOne(value, field.define)
+            }
+            else if(any?.define)
+            {
+                value = this.addon.divhunt.DataDefineOne(value, any.define)
+            }
+        }
+        catch(error)
+        {
+            throw new Error('Error setting value on field ' + key + '. ' + error.message)
+        }
+
+        if(callback)
+        {
+            this.addon.items.callbacks.modify.forEach(callback => callback(this, key, value, prevValue));
+            this.addon.items.callbacks.set.forEach(callback => callback(this, key, value));
+            this.addon.divhunt.Emit('addon.item.modify', this, key, value, prevValue);
+            this.addon.divhunt.Emit('addon.item.set', this, key, value, prevValue);
+        }
+
+        this.data[key] = value;
+
+        if(callback)
+        {
+            this.addon.items.callbacks.modified.forEach(callback => callback(this, key, value, prevValue));
+            this.addon.divhunt.Emit('addon.item.modified', this, key, value, prevValue);
+        }
+    },
+
+    SetData(data, callback = true)
+    {
+        Object.entries(data).forEach(([key, value]) =>
+        {
+            this.Set(key, value, callback);
+        })
+    }
+};
+
+export default AddonItemSet;

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

@@ -0,0 +1,58 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonItemStore =
+{
+    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' && key !== null && value === undefined)
+        {
+            Object.assign(this.store, key);
+            return this;
+        }
+
+        this.store[key] = value;
+        return this;
+    },
+
+    StoreHas(key)
+    {
+        return key in this.store;
+    },
+
+    StoreRemove(key)
+    {
+        if(Array.isArray(key))
+        {
+            key.forEach(k => delete this.store[k]);
+        }
+        else
+        {
+            delete this.store[key];
+        }
+        
+        return this;
+    },
+
+    StoreClear()
+    {
+        this.store = {};
+        return this;
+    }
+};
+
+export default AddonItemStore;

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

@@ -0,0 +1,117 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import RenderGet from './mixins/get.js';
+import RenderSet from './mixins/set.js';
+import RenderCompile from './mixins/compile.js';
+import RenderDOM from './mixins/dom.js';
+import RenderProcess from './mixins/process.js';
+import RenderMethods from './mixins/methods.js';
+import RenderEvents from './mixins/events.js';
+
+class DivhuntAddonRender
+{
+    constructor(addon, name, callback)
+    {
+        this.Addon = addon;
+        this.Name = name;
+        this.Callback = callback;
+
+        this._updateTimeout = null;
+        this.Data = {};
+        this.Attributes = {};
+        this.Item = null;
+        this.Slots = {};
+
+        this.Element = null;
+        this.Nodes = {};
+        this.Html = '';
+        this.Time = 0;
+
+        this.Events = {
+            init: [],
+            render: [],
+            mount: [],
+            mounted: [],
+            unmount: [],
+            unmounted: [],
+            destroy: [],
+            error: [],
+            ready: [],
+            visible: [],
+            resize: [],
+            compile: []
+        };
+
+        this.State = {
+            ready: false,
+            initialized: false,
+            rendered: false,
+            mounted: false,
+            destroyed: false,
+            rendering: false
+        };
+
+        this.Observer = {
+            visibility: undefined,
+            resize: undefined
+        };
+
+        const proxy = new Proxy(this, {
+            get(target, prop)
+            {
+                if (typeof target[prop] !== 'undefined' || typeof prop === 'symbol')
+                {
+                    return target[prop];
+                }
+
+                return target.Data[prop];
+            },
+
+            set(target, prop, value)
+            {
+                if (prop in target || typeof prop === 'symbol')
+                {
+                    target[prop] = value;
+                }
+                else
+                {
+                    const changed = target.Data[prop] !== value;
+                    target.Data[prop] = value;
+
+                    if(changed && target.State.ready && !target.State.rendering)
+                    {
+                        target._scheduleUpdate();
+                    }
+                }
+
+                return true;
+            }
+        });
+
+        return proxy;
+    }
+
+    _scheduleUpdate()
+    {
+        if(this._updateTimeout)
+        {
+            clearTimeout(this._updateTimeout);
+        }
+
+        this._updateTimeout = setTimeout(() =>
+        {
+            this._updateTimeout = null;
+            this.Update();
+        }, 16);
+    }
+}
+
+Object.assign(DivhuntAddonRender.prototype, RenderGet);
+Object.assign(DivhuntAddonRender.prototype, RenderSet);
+Object.assign(DivhuntAddonRender.prototype, RenderCompile);
+Object.assign(DivhuntAddonRender.prototype, RenderDOM);
+Object.assign(DivhuntAddonRender.prototype, RenderProcess);
+Object.assign(DivhuntAddonRender.prototype, RenderMethods);
+Object.assign(DivhuntAddonRender.prototype, RenderEvents);
+
+export default DivhuntAddonRender;