@onetype/framework 2.0.20

package/lib/src/mixins/helper.js

@@ -0,0 +1,315 @@
+const OneTypeHelper =
+{
+    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 OneTypeHelper;

package/lib/src/mixins/logger.js

@@ -0,0 +1,83 @@
+const OneTypeLogger =
+{
+    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)) : [];
+
+        if(error && typeof error.code === 'number')
+        {
+            meta.code = error.code;
+        }
+
+        if(error && error.context && typeof error.context === 'object')
+        {
+            meta.context = error.context;
+        }
+
+        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 OneTypeLogger;

package/lib/src/mixins/middleware.js

@@ -0,0 +1,50 @@
+const OneTypeMiddleware =
+{
+    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 OneTypeMiddleware;

package/lib/src/mixins/overrides.js

@@ -0,0 +1,35 @@
+const OneTypeOverrides =
+{
+    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 OneTypeOverrides;

package/lib/src/mixins/request.js

@@ -0,0 +1,26 @@
+const OneTypeRequest = {
+    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 OneTypeRequest;

package/lib/src/mixins/route.js

@@ -0,0 +1,189 @@
+const OneTypeRoute =
+{
+    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 OneTypeRoute;