divhunt 2.0.0

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

@@ -0,0 +1,91 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderCompile =
+{
+    Compile(html, data = null)
+    {
+        const element = this.DOMCreateElement(html);
+
+        if(element.nodeType === Node.ELEMENT_NODE)
+        {
+            Object.entries(this.GetAttributes()).forEach(([key, value]) =>
+            {
+                element.setAttribute(key, value);
+            });
+
+            const prefix = this.GetAddon().GetName().charAt(0).toLowerCase();
+
+            element.classList.add(prefix + '-' + this.GetDivhunt().GenerateHash(this.GetAddon().GetName() + '-' + this.GetName()));
+        }
+
+        const compile = {
+            element,
+            data: this.GetData(),
+            nodes: {},
+            time: 0,
+            walk: true,
+            children: true
+        };
+
+        if(data)
+        {
+            compile.data = Object.assign({}, compile.data, data);
+        }
+
+        const start = performance.now();
+
+        this.GetDivhunt().Emit('addon.render.compile.before', this, compile, element, '0');
+
+        this.CompileWalkNodes(element, '0', compile);
+
+        this.GetDivhunt().Emit('addon.render.compile.after', this, compile, element, '0');
+
+        compile.time = performance.now() - start;
+
+        return compile;
+    },
+
+    CompileWalkNodes(node, identifier, compile)
+    {
+        if(!compile.walk || !node)
+        {
+            return;
+        }
+
+        compile.nodes[identifier] = node;
+
+        const originalRemove = node.remove;
+        let wasRemoved = false;
+
+        node.remove = function()
+        {
+            wasRemoved = true;
+            originalRemove.call(this);
+        };
+
+        this.GetDivhunt().Emit('addon.render.compile.node', this, compile, node, identifier);
+
+        node.remove = originalRemove;
+
+        if(wasRemoved)
+        {
+            return;
+        }
+
+        if(node.hasChildNodes() && compile.children)
+        {
+            const childNodes = Array.from(node.childNodes);
+
+            for(let i = 0; i < childNodes.length; i++)
+            {
+                this.CompileWalkNodes(childNodes[i], identifier + '-' + i, compile);
+            }
+        }
+        else if(node.hasChildNodes())
+        {
+            compile.children = true;
+        }
+    }
+};
+
+export default RenderCompile;

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

@@ -0,0 +1,18 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderDOM =
+{
+    DOMCreateElement(html)
+    {
+        const div = document.createElement('div');
+        div.innerHTML = html.trim();
+        return div;
+    },
+
+    DOMPatchElement(current, target)
+    {
+        return this.Addon.divhunt.DOMPatch(current, target);
+    },
+};
+
+export default RenderDOM;

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

@@ -0,0 +1,152 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderEvents =
+{
+    EventOn(event, callback)
+    {
+        if(!(event in this.Events))
+        {
+            throw new Error('Event ' + event + ' doesn\'t exist.');
+        }
+
+        const run = {
+            init:    () => this.State.initialized,
+            mount:   () => this.State.mounted,
+            mounted: () => this.State.mounted,
+            ready:   () => this.State.ready
+        };
+
+        if(run[event] && run[event]())
+        {
+            callback.call(this);
+        }
+        else
+        {
+            this.Events[event].push(callback);
+        }
+        
+        return this;
+    },
+
+    EventEmit(event, ...args)
+    {
+        if(!(event in this.Events))
+        {
+            throw new Error('Event ' + event + ' doesn\'t exist.');
+        }
+
+        const skip = {
+            init:      () => this.State.initialized,
+            mount:     () => this.State.mounted,
+            unmount:   () => !this.State.mounted,
+            unmounted: () => !this.State.mounted,
+            destroy:   () => this.State.destroyed,
+            ready:     () => this.State.ready
+        };
+
+        if(skip[event] && skip[event]())
+        {
+            return this;
+        }
+
+        this.Events[event].forEach(callback => callback.call(this, ...args));
+
+        const after = {
+            init:      () => { this.State.initialized = true; },
+            mount:     () => { this.State.mounted = true; },
+            render:    () => { this.State.rendered = true; },
+            ready:     () => { this.State.ready = true; },
+            destroy:   () => { this.State.destroyed = true; this.EventCleanup(); },
+            mounted:   () => { this.EventEmit('ready'); },
+            unmounted: () => { this.State.mounted = false; }
+        };
+
+        if(after[event])
+        {
+            after[event]();
+        }
+
+        return this;
+    },
+
+    EventOff(event, callback)
+    {
+         if(!(event in this.Events))
+        {
+            throw new Error('Event ' + event + ' doesn\'t exist.');
+        }
+
+        if(!callback)
+        {
+            this.Events[event] = [];
+            return this;
+        }
+
+        const index = this.Events[event].indexOf(callback);
+        if(index > -1)
+        {
+            this.Events[event].splice(index, 1);
+        }
+
+        return this;
+    },
+
+    EventOnce(event, callback)
+    {
+        const onceWrapper = (...args) =>
+        {
+            callback.call(this, ...args);
+            this.EventOff(event, onceWrapper);
+        };
+
+        return this.EventOn(event, onceWrapper);
+    },
+
+    EventInitObserver(type)
+    {
+        if(this.Observer[type])
+        {
+            return;
+        }
+
+        this.EventOn('mount', () =>
+        {
+            if(type === 'visibility')
+            {
+                this.Observer[type] = new IntersectionObserver(entries =>
+                {
+                    entries.forEach(entry =>
+                    {
+                        if(entry.isIntersecting)
+                        {
+                            this.EventEmit('visible', entry);
+                        }
+                    });
+                }, {threshold: 0.1});
+            }
+            else if(type === 'resize')
+            {
+                this.Observer[type] = new ResizeObserver(entries =>
+                {
+                    entries.forEach(entry => this.EventEmit('resize', entry));
+                });
+            }
+
+            this.Observer[type].observe(this.Element);
+        });
+    },
+    
+    EventCleanup()
+    {
+        Object.keys(this.Observer).forEach(key =>
+        {
+            if(this.Observer[key])
+            {
+                this.Observer[key].disconnect();
+                this.Observer[key] = undefined;
+            }
+        });
+    }
+};
+
+export default RenderEvents;

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

@@ -0,0 +1,56 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderGet =
+{
+    GetName()
+    {
+        return this.Name;
+    },
+
+    GetCallback()
+    {
+        return this.Callback;
+    },
+    
+    GetAddon()
+    {
+        return this.Addon;
+    },
+
+    GetDivhunt()
+    {
+        return this.Addon.divhunt;
+    },
+    
+    GetData()
+    {
+        return this.Data;
+    },
+    
+    GetAttributes()
+    {
+        return this.Attributes;
+    },
+
+    GetItem()
+    {
+        return this.Item;
+    },
+    
+    GetElement()
+    {
+        return this.Element;
+    },
+    
+    GetNodes()
+    {
+        return this.Nodes;
+    },
+
+    GetReady()
+    {
+        return this.State.ready;
+    }
+}
+
+export default RenderGet;

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

@@ -0,0 +1,191 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderMethods =
+{
+    Mount(target)
+    {
+        try
+        {
+            if(!this.Element)
+            {
+                throw new Error('Cannot mount - render not processed');
+            }
+            
+            if(this.State.mounted)
+            {
+                throw new Error('Already mounted');
+            }
+            
+            /* Before mount */
+            this.EventEmit('mount');
+            
+            /* Insert into DOM */
+            target = typeof target === 'string' ? document.querySelector(target) : target;
+
+            if(!target)
+            {
+                throw new Error('Target element not found');
+            }
+
+            target.appendChild(this.Element);
+            
+            /* After mount */
+            this.EventEmit('mounted');
+            
+            return this;
+        }
+        catch(error)
+        {
+            console.log(error);
+            this.EventEmit('error', error);
+            return this;
+        }
+    },
+    
+    Unmount()
+    {
+        try
+        {
+            if(!this.State.mounted)
+            {
+                return this;
+            }
+            
+            /* Before unmount */
+            this.EventEmit('unmount');
+            
+            /* Remove from DOM */
+            if(this.Element && this.Element.parentNode)
+            {
+                this.Element.parentNode.removeChild(this.Element);
+            }
+            
+            /* After unmount */
+            this.EventEmit('unmounted');
+            
+            return this;
+        }
+        catch(error)
+        {
+            this.EventEmit('error', error);
+            return this;
+        }
+    },
+    
+    Destroy()
+    {
+        try
+        {
+            /* Unmount first */
+            this.Unmount();
+            
+            /* Emit destroy */
+            this.EventEmit('destroy');
+            
+            /* Clear references */
+            this.Element = null;
+            this.Nodes = {};
+
+            return this;
+        }
+        catch(error)
+        {
+            this.EventEmit('error', error);
+            return this;
+        }
+    },
+
+    /* State Management */
+    
+    Define(config)
+    {
+        const data = this.GetDivhunt().DataDefine(this, config);
+
+        for(const key in data)
+        {
+            this.Data[key] = data[key];
+        }
+    },
+
+    Update()
+    {
+        try
+        {
+            if(!this.Element)
+            {
+                throw new Error('Cannot update - element not rendered');
+            }
+
+            const compiled = this.Compile(this.Html);
+
+            this.GetDivhunt().DOMPatch(this.Element, compiled.element);
+
+            this.Nodes = compiled.nodes;
+            this.Time = compiled.time;
+
+            return this;
+        }
+        catch(error)
+        {
+            this.EventEmit('error', error);
+            return this;
+        }
+    },
+
+    /* Lifecycle Hooks */
+    
+    OnInit(callback)
+    {
+        return this.EventOn('init', callback);
+    },
+    
+    OnMount(callback)
+    {
+        return this.EventOn('mount', callback);
+    },
+    
+    OnMounted(callback)
+    {
+        return this.EventOn('mounted', callback);
+    },
+    
+    
+    OnBeforeUnmount(callback)
+    {
+        return this.EventOn('unmount', callback);
+    },
+    
+    OnUnmount(callback)
+    {
+        return this.EventOn('unmount', callback);
+    },
+    
+    OnDestroy(callback)
+    {
+        return this.EventOn('destroy', callback);
+    },
+    
+    OnReady(callback)
+    {
+        return this.EventOn('ready', callback);
+    },
+    
+    OnVisible(callback)
+    {
+        return this.EventOn('visible', callback);
+    },
+    
+    OnResize(callback)
+    {
+        return this.EventOn('resize', callback);
+    },
+    
+    
+    OnError(callback)
+    {
+        return this.EventOn('error', callback);
+    },
+    
+};
+
+export default RenderMethods;

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

@@ -0,0 +1,88 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderProcess =
+{
+    Process()
+    {
+        try
+        {
+            this.EventEmit('init');
+
+            this.ProcessContext();
+
+            const html = this.ProcessHtml();
+
+            this.Html = html;
+
+            this.EventEmit('render', html);
+
+            const compiled = this.Compile(html);
+
+            this.EventEmit('compile', compiled, false);
+
+            this.Element = compiled.element;
+            this.Nodes = compiled.nodes;
+            this.Time = compiled.time;
+
+            this.EventEmit('ready');
+
+            return this;
+        }
+        catch(error)
+        {
+            const compiled = this.Compile(this.ProcessError(error.message));
+
+            this.EventEmit('compile', compiled, true);
+
+            this.Element = compiled.element;
+            this.Nodes = compiled.nodes;
+            this.Time = compiled.time;
+
+            this.EventEmit('error', error);
+
+            return this;
+        }
+    },
+
+    ProcessContext()
+    {
+        const proto = Object.getPrototypeOf(this);
+        const methods = Object.getOwnPropertyNames(proto);
+
+        methods.forEach(method =>
+        {
+            if(typeof this[method] === 'function' && method !== 'constructor')
+            {
+                this[method] = this[method].bind(this);
+            }
+        });
+    },
+
+    ProcessHtml()
+    {
+        this.State.rendering = true;
+        const html = this.GetCallback().call(this, this.GetData());
+        this.State.rendering = false;
+
+        if(typeof html !== 'string')
+        {
+            throw new Error('Render function must return a string');
+        }
+
+        return html;
+    },
+
+    ProcessError(message)
+    {
+        const html = `
+            <div class="dh-render-error" style="padding: 20px; background: rgb(255 0 0 / 10%); border: 1px solid rgb(255 0 0 / 20%); border-radius: 4px; color: #FF0000; font-family: monospace;">
+                <strong>Render Error | Name: ${this.GetName()} | Addon: ${this.GetAddon().GetName()} </strong><br>
+                ${this.GetDivhunt().StringSanitize(message)}
+            </div>
+        `;
+        
+       return html;
+    }
+};
+
+export default RenderProcess;

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

@@ -0,0 +1,36 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const RenderSet =
+{
+    SetData(data)
+    {
+        this.Data = data;
+        return this;
+    },
+
+    SetAttributes(attributes)
+    {
+        this.Attributes = attributes;
+        return this;
+    },
+
+    SetItem(item)
+    {
+        this.Item = item;
+        return this;
+    },
+
+    SetSlots(slots)
+    {
+        this.Slots = slots;
+        return this;
+    },
+
+    SetCallback(callback)
+    {
+        this.Callback = callback;
+        return this;
+    }
+};
+
+export default RenderSet;

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

@@ -0,0 +1,85 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const AddonFields =
+{
+    Field(name, define = null, get = null, set = null, map = false, callback = true)
+    {
+        const field = this.FieldGet(name);
+
+        if(field)
+        {
+            return field;
+        }
+
+        return this.FieldAdd(name, define, get, set, map, callback);
+    },
+
+    Fields()
+    {
+        return this.fields;
+    },
+
+    FieldAdd(name, define = null, get = null, set = null, map = false, callback = true)
+    {
+        if(!(name in this.fields.data))
+        {
+            this.fields.data[name] = {name, define: null, get: [], set: [], map};
+        }
+
+        if(map)
+        {
+            if(!(name in this.items.map))
+            {
+                this.items.map = {};
+            }
+
+            this.items.map[name] = {};
+        }
+
+        if(define !== null) { this.fields.data[name].define = define; }
+        if(get !== null)    { this.fields.data[name].get.push(get); }
+        if(set !== null)    { this.fields.data[name].set.push(set); }
+
+        if(callback)
+        {
+            this.fields.callbacks.add.forEach(callback => callback.call(this, this.fields.data[name]));
+            this.divhunt.Emit('addon.field.add', this, this.fields.data[name]);
+        }
+
+        return this.fields.data[name];
+    },
+
+    FieldGet(name)
+    {
+        return this.fields.data[name];
+    },
+
+    FieldRemove(name, callback = true)
+    {
+        if(!(name in this.fields))
+        {
+            return;
+        }
+
+        if(callback)
+        {
+            this.fields.callbacks.remove.forEach(callback => callback.call(this, this.fields.data[name]));
+            this.divhunt.Emit('addon.field.remove', this, this.fields.data[name]);
+        }
+
+        delete this.fields.data[name];
+    },
+
+    FieldOn(type, callback)
+    {
+        if(!(type in this.fields.callbacks))
+        {
+            this.LogWarn('Field catcher not found.', {name});
+            return this;
+        }
+
+        this.fields.callbacks[type].push(callback);
+    }
+};
+
+export default AddonFields;