divhunt 2.0.0

package/addons/modules/variables/functions/process.js

@@ -0,0 +1,52 @@
+import divhunt from '#divhunt';
+import variables from '../addon.js';
+
+variables.Fn('process', function(string)
+{
+    if(typeof string !== 'string')
+    {
+        return string;
+    }
+
+    return string.replace(/\$\{([^}]+)\}/g, (match, expr) =>
+    {
+        const parts = expr.trim().split('.');
+        const id = parts[0];
+        const key = parts.slice(1).join('.');
+
+        const item = this.ItemGet(id);
+
+        if(!item)
+        {
+            try
+            {
+                return divhunt.Function(`return ${expr}`)();
+            }
+            catch
+            {
+                return match;
+            }
+        }
+
+        let value = item.Get('value');
+
+        if(key && typeof value === 'object' && value !== null)
+        {
+            const keys = key.split('.');
+
+            for(const k of keys)
+            {
+                if(value && typeof value === 'object' && k in value)
+                {
+                    value = value[k];
+                }
+                else
+                {
+                    return match;
+                }
+            }
+        }
+
+        return value;
+    });
+});

package/addons/modules/variables/item/catch/add.js

@@ -0,0 +1,13 @@
+import divhunt from '#divhunt';
+import variables from '../../addon.js';
+
+variables.ItemOn('add', function(item)
+{
+    const value = item.Get('value');
+    const type = typeof value;
+
+    if(!item.Get('type'))
+    {
+        item.Set('type', type);
+    }
+});

package/addons/modules/variables/load.js

@@ -0,0 +1,8 @@
+import variables from './addon.js';
+
+import './item/catch/add.js';
+
+import './functions/process.js';
+import './functions/filter.js';
+
+export default variables;

package/addons/render/assets/back/README.md

@@ -0,0 +1 @@
+# assets

package/addons/render/assets/back/addon.js

@@ -0,0 +1,15 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from '#framework/load.js';
+
+const assets = divhunt.Addon('assets', (addon) =>
+{
+    addon.Field('id', ['number']);
+    addon.Field('order', ['number']);
+    addon.Field('path', ['string']);
+    addon.Field('content', ['string|function']);
+    addon.Field('type', ['string']);
+    addon.Field('ignore', ['array', []]);
+});
+
+export default assets;

package/addons/render/assets/back/functions/css.js

@@ -0,0 +1,32 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../addon.js';
+
+assets.Fn('css', function()
+{
+    const css = [];
+    const items = Object.values(this.Items()).filter(item => item.Get('type') === 'css').sort((a, b) => a.Get('order') - b.Get('order'));
+    
+    items.forEach((item) => 
+    {
+        if(item.Get('content'))
+        {
+            if(typeof item.Get('content') === 'function')
+            {
+                css.push(item.Get('content')());
+            }
+            else 
+            {
+                css.push(item.Get('content'));
+            }
+        }
+        else if(item.Get('path'))
+        {
+            const files = assets.Fn('scan.files', item.Get('path'), 'css', item.Get('ignore'));
+
+            css.push(...assets.Fn('utils.read', files));
+        }
+    })
+
+    return assets.Fn('utils.transform', css, 'css');
+});

package/addons/render/assets/back/functions/js.js

@@ -0,0 +1,32 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../addon.js';
+
+assets.Fn('js', function(context = {})
+{
+    const js = [];
+    const items = Object.values(this.Items()).filter(item => item.Get('type') === 'js').sort((a, b) => a.Get('order') - b.Get('order'));
+
+    items.forEach((item) =>
+    {
+        if(item.Get('content'))
+        {
+            if(typeof item.Get('content') === 'function')
+            {
+                js.push(item.Get('content').call(context));
+            }
+            else
+            {
+                js.push(item.Get('content'));
+            }
+        }
+        else if(item.Get('path'))
+        {
+            const files = assets.Fn('scan.files', item.Get('path'), 'js', item.Get('ignore'));
+
+            js.push(...assets.Fn('utils.read', files));
+        }
+    })
+
+    return assets.Fn('utils.transform', js, 'js');
+});

package/addons/render/assets/back/functions/scan/directories.js

@@ -0,0 +1,38 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../../addon.js';
+import fs from 'fs';
+import path from 'path';
+
+assets.Fn('scan.directories', function(dirPath, ignore = [], recursive = true)
+{
+    const dirs = [];
+
+    if (!fs.existsSync(dirPath))
+    {
+        return dirs;
+    }
+
+    const items = fs.readdirSync(dirPath);
+
+    for (const item of items)
+    {
+        if (item.startsWith('.')) continue;
+        if (ignore.some(str => item.includes(str))) continue;
+
+        const itemPath = path.join(dirPath, item);
+        const stats = fs.statSync(itemPath);
+
+        if (stats.isDirectory())
+        {
+            dirs.push(itemPath);
+
+            if (recursive)
+            {
+                dirs.push(...assets.Fn('scan.directories', itemPath, ignore, recursive));
+            }
+        }
+    }
+
+    return dirs;
+});

package/addons/render/assets/back/functions/scan/files.js

@@ -0,0 +1,58 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../../addon.js';
+import fs from 'fs';
+import path from 'path';
+
+assets.Fn('scan.files', function(dirPath, extension = 'css', ignore = [], recursive = true)
+{
+    const results = [];
+
+    if (!fs.existsSync(dirPath))
+    {
+        return results;
+    }
+
+    const items = fs.readdirSync(dirPath);
+    const folders = [];
+    const files = [];
+
+    for (const item of items)
+    {
+        if (item.startsWith('.')) continue;
+
+        const full = path.join(dirPath, item);
+        const stats = fs.statSync(full);
+
+        if (ignore.some(str => full.includes(str))) continue;
+
+        if (stats.isDirectory() && recursive)
+        {
+            folders.push(full);
+        }
+        else if (item.endsWith(`.${extension}`) && !item.endsWith(`.back.${extension}`))
+        {
+            files.push(full);
+        }
+    }
+
+    const addon = files.find(f => f.endsWith('/addon.js'));
+
+    if (addon)
+    {
+        results.push(addon);
+        files.splice(files.indexOf(addon), 1);
+    }
+
+    folders.sort();
+
+    for (const folder of folders)
+    {
+        results.push(...assets.Fn('scan.files', folder, extension, ignore, recursive));
+    }
+
+    files.sort();
+    results.push(...files);
+
+    return results;
+});

package/addons/render/assets/back/functions/utils/read.js

@@ -0,0 +1,26 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../../addon.js';
+import fs from 'fs';
+
+assets.Fn('utils.read', function(files)
+{
+    const contents = [];
+
+    for (const file of files)
+    {
+        if(!fs.existsSync(file))
+        {
+            continue;
+        }
+
+        const fileContent = fs.readFileSync(file, 'utf8');
+        
+        if (fileContent)
+        {
+            contents.push(fileContent);
+        }
+    }
+
+    return contents;
+});

package/addons/render/assets/back/functions/utils/transform.js

@@ -0,0 +1,34 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from '../../addon.js';
+
+assets.Fn('utils.transform', function(contents, type = 'js')
+{
+    if (!Array.isArray(contents))
+    {
+        return '';
+    }
+
+    if (type === 'js')
+    {
+        const code = contents.map(code => 
+        {
+            code = code.replace(/^import\s+.*?;?\s*$/gm, '');
+            code = code.replace(/^export\s+.*?;?\s*$/gm, '');
+            code = code.replace(/^\s*[\r\n]/gm, '');
+
+            return code;
+        });
+
+        return code.filter(content => content && content.trim()).join('\n\n');
+    }
+
+    if (type === 'css')
+    {
+        const code = contents.map(code => code ? code.trim() : '');
+
+        return code.filter(content => content && content.trim()).join('\n');
+    }
+
+    return code.filter(content => content && content.trim()).join('\n');
+});

package/addons/render/assets/back/items/commands/css.js

@@ -0,0 +1,20 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from "#framework/load.js";
+import assets from "#assets/load.js";
+
+divhunt.AddonReady('commands', (commands) => 
+{
+    commands.Item({
+        id: 'assets:css',
+        exposed: true,
+        method: 'GET',
+        endpoint: '/assets/build.css',
+        type: 'CSS',
+        callback: async function(properties, resolve)
+        {
+            resolve(await assets.Fn('css'));
+        }
+    });
+});
+

package/addons/render/assets/back/items/commands/js.js

@@ -0,0 +1,19 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from "#framework/load.js";
+import assets from "#assets/addon.js";
+
+divhunt.AddonReady('commands', (commands) => 
+{
+    commands.Item({
+        id: 'assets:js',
+        exposed: true,
+        method: 'GET',
+        endpoint: '/assets/build.js',
+        type: 'JS',
+        callback: async function(properties, resolve)
+        {
+            resolve(await assets.Fn('js', {http: this.http}));
+        }
+    });
+});

package/addons/render/assets/back/items/html/css.js

@@ -0,0 +1,18 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from "#framework/load.js";
+
+divhunt.AddonReady('html', (html) => 
+{
+    html.Item({
+        id: 'assets-css',
+        exposed: true,
+        tag: 'link',
+        position: 'head',
+        order: 90,
+        attributes: {
+            rel: 'stylesheet',
+            href: '/assets/build.css?v=18'
+        }
+    });
+});

package/addons/render/assets/back/items/html/js.js

@@ -0,0 +1,18 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import divhunt from "#framework/load.js";
+
+divhunt.AddonReady('html', (html) => 
+{
+    html.Item({
+        id: 'assets-js',
+        exposed: true,
+        tag: 'script',
+        position: 'head',
+        order: 90,
+        attributes: {
+            src: '/assets/build.js?v=18',
+            defer: null
+        }
+    });
+});

package/addons/render/assets/back/load.js

@@ -0,0 +1,23 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+import assets from './addon.js';
+
+/* Functions */
+import './functions/css.js';
+import './functions/js.js';
+
+import './functions/scan/files.js';
+import './functions/scan/directories.js';
+
+import './functions/utils/read.js';
+import './functions/utils/transform.js';
+
+/* Items */
+import './items/commands/css.js';
+import './items/commands/js.js';
+
+import './items/html/css.js';
+import './items/html/js.js';
+
+
+export default assets;

package/addons/render/directives/front/js/#register/addon.js

@@ -0,0 +1,32 @@
+const directives = divhunt.Addon('directives', (addon) =>
+{
+    addon.Field('id', ['string']);
+    addon.Field('icon', ['string', 'code']);
+    addon.Field('name', ['string', '']);
+    addon.Field('description', ['string', '']);
+    addon.Field('trigger', ['string', 'node']);
+    addon.Field('order', ['number', 1]);
+    addon.Field('code', ['function']);
+    addon.Field('strict', ['boolean', true]);
+
+    addon.Field('tag', ['string']);
+    addon.Field('type', ['string']);
+    addon.Field('attributes', ['object', {}]);
+
+    /* Trigers */
+    
+    divhunt.EmitOn('addon.render.compile.before', (...data) =>
+    {
+        directives.Fn('process', 'before', ...data);
+    })
+    
+    divhunt.EmitOn('addon.render.compile.after', (...data) =>
+    {
+        directives.Fn('process', 'after', ...data);
+    })
+    
+    divhunt.EmitOn('addon.render.compile.node', (...data) =>
+    {
+        directives.Fn('process', 'node', ...data);
+    })
+});

package/addons/render/directives/front/js/functions/process/attributes.js

@@ -0,0 +1,47 @@
+directives.Fn('process.attributes', function(node, compile)
+{
+    if (node.nodeType !== Node.ELEMENT_NODE || !node.__attributes)
+    {
+        return;
+    }
+
+    node.__attributes.forEach(attribute =>
+    {
+        if (!attribute.name.startsWith(':'))
+        {
+            return;
+        }
+
+        const attributeName = attribute.name.substring(1);
+        const expression = attribute.value;
+
+        try
+        {
+            const value = divhunt.Function(expression, compile.data, false);
+
+            if (value === null || value === undefined || value === false)
+            {
+                node.removeAttribute(attributeName);
+            }
+            else if (value === true)
+            {
+                node.setAttribute(attributeName, '');
+            }
+            else if (typeof value === 'string' || typeof value === 'number')
+            {
+                node.setAttribute(attributeName, value);
+            }
+            else
+            {
+                node.removeAttribute(attributeName);
+            }
+
+            node.removeAttribute(attribute.name);
+        }
+        catch(error)
+        {
+            console.error('Dynamic attribute error:', error);
+            node.removeAttribute(attribute.name);
+        }
+    });
+});

package/addons/render/directives/front/js/functions/process/data.js

@@ -0,0 +1,74 @@
+directives.Fn('process.data', function(attributes, node, compile)
+{
+    const data = {};
+
+    Object.entries(attributes).forEach(([name, definition]) =>
+    {
+        name = name.toLowerCase();
+
+        const find = node.__attributes ? node.__attributes.find(attribute =>
+        {
+            return (attribute.lowerName === name) || attribute.lowerName === (':' + name) || attribute.lowerName.startsWith(name + '.') || attribute.lowerName.startsWith(':' + name + '.');
+        }) : null;
+
+        let attribute;
+
+        if (find)
+        {
+            attribute = {
+                original: { name: find.name, value: find.value }, 
+                name: find.name,
+                value: find.value,
+                dynamic: false,
+                modifiers: []
+            };
+        }
+        else 
+        {
+            attribute = {
+                original: { name: name, value: null }, 
+                name: name,
+                value: null,
+                dynamic: false,
+                modifiers: []
+            };
+        }
+
+        if(attribute.name.split('.').length > 1)
+        {
+            const split = attribute.name.split('.');
+
+            attribute.name = split[0];
+            attribute.modifiers = split.slice(1);
+        }
+
+        if(attribute.name.startsWith(':'))
+        {
+            attribute.dynamic = true;
+            attribute.name = attribute.name.substring(1);
+        }
+
+        if(attribute.dynamic)
+        {
+            try 
+            {
+                attribute.value = divhunt.Function(attribute.value, compile, false);
+            }
+            catch(error)
+            {
+                attribute.value = null;
+            }
+        }
+
+
+        attribute.value = divhunt.DataDefineOne(attribute.value, definition);
+        data[attribute.name] = attribute;
+
+        if(find && node.removeAttribute)
+        {
+            node.removeAttribute(find.name);
+        }
+    });
+
+    return data;
+});

package/addons/render/directives/front/js/functions/process/match.js

@@ -0,0 +1,43 @@
+directives.Fn('process.match', function(directive, node)
+{   
+    const tag = directive.Get('tag');
+    const type = directive.Get('type');
+    const attributes = directive.Get('attributes');
+
+    const matches = {
+        count: 0,
+        total: Object.keys(attributes).length + (tag ? 1 : 0) + (type ? 1 : 0),
+    };
+
+    if (tag && node.tagName && node.tagName.toLowerCase() === tag.toLowerCase())
+    {
+        matches.count++;
+    }
+
+    if (type && node.nodeType.toString() === type)
+    {
+        matches.count++;
+    }
+
+    Object.entries(attributes).forEach(([name]) =>
+    {
+        name = name.toLowerCase();
+
+        const find = node.__attributes && node.__attributes.some(attribute =>
+        {
+            return (attribute.lowerName === name) || attribute.lowerName === (':' + name) || attribute.lowerName.startsWith(name + '.') || attribute.lowerName.startsWith(':' + name + '.');
+        });
+
+        if(find)
+        {
+            matches.count++;
+        }
+    });
+
+    if(directive.Get('strict'))
+    {
+        return matches.count === matches.total && matches.total > 0;
+    }
+
+    return matches.count > 0;
+});

package/addons/render/directives/front/js/functions/process.js

@@ -0,0 +1,57 @@
+directives.Fn('process', function(trigger, item, compile, node, identifier)
+{
+    if (!node)
+    {
+        return;
+    }
+
+    if(!directives.StoreHas('sorted'))
+    {
+        directives.StoreSet('sorted', Object.values(directives.Items()).sort((a, b) => a.Get('order') - b.Get('order')));
+    }
+
+    if(node.attributes && !node.__attributes)
+    {
+        node.__attributes = Array.from(node.attributes).map(attr => ({
+            name: attr.name,
+            lowerName: attr.name.toLowerCase(),
+            value: attr.value,
+            original: attr
+        }));
+    }
+
+    const items = directives.StoreGet('sorted');
+
+    for (let i = 0; i < items.length; i++)
+    {
+        const directive = items[i];
+
+        if (directive.Get('trigger') !== trigger)
+        {
+            continue;
+        }
+
+        if (!directives.Fn('process.match', directive, node))
+        {
+            continue;
+        }
+
+        const data = directives.Fn('process.data', directive.Get('attributes'), node, compile);
+
+        try
+        {
+            const result = directive.Get('code').call({}, data, item, compile, node, identifier);
+
+            if (result === false)
+            {
+                break;
+            }
+        }
+        catch (error)
+        {
+            console.error('Directive processing error:', error);
+        }
+    }
+
+    directives.Fn('process.attributes', node, compile);
+});