divhunt 2.0.0

package/lib/src/mixins/logger.js

@@ -0,0 +1,75 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntLogger =
+{
+    Log(level, message, meta = {})
+    {
+        if(!(level in this.logger.levels))
+        {
+            throw new Error(`Invalid log level: '${level}'`);
+        }
+
+        meta.allowed = this.logger.levels[level] >= this.logger.levels[this.logger.level];
+        meta.timestamp = new Date().toISOString();
+        meta.level = level;
+        meta.message = message;
+
+        this.Emit('log', meta);
+
+        if(meta.allowed)
+        {
+            console.log(meta);
+        }
+
+        return this;
+    },
+
+    LogLevel(level)
+    {
+        if(!(level in this.logger.levels))
+        {
+            throw new Error(`Invalid log level: '${level}'`);
+        }
+
+        return this;
+    },
+
+    LogError(message, meta = {}, error = null, slice = 1, throwError = false)
+    {
+        meta.stack = error ? (error.stack.split('\n').splice(1, slice)) : [];
+
+        this.Log('error', message + (error ? (' / ' + error.message) : ''), meta);
+
+        if(throwError)
+        {
+            throw (error ? error : new Error(message))
+        }
+    },
+
+    LogWarn(message, meta = {})
+    {
+        return this.Log('warn', message, meta);
+    },
+
+    LogInfo(message, meta = {})
+    {
+        return this.Log('info', message, meta);
+    },
+
+    LogVerbose(message, meta = {})
+    {
+        return this.Log('verbose', message, meta);
+    },
+
+    LogDebug(message, meta = {})
+    {
+        return this.Log('debug', message, meta);
+    },
+
+    LogSilly(message, meta = {})
+    {
+        return this.Log('silly', message, meta);
+    }
+};
+
+export default DivhuntLogger;

package/lib/src/mixins/middleware.js

@@ -0,0 +1,52 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntMiddleware =
+{
+    async Middleware(name, value)
+    {
+        let index = -1;
+
+        const context = {
+            value: value,
+            errors: [],
+            next: async () =>
+            {
+                index++;
+
+                if (index < this.middleware[name].length)
+                {
+                    try
+                    {
+                        return await this.middleware[name][index](context);
+                    }
+                    catch(error)
+                    {
+                        this.LogError('Error in middleware callback: ' + name, {}, error);
+                    }
+                }
+
+                return context;
+            }
+        };
+
+        if (!this.middleware[name])
+        {
+            this.middleware[name] = [];
+        }
+
+        return await context.next();
+    },
+
+    MiddlewareIntercept(name, callback)
+    {
+        if(!this.middleware[name])
+        {
+            this.middleware[name] = [];
+        }
+
+        this.middleware[name].push(callback);
+        return this;
+    }
+};
+
+export default DivhuntMiddleware;

package/lib/src/mixins/overrides.js

@@ -0,0 +1,37 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntOverrides =
+{
+    OverrideLog()
+    {
+        let start = performance.now();
+        let log = console.log
+
+        console.log = function(message, ...keys)
+        {
+            if(typeof message !== 'string')
+            {
+                return log(message, ...keys);
+            }
+
+            const now = performance.now();
+            const elapsed = now - start;
+            const timestamp = new Date().toISOString();
+            
+            if (!message.endsWith('.')) 
+            {
+                message = message + '.';
+            }
+
+            keys.forEach((key, index) => 
+            {
+                message = message.replace(':' + (index + 1), key);
+            })
+            
+            log(`${timestamp} [+${elapsed.toFixed(2)}ms] - ${message}`);
+            start = now;
+        };
+    },
+};
+
+export default DivhuntOverrides;

package/lib/src/mixins/request.js

@@ -0,0 +1,28 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntRequest = {
+    Request(name, value)
+    {
+        name = name.toLowerCase();
+
+        const data = {value};
+
+        this.Emit('request.' + name, data);
+
+        if(typeof data !== 'object' || !('value' in data) || typeof data.value !== typeof value)
+        {
+            return value;
+        }
+
+        return data.value;
+    },
+
+    RequestCatch(name, callback)
+    {
+        name = name.toLowerCase();
+
+        this.EmitOn('request.' + name, callback);
+    }
+};
+
+export default DivhuntRequest;

package/lib/src/mixins/route.js

@@ -0,0 +1,191 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntRoute =
+{
+    RouteNormalize(pathname)
+    {
+        if (!pathname || pathname === '/')
+        {
+            return '/';
+        }
+
+        let normalized = pathname.toLowerCase();
+
+        if (normalized.endsWith('/') && normalized.length > 1)
+        {
+            normalized = normalized.slice(0, -1);
+        }
+
+        if (!normalized.startsWith('/'))
+        {
+            normalized = '/' + normalized;
+        }
+
+        return normalized;
+    },
+
+    RouteMatch(pattern, pathname)
+    {
+        const normalized = this.RouteNormalize(pattern);
+        const path = this.RouteNormalize(pathname);
+
+        if (normalized === path)
+        {
+            return { match: true, params: {} };
+        }
+
+        if (normalized.includes('*'))
+        {
+            const segments = normalized.split('/');
+            const parts = path.split('/');
+
+            if (segments[segments.length - 1] === '*')
+            {
+                if (parts.length < segments.length - 1)
+                {
+                    return { match: false, params: {} };
+                }
+
+                for (let i = 0; i < segments.length - 1; i++)
+                {
+                    if (segments[i] !== parts[i])
+                    {
+                        return { match: false, params: {} };
+                    }
+                }
+
+                return { match: true, params: {} };
+            }
+        }
+
+        if (normalized.includes(':') || normalized.includes('*'))
+        {
+            const segments = normalized.split('/');
+            const parts = path.split('/');
+
+            if (segments.length !== parts.length)
+            {
+                return { match: false, params: {} };
+            }
+
+            let matches = true;
+            const params = {};
+
+            for (let i = 0; i < segments.length; i++)
+            {
+                if (segments[i] === '*')
+                {
+                    continue;
+                }
+                else if (segments[i].startsWith(':'))
+                {
+                    const name = segments[i].substring(1);
+                    params[name] = parts[i];
+                }
+                else if (segments[i] !== parts[i])
+                {
+                    matches = false;
+                    break;
+                }
+            }
+
+            if (matches)
+            {
+                return { match: true, params };
+            }
+        }
+
+        return { match: false, params: {} };
+    },
+
+    RouteParams(pattern, pathname)
+    {
+        const result = this.RouteMatch(pattern, pathname);
+        return result.match ? result.params : null;
+    },
+
+    RouteBuild(pattern, params = {})
+    {
+        let route = pattern;
+
+        for (const [key, value] of Object.entries(params))
+        {
+            route = route.replace(':' + key, value);
+        }
+
+        return this.RouteNormalize(route);
+    },
+
+    RouteQuery(search)
+    {
+        const query = search || (typeof window !== 'undefined' ? window.location.search : '');
+
+        if (!query)
+        {
+            return {};
+        }
+
+        const params = {};
+        const cleaned = query.startsWith('?') ? query.substring(1) : query;
+
+        if (!cleaned)
+        {
+            return {};
+        }
+
+        cleaned.split('&').forEach(pair =>
+        {
+            const [key, value] = pair.split('=');
+
+            if (key)
+            {
+                params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : '';
+            }
+        });
+
+        return params;
+    },
+
+    RouteHash()
+    {
+        if (typeof window === 'undefined')
+        {
+            return '';
+        }
+
+        const hash = window.location.hash;
+        return hash ? hash.substring(1) : '';
+    },
+
+    RouteCurrent()
+    {
+        if (typeof window === 'undefined')
+        {
+            return '/';
+        }
+
+        return this.RouteNormalize(window.location.pathname);
+    },
+
+    RouteNavigate(pathname, state = {})
+    {
+        if (typeof window === 'undefined')
+        {
+            return;
+        }
+
+        const normalized = this.RouteNormalize(pathname);
+
+        if (window.history && window.history.pushState)
+        {
+            window.history.pushState(state, '', normalized);
+            window.dispatchEvent(new PopStateEvent('popstate', { state }));
+        }
+        else
+        {
+            window.location.pathname = normalized;
+        }
+    }
+};
+
+export default DivhuntRoute;

package/lib/src/mixins/string.js

@@ -0,0 +1,196 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntString =
+{
+    StringSanitize(input)
+    {
+        const string = typeof input !== 'string' ? JSON.stringify(input) : input;
+
+        const htmlEntities = {
+            '&': '&',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#39;'
+        };
+
+        return string.replace(/[&<>"']/g, char => htmlEntities[char]);
+    },
+
+    StringHasTemplateKey(template, key)
+    {
+        if (typeof template !== 'string' || typeof key !== 'string')
+        {
+            return false;
+        }
+
+        const regex = /\{\{\s*([^}]+)\s*\}\}/g;
+
+        const keyPattern = new RegExp(`(^|[^\\w.])${key.replace(/\./g, '\\.')}($|[^\\w])`);
+
+        let match;
+
+        while ((match = regex.exec(template)) !== null)
+        {
+            const expression = match[1].trim();
+
+            if (keyPattern.test(expression))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    },
+
+    StringCompileTemplate(template, data)
+    {
+        if (typeof template !== 'string')
+        {
+            return '';
+        }
+
+        if(!data || typeof data !== 'object')
+        {
+            return template;
+        }
+
+        return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (match, key) =>
+        {
+            try
+            {
+                const keys = key.trim().split('.');
+                let value = data;
+                let depth = 0;
+                const MAX_DEPTH = 5;
+
+                for (const k of keys)
+                {
+                    if (value === undefined || value === null || depth > MAX_DEPTH)
+                    {
+                        return match;
+                    }
+
+                    value = value[k];
+                    depth++;
+                }
+
+                return value !== undefined && value !== null ? (value + '') : match;
+            }
+            catch(error)
+            {
+                return match;
+            }
+        });
+    },
+
+    StringExtractUnit(string, unit = 'px')
+    {
+        const strValue = (string + '');
+        const match = strValue.match(/^(\d+)(%|px|em|rem|vh|vw|pt)?$/);
+
+        if (match)
+        {
+            return {
+                value: parseInt(match[1], 10),
+                unit: match[2] || unit
+            };
+        }
+
+        return {
+            value: 0,
+            unit: unit
+        };
+    },
+
+    StringTruncate(string, length = 100, append = '...')
+    {
+        if (typeof string !== 'string')
+        {
+            string = (string + '');
+        }
+
+        if (string.length <= length)
+        {
+            return string;
+        }
+
+        return string.slice(0, length - append.length) + append;
+    },
+
+    StringCapitalize(string)
+    {
+        if (typeof string !== 'string' || !string.length)
+        {
+            return '';
+        }
+
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    },
+
+    StringToCamelCase(string)
+    {
+        if (typeof string !== 'string')
+        {
+            return '';
+        }
+
+        return string.replace(/[^\w\s]/g, ' ').split(/\s+/).filter(word => word.length).map((word, index) =>
+        {
+            return index === 0 ? word.toLowerCase() : this.StringCapitalize(word.toLowerCase());
+        })
+        .join('');
+    },
+
+    StringStripHtml(html)
+    {
+        if (typeof html !== 'string')
+        {
+            return '';
+        }
+
+        return html.replace(/<style[^>]*>.*?<\/style>/gs, '')
+            .replace(/<script[^>]*>.*?<\/script>/gs, '')
+            .replace(/<[^>]+>/g, '')
+            .replace(/&nbsp;/g, ' ')
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#039;/g, "'")
+            .replace(/\s+/g, ' ')
+            .trim();
+    },
+
+    StringSlugify(string)
+    {
+        if (typeof string !== 'string')
+        {
+            return '';
+        }
+
+        return string.toLowerCase()
+            .trim()
+            .replace(/\s+/g, '-')
+            .replace(/[^\w-]+/g, '')
+            .replace(/--+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    },
+
+    StringFormatNumber(number, decimals = 2, decPoint = '.', thousandsSep = ',')
+    {
+        if (isNaN(number))
+        {
+            return '0';
+        }
+
+        const string = parseFloat(number).toFixed(decimals);
+        const parts = string.split('.');
+
+        parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSep);
+
+        return parts.join(decPoint);
+    }
+};
+
+export default DivhuntString;

package/lib/src/mixins/validate.js

@@ -0,0 +1,78 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+const DivhuntValidate =
+{
+    ValidateEmail(email)
+    {
+        if (typeof email !== 'string')
+        {
+            return false;
+        }
+
+        const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        
+        return pattern.test(email) && email.length <= 254 && !email.includes('..') &&!email.startsWith('.') && !email.endsWith('.');
+    },
+
+    ValidatePassword(password, options = {})
+    {
+        if (typeof password !== 'string')
+        {
+            return { valid: false, errors: ['Password must be a string'] };
+        }
+
+        const config = {
+            minLength: options.minLength || 8,
+            maxLength: options.maxLength || 128,
+            requireUppercase: options.requireUppercase !== false,
+            requireLowercase: options.requireLowercase !== false,
+            requireNumbers: options.requireNumbers !== false,
+            requireSpecial: options.requireSpecial !== false,
+            specialChars: options.specialChars || '!@#$%^&*()_+-=[]{}|;:,.<>?'
+        };
+
+        const errors = [];
+
+        if (password.length < config.minLength)
+        {
+            errors.push(`Password must be at least ${config.minLength} characters long`);
+        }
+
+        if (password.length > config.maxLength)
+        {
+            errors.push(`Password must be no more than ${config.maxLength} characters long`);
+        }
+
+        if (config.requireUppercase && !/[A-Z]/.test(password))
+        {
+            errors.push('Password must contain at least one uppercase letter');
+        }
+
+        if (config.requireLowercase && !/[a-z]/.test(password))
+        {
+            errors.push('Password must contain at least one lowercase letter');
+        }
+
+        if (config.requireNumbers && !/\d/.test(password))
+        {
+            errors.push('Password must contain at least one number');
+        }
+
+        if (config.requireSpecial)
+        {
+            const specialRegex = new RegExp(`[${config.specialChars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}]`);
+
+            if (!specialRegex.test(password))
+            {
+                errors.push('Password must contain at least one special character');
+            }
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors: errors
+        };
+    }
+};
+
+export default DivhuntValidate;