divhunt 2.0.0

package/lib/src/mixins/dom.js

@@ -0,0 +1,167 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntDOM =
+{
+    DOMCreate(html)
+    {
+        const wrapper = document.createElement('div');
+        wrapper.innerHTML = html.trim();
+
+        let element;
+
+        if(wrapper.childNodes.length === 1)
+        {
+            element = wrapper.firstChild;
+        }
+        else
+        {
+            element = document.createDocumentFragment();
+            
+            while(wrapper.firstChild)
+            {
+                element.appendChild(wrapper.firstChild);
+            }
+        }
+
+        return element;
+    },
+    
+    DOMPatch(current, target)
+    {
+        if(current === target)
+        {
+            return current;
+        }
+
+        if(!current || !target)
+        {
+            return target;
+        }
+
+        const shouldReplace = current.nodeType !== target.nodeType || (current.nodeType === Node.ELEMENT_NODE && current.nodeName.toUpperCase() !== target.nodeName.toUpperCase());
+
+        if(shouldReplace)
+        {
+            if(current.parentNode)
+            {
+                current.parentNode.replaceChild(target, current);
+                return target;
+            }
+
+            return target;
+        }
+
+        if(current.nodeType === Node.TEXT_NODE)
+        {
+            if(current.textContent !== target.textContent)
+            {
+                current.textContent = target.textContent;
+            }
+
+            return current;
+        }
+
+        if(current.nodeType === Node.ELEMENT_NODE)
+        {
+            this.DOMPatchAttributes(current, target);
+            this.DOMPatchChildren(current, target);
+
+            for(const key in target)
+            {
+                if(key.startsWith('dh') && typeof target[key] === 'function')
+                {
+                    current[key] = target[key];
+                }
+            }
+        }
+
+        return current;
+    },
+    
+    DOMPatchAttributes(current, target)
+    {
+        for(let i = 0; i < target.attributes.length; i++)
+        {
+            const attr = target.attributes[i];
+
+            if(current.getAttribute(attr.name) !== attr.value)
+            {
+                current.setAttribute(attr.name, attr.value);
+            }
+        }
+
+        for(let i = current.attributes.length - 1; i >= 0; i--)
+        {
+            const attr = current.attributes[i];
+
+            if(!target.hasAttribute(attr.name))
+            {
+                current.removeAttribute(attr.name);
+            }
+        }
+    },
+
+    DOMPatchChildren(current, target)
+    {
+        const currentChildren = Array.from(current.childNodes);
+        const targetChildren = Array.from(target.childNodes);
+
+        const maxLength = Math.max(currentChildren.length, targetChildren.length);
+
+        for(let i = 0; i < maxLength; i++)
+        {
+            const currentChild = currentChildren[i];
+            const targetChild = targetChildren[i];
+
+            if(!targetChild)
+            {
+                current.removeChild(currentChild);
+            }
+            else if(!currentChild)
+            {
+                current.appendChild(targetChild);
+            }
+            else
+            {
+                this.DOMPatch(currentChild, targetChild);
+            }
+        }
+    },
+    
+    DOMWalk(element, callback, depth = 0)
+    {
+        if(callback(element, depth) === false)
+        {
+            return;
+        }
+
+        if(element.childNodes)
+        {
+            for(let i = 0; i < element.childNodes.length; i++)
+            {
+                this.DOMWalk(element.childNodes[i], callback, depth + 1);
+            }
+        }
+    },
+
+    DOMObserve(element, options = {}, callback)
+    {
+        const observer = new MutationObserver(mutations =>
+        {
+            callback && callback(mutations);
+        });
+
+        observer.observe(element, {
+            childList: options.children !== false,
+            attributes: options.attributes !== false,
+            characterData: options.text !== false,
+            subtree: options.subtree !== false,
+            attributeOldValue: options.attributeOldValue !== false,
+            characterDataOldValue: options.textOldValue !== false
+        });
+
+        return observer;
+    }
+};
+
+export default DivhuntDOM;

package/lib/src/mixins/emitter.js

@@ -0,0 +1,77 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntEmitter =
+{
+    Emit(name, ...args)
+    {
+        name = name.toLowerCase();
+
+        if(!(name in this.emitters))
+        {
+            return;
+        }
+
+        this.emitters[name].forEach(emitter =>
+        {
+            try
+            {
+                emitter.callback(...args);
+
+                if (emitter.once)
+                {
+                    this.EmitOff(name, emitter.id);
+                }
+            }
+            catch(error)
+            {
+                this.LogError(`Error in emitter callback.`, {name}, error);
+            }
+        });
+    },
+
+    EmitOn(name, callback)
+    {
+        name = name.toLowerCase();
+
+        if(!this.emitters[name])
+        {
+            this.emitters[name] = [];
+        }
+
+        const id = this.GenerateUID();
+
+        this.emitters[name].push({id, once: false, callback});
+
+        return id;
+    },
+
+    EmitOnce(name, callback)
+    {
+        name = name.toLowerCase();
+
+        if(!this.emitters[name])
+        {
+            this.emitters[name] = [];
+        }
+
+        const id = this.GenerateUID();
+
+        this.emitters[name].push({id, once: true, callback});
+
+        return id;
+    },
+
+    EmitOff(name, id)
+    {
+        name = name.toLowerCase();
+
+        if(!(name in this.emitters))
+        {
+            return;
+        }
+
+        this.emitters[name] = this.emitters[name].filter(emitter => emitter.id !== id);
+    }
+};
+
+export default DivhuntEmitter;

package/lib/src/mixins/function.js

@@ -0,0 +1,82 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntFunction =
+{
+    FunctionCache: new Map(),
+
+    Function(expression, data = {}, safe = true)
+    {
+        if (!this.FunctionExpressionValid(expression, safe))
+        {
+            return undefined;
+        }
+
+        try
+        {
+            const keys = Object.keys(data);
+            const cacheKey = keys.length > 0 ? expression + ':' + keys.join(',') : expression;
+
+            let evaluator = this.FunctionCache.get(cacheKey);
+
+            if (!evaluator)
+            {
+                const FunctionConstructor = Function;
+                evaluator = new FunctionConstructor(...keys, `return ${expression};`);
+                this.FunctionCache.set(cacheKey, evaluator);
+            }
+
+            return keys.length > 0 ? evaluator(...Object.values(data)) : evaluator();
+        }
+        catch (error)
+        {
+            return undefined;
+        }
+    },
+
+    FunctionExpressionValid(expression, safe = true)
+    {
+        if (expression.includes(';') ||
+            expression.includes('`') ||
+            expression.includes('return '))
+        {
+            return false;
+        }
+
+        if (!safe)
+        {
+            return true;
+        }
+
+        if (expression.includes('=>'))
+        {
+            return false;
+        }
+
+        const safePattern = /^[a-zA-Z0-9_\[\]\.\'"+-\/*%<>=!&|\s()?,:\d:]*$/;
+
+        if (!safePattern.test(expression))
+        {
+            return false;
+        }
+        
+        const dangerousKeywords = [
+            'eval', 'Function', 'setTimeout', 'setInterval', 'execScript',
+            'constructor', 'prototype', '__proto__', 'global', 'process',
+            'require', 'import', 'export', 'module', 'window', 'document',
+            'localStorage', 'sessionStorage', 'fetch', 'XMLHttpRequest',
+            '__dirname', '__filename', 'Buffer', 'Promise', 'arguments',
+            'callee', 'caller', 'debugger', 'new', 'this', 'delete',
+            'bind', 'apply', 'call', 'Reflect', 'Proxy', 'revoke'
+        ];
+
+        const withoutQuotes = expression.replace(/'[^']*'|"[^"]*"/g, '');
+
+        return !dangerousKeywords.some(keyword =>
+        {
+            const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+            return regex.test(withoutQuotes);
+        });
+    }
+};
+
+export default DivhuntFunction;

package/lib/src/mixins/generate.js

@@ -0,0 +1,73 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntGenerate =
+{
+    GenerateHash(name)
+    {
+        let hash = 0;
+
+        for (let i = 0; i < name.length; i++)
+        {
+            hash = (hash << 5) - hash + name.charCodeAt(i);
+            hash |= 0;
+        }
+
+        return Math.abs(hash).toString(16);
+    },
+
+    GenerateUID()
+    {
+        return Math.random().toString(36).slice(2, 11);
+    },
+
+    GenerateString(length = 10, charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789')
+    {
+        let result = '';
+        const charsetLength = charset.length;
+
+        for (let i = 0; i < length; i++)
+        {
+            result += charset.charAt(Math.floor(Math.random() * charsetLength));
+        }
+
+        return result;
+    },
+
+    GenerateTID()
+    {
+        let timestamp = Date.now();
+        let uniquePart = Math.floor(Math.random() * 1000000).toString().padStart(6, '0');
+
+        return parseInt(`${timestamp}${uniquePart}`);
+    },
+
+    GenerateCommand(string)
+    {
+        const segments = string.trim().toLowerCase().split(' ').filter(segment => segment !== '');
+        
+        if(!segments.length)
+        {
+            return { name: '', options: [] };
+        }
+        
+        const [name, ...parameters] = segments;
+        
+        const options = parameters.filter(parameter => parameter.startsWith('--')).map(parameter => 
+        {
+            const option = parameter.substring(2);
+            
+            if (option.includes('='))
+            {
+                const [identifier, content] = option.split('=');
+
+                return { name: identifier, value: content };
+            }
+            
+            return { name: option, value: null };
+        });
+    
+        return { name, options };
+    }
+};
+
+export default DivhuntGenerate;

package/lib/src/mixins/helper.js

@@ -0,0 +1,317 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntHelper =
+{
+    HelperDebounce(callback, delay = 300)
+    {
+        let timer;
+        
+        return (...args) =>
+        {
+            clearTimeout(timer);
+            timer = setTimeout(() => callback(...args), delay);
+        };
+    },
+    
+    HelperThrottle(callback, delay = 300)
+    {
+        let waiting = false;
+        let lastArgs;
+        
+        const timeoutFunc = () =>
+        {
+            if(lastArgs)
+            {
+                callback(...lastArgs);
+                lastArgs = null;
+                setTimeout(timeoutFunc, delay);
+            }
+            else
+            {
+                waiting = false;
+            }
+        };
+        
+        return (...args) =>
+        {
+            if(waiting)
+            {
+                lastArgs = args;
+                return;
+            }
+            
+            callback(...args);
+            waiting = true;
+            setTimeout(timeoutFunc, delay);
+        };
+    },
+    
+    HelperSleep(ms)
+    {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    },
+    
+    HelperRetry(fn, retries = 3, delay = 1000)
+    {
+        return new Promise((resolve, reject) =>
+        {
+            const attempt = async (remaining) =>
+            {
+                try
+                {
+                    const result = await fn();
+                    resolve(result);
+                }
+                catch(error)
+                {
+                    if(remaining <= 0)
+                    {
+                        reject(error);
+                        return;
+                    }
+                    
+                    await this.HelperSleep(delay);
+                    attempt(remaining - 1);
+                }
+            };
+            
+            attempt(retries);
+        });
+    },
+    
+    HelperMemoize(fn)
+    {
+        const cache = new Map();
+        
+        return (...args) =>
+        {
+            const key = JSON.stringify(args);
+            
+            if(cache.has(key))
+            {
+                return cache.get(key);
+            }
+            
+            const result = fn(...args);
+            cache.set(key, result);
+            
+            return result;
+        };
+    },
+    
+    HelperPipe(...fns)
+    {
+        return (value) => fns.reduce((v, fn) => fn(v), value);
+    },
+    
+    HelperCompose(...fns)
+    {
+        return (value) => fns.reduceRight((v, fn) => fn(v), value);
+    },
+    
+    HelperPick(obj, keys)
+    {
+        return keys.reduce((result, key) =>
+        {
+            if(key in obj)
+            {
+                result[key] = obj[key];
+            }
+            return result;
+        }, {});
+    },
+    
+    HelperOmit(obj, keys)
+    {
+        const keysSet = new Set(keys);
+        
+        return Object.entries(obj).reduce((result, [key, value]) =>
+        {
+            if(!keysSet.has(key))
+            {
+                result[key] = value;
+            }
+            return result;
+        }, {});
+    },
+    
+    HelperDeepClone(obj)
+    {
+        if(obj === null || typeof obj !== 'object')
+        {
+            return obj;
+        }
+        
+        if(obj instanceof Date)
+        {
+            return new Date(obj);
+        }
+        
+        if(obj instanceof Array)
+        {
+            return obj.map(item => this.HelperDeepClone(item));
+        }
+        
+        if(obj instanceof Object)
+        {
+            const clone = {};
+            
+            for(const key in obj)
+            {
+                if(obj.hasOwnProperty(key))
+                {
+                    clone[key] = this.HelperDeepClone(obj[key]);
+                }
+            }
+            
+            return clone;
+        }
+    },
+    
+    HelperDeepMerge(target, ...sources)
+    {
+        if(!sources.length) return target;
+        
+        const source = sources.shift();
+        
+        if(this.HelperIsObject(target) && this.HelperIsObject(source))
+        {
+            for(const key in source)
+            {
+                if(this.HelperIsObject(source[key]))
+                {
+                    if(!target[key]) Object.assign(target, { [key]: {} });
+                    this.HelperDeepMerge(target[key], source[key]);
+                }
+                else
+                {
+                    Object.assign(target, { [key]: source[key] });
+                }
+            }
+        }
+        
+        return this.HelperDeepMerge(target, ...sources);
+    },
+    
+    HelperIsObject(item)
+    {
+        return item && typeof item === 'object' && !Array.isArray(item);
+    },
+    
+    HelperIsEmpty(value)
+    {
+        if(value == null) return true;
+        if(typeof value === 'boolean') return false;
+        if(typeof value === 'number') return false;
+        if(value instanceof Date) return false;
+        if(value instanceof Error) return false;
+        if(Array.isArray(value)) return value.length === 0;
+        if(typeof value === 'string') return value.length === 0;
+        if(value instanceof Map || value instanceof Set) return value.size === 0;
+        if(typeof value === 'object') return Object.keys(value).length === 0;
+        
+        return false;
+    },
+    
+    HelperGroupBy(array, key)
+    {
+        return array.reduce((groups, item) =>
+        {
+            const group = typeof key === 'function' ? key(item) : item[key];
+            
+            if(!groups[group])
+            {
+                groups[group] = [];
+            }
+            
+            groups[group].push(item);
+            
+            return groups;
+        }, {});
+    },
+    
+    HelperChunk(array, size)
+    {
+        const chunks = [];
+        
+        for(let i = 0; i < array.length; i += size)
+        {
+            chunks.push(array.slice(i, i + size));
+        }
+        
+        return chunks;
+    },
+    
+    HelperFlatten(array, depth = 1)
+    {
+        if(depth <= 0) return array.slice();
+        
+        return array.reduce((flat, item) =>
+        {
+            if(Array.isArray(item))
+            {
+                return flat.concat(this.HelperFlatten(item, depth - 1));
+            }
+            
+            return flat.concat(item);
+        }, []);
+    },
+    
+    HelperUnique(array, key)
+    {
+        if(!key)
+        {
+            return [...new Set(array)];
+        }
+        
+        const seen = new Set();
+        
+        return array.filter(item =>
+        {
+            const k = typeof key === 'function' ? key(item) : item[key];
+            
+            if(seen.has(k))
+            {
+                return false;
+            }
+            
+            seen.add(k);
+            return true;
+        });
+    },
+
+    HelperRegex(pattern, defaultFlags = '')
+    {
+        if (typeof pattern !== 'string')
+        {
+            return null;
+        }
+
+        if (pattern.startsWith('/') && pattern.lastIndexOf('/') > 0)
+        {
+            const lastSlashIndex = pattern.lastIndexOf('/');
+            const regexPattern = pattern.substring(1, lastSlashIndex);
+            const flags = pattern.substring(lastSlashIndex + 1) || defaultFlags;
+
+            try
+            {
+                return new RegExp(regexPattern, flags);
+            }
+            catch (e)
+            {
+                return null;
+            }
+        }
+
+        try
+        {
+            return new RegExp(pattern, defaultFlags);
+        }
+        catch (e)
+        {
+            return null;
+        }
+    }
+};
+
+export default DivhuntHelper;