divhunt 2.0.0

package/docs/frontend.md

@@ -0,0 +1,379 @@
+# Frontend
+
+Proxy-based reactivity with DOM diffing, Vue-like directives, SPA page routing, and convention-based asset bundling.
+
+## Pages
+
+Pages define routes with async data loading, CSS Grid layouts, and template areas.
+
+```js
+pages.ItemAdd({
+    id: 'home',
+    route: '/',
+    title: 'Home',
+    grid: {
+        template: '"content"',
+        columns: '1fr',
+        rows: '1fr'
+    },
+    areas: {
+        content: function() {
+            return `
+                <div class="page-home">
+                    <c-navbar></c-navbar>
+                    <c-hero title="Welcome"></c-hero>
+                    <c-footer></c-footer>
+                </div>
+            `;
+        }
+    }
+});
+```
+
+### Route params
+
+```js
+pages.ItemAdd({
+    id: 'offer',
+    route: '/ponuda/:id/:type/:location/:name',
+    // ...
+});
+```
+
+Params are available in `this.parameters`:
+
+```js
+areas: {
+    content: function() {
+        const id = this.parameters.id;
+        // ...
+    }
+}
+```
+
+### Multiple routes
+
+```js
+route: ['/offers', '/offers/:type/:value']
+```
+
+### Async data loading
+
+The `data` function runs before render:
+
+```js
+pages.ItemAdd({
+    id: 'offer',
+    route: '/ponuda/:id/:type/:location/:name',
+
+    title: function(parameters, data) {
+        return data?.offer?.name || 'Offer';
+    },
+
+    data: async function(parameters) {
+        const offer = await offers.Find()
+            .filter('id', parameters.id)
+            .join('files', 'cover_id', 'cover')
+            .join('countries', 'countries', 'countries')
+            .join('cities', 'cities', 'cities')
+            .one();
+
+        return { offer: offer ? offer.data : null };
+    },
+
+    areas: {
+        content: function() {
+            this.offer = this.data.offer || {};
+
+            return `
+                <div>
+                    <h1>{{ offer.name }}</h1>
+                    <span dh-if="offer.stars">{{ offer.stars }} stars</span>
+                </div>
+            `;
+        }
+    }
+});
+```
+
+### Interactive pages
+
+Pages can have local state and methods:
+
+```js
+areas: {
+    content: function() {
+        this.items = [];
+        this.page = 1;
+        this.total = 0;
+
+        this.fetch = async () => {
+            const result = await offers.Find()
+                .filter('status', 'Aktivna')
+                .sort('score', 'desc')
+                .page(this.page)
+                .limit(12)
+                .plain();
+
+            this.items = result.items;
+            this.total = result.total;
+        };
+
+        this.handlePageChange = (newPage) => {
+            this.page = newPage;
+            this.fetch();
+        };
+
+        this.fetch();
+
+        return `
+            <div>
+                <span>{{ total }} results</span>
+
+                <div dh-if="items.length > 0" class="grid">
+                    <a dh-for="offer in items" :href="'/offer/' + offer.id">
+                        <c-offer-card :offer="offer"></c-offer-card>
+                    </a>
+                </div>
+
+                <c-pagination
+                    :page="page"
+                    :pages="Math.ceil(total / 12)"
+                    :_change="handlePageChange"
+                ></c-pagination>
+            </div>
+        `;
+    }
+}
+```
+
+Setting `this.items`, `this.page`, or `this.total` triggers a 16ms debounced re-render with DOM diffing.
+
+## Components
+
+Reusable UI elements with typed config and template rendering.
+
+```js
+components.ItemAdd({
+    id: 'hero',
+    config: {
+        title: { type: 'string', value: 'Page Title' },
+        subtitle: { type: 'string', value: '' },
+        image: { type: 'string', value: '' },
+        variant: { type: 'array', value: [], options: ['compact', 'tall'] }
+    },
+    render: function() {
+        return `
+            <section class="holder" :style="'background-image: url(' + image + ')'">
+                <div class="overlay"></div>
+                <div class="content">
+                    <slot name="top"></slot>
+                    <h1>{{ title }}</h1>
+                    <p dh-if="subtitle">{{ subtitle }}</p>
+                </div>
+            </section>
+        `;
+    }
+});
+```
+
+### Using components
+
+Components become custom elements prefixed with `c-`:
+
+```html
+<c-hero title="Our Offers" subtitle="Find your trip" image="/hero.jpg">
+    <div slot="top">
+        <c-breadcrumb :items="[{label: 'Home', href: '/'}, {label: 'Offers'}]"></c-breadcrumb>
+    </div>
+</c-hero>
+```
+
+### Config types
+
+```js
+config: {
+    title: { type: 'string', value: 'Default' },
+    count: { type: 'number', value: 0 },
+    active: { type: 'boolean', value: true },
+    items: { type: 'array', value: [] },
+    data: { type: 'object', value: {} },
+    variant: { type: 'array', value: [], options: ['size-s', 'size-m', 'size-l'] },
+    _click: { type: 'function' },        // callback (prefixed with _)
+    _change: { type: 'function' }
+}
+```
+
+### Component with logic
+
+```js
+components.ItemAdd({
+    id: 'pagination',
+    config: {
+        page: { type: 'number', value: 1 },
+        pages: { type: 'number', value: 1 },
+        _change: { type: 'function' }
+    },
+    render: function() {
+        this.goToPage = (num) => {
+            if (num >= 1 && num <= this.pages) {
+                this.page = num;
+                if (this._change) this._change(num);
+            }
+        };
+
+        return `
+            <div class="pagination">
+                <button dh-click="() => goToPage(page - 1)" :disabled="page === 1">Prev</button>
+                <span>{{ page }} / {{ pages }}</span>
+                <button dh-click="() => goToPage(page + 1)" :disabled="page === pages">Next</button>
+            </div>
+        `;
+    }
+});
+```
+
+## Directives
+
+Vue-like syntax, processed during compile with priority ordering.
+
+### Conditional rendering
+
+```html
+<div dh-if="items.length > 0">Has items</div>
+<div dh-if="!loading">Content loaded</div>
+```
+
+### List rendering
+
+```html
+<a dh-for="offer in items" :href="'/offer/' + offer.id">
+    {{ offer.name }}
+</a>
+
+<!-- With index -->
+<div dh-for="item, index in items">
+    {{ index }}: {{ item.name }}
+</div>
+```
+
+### Event handlers
+
+```html
+<button dh-click="submit">Send</button>
+<button dh-click="() => goToPage(3)">Page 3</button>
+<input :_input="(e) => form.name = e.target.value">
+```
+
+### Dynamic attributes
+
+```html
+<img :src="getImage()" :alt="name" loading="lazy">
+<div :class="'card ' + (active ? 'active' : '')">
+<div :style="'background-image: url(' + image + ')'">
+<button :disabled="page === 1">
+<article :variant="variant.join(' ')">
+```
+
+### Text interpolation
+
+```html
+<span>{{ total }} results</span>
+<h1>{{ offer.name }}</h1>
+<span>{{ getStars() }}</span>
+```
+
+### All directives
+
+`dh-if`, `dh-show`, `dh-for`, `dh-click`, `dh-text`, `dh-html`, `dh-fetch`, `dh-render`, `dh-form`, and all DOM event handlers.
+
+## Reactivity
+
+Setting any property on a render context triggers a re-render:
+
+```js
+this.count = 0;
+this.increment = () => this.count++;  // triggers DOM update
+```
+
+Updates are batched with a 16ms debounce. The framework diffs the new DOM against the current DOM and patches only what changed. No virtual DOM — direct DOM diffing.
+
+Lifecycle: `init → render → compile → ready → mount → update → unmount → destroy`.
+
+## Slots
+
+Components can define named slots:
+
+```js
+render: function() {
+    return `
+        <div>
+            <slot name="top"></slot>
+            <div class="content">
+                <slot></slot>
+            </div>
+        </div>
+    `;
+}
+```
+
+Usage:
+
+```html
+<c-layout>
+    <div slot="top">Header content</div>
+    <p>Default slot content</p>
+</c-layout>
+```
+
+## Asset bundling
+
+Convention-based bundler that scans directories, strips ES module syntax, concatenates, and minifies.
+
+```js
+import assets from '#assets/load.js';
+
+// Scan directories in order
+assets.Item({ type: 'js', order: 0, path: 'framework' });
+assets.Item({ type: 'js', order: 1, path: 'addons/core/commands/front' });
+assets.Item({ type: 'js', order: 1, path: 'addons/render/directives/front' });
+assets.Item({ type: 'js', order: 1, path: 'addons/render/pages/front' });
+
+// CSS
+assets.Item({ type: 'css', order: 0, path: 'styles' });
+assets.Item({ type: 'css', order: 1, path: 'addons/render/elements/front' });
+assets.Item({ type: 'css', order: 2, path: 'projects/travel/site/front' });
+
+// Ignore specific files
+assets.Item({ type: 'js', order: 0, path: 'framework', ignore: ['framework/load.js'] });
+```
+
+### Dynamic content injection
+
+Inject server-side data into the frontend bundle:
+
+```js
+assets.Item({
+    type: 'js',
+    order: 4,
+    content: function() {
+        const items = Object.values(settings.Items())
+            .filter(item => item.Get('organization_id') === 9)
+            .map(item => item.data);
+
+        return `settings.ItemsAdd(${JSON.stringify(items)}, null, false);`;
+    }
+});
+```
+
+This runs at bundle time — server-side data becomes available client-side without an API call.
+
+### How it works
+
+1. Scans directories recursively for `.js` or `.css` files
+2. Prioritizes `addon.js` files (loaded first)
+3. Strips `import`/`export` statements
+4. Concatenates by `order` value
+5. Minifies via terser
+
+No webpack, no build step, no configuration files.

package/docs/servers.md

@@ -0,0 +1,133 @@
+# Servers
+
+HTTP and gRPC servers, both configured through the commands addon.
+
+## HTTP server
+
+```js
+import commands from '#commands/load.js';
+
+commands.Fn('http.server', 3000, {
+    onStart: (server) => {
+        console.log('HTTP server started on port 3000');
+    },
+    onResponse: (http) => {
+        // Called after each response
+    },
+    onError: (error) => {
+        console.log('HTTP server error:', error.message);
+    }
+});
+```
+
+## gRPC server
+
+Bidirectional streaming with automatic reconnection and binary data transport.
+
+```js
+commands.Fn('grpc.server', 50000, {
+    onStart: function() {
+        console.log('gRPC server started on port 50000');
+    },
+    onStreamConnect: async function(stream) {
+        // Authenticate via metadata
+        const node = await nodes.Fn('find', stream.metadata.get('token')[0]);
+
+        // Track the connection as an item
+        const connection = streams.Item({
+            gateway_id: gateway.Get('id'),
+            node_id: node.Get('id')
+        });
+        await connection.Create();
+
+        // Attach runtime state via Store
+        connection.StoreSet('gateway', gateway);
+        connection.StoreSet('node', node);
+        connection.StoreSet('stream', stream);
+
+        stream.connection = connection;
+
+        console.log('Connection established:', node.Get('name'));
+    },
+    onStreamEnd: function(stream) {
+        if (stream.connection) {
+            const node = stream.connection.StoreGet('node');
+            console.log('Disconnected:', node.Get('name'));
+
+            stream.connection.Delete();
+            stream.connection.Remove();
+        }
+    },
+    onStreamError: function(stream) {
+        console.log('Stream error');
+    },
+    onError: function(message) {
+        console.log('Server error:', message);
+    }
+});
+```
+
+## Binary transport
+
+gRPC messages are JSON strings. Binary data (Buffers) is automatically extracted into a separate `map<string, bytes>` field before sending and re-injected on receive.
+
+```js
+// Extract binaries from a data object
+const extracted = divhunt.BinariesExtract(data);
+// extracted.data    → JSON-safe object (Buffers replaced with keys)
+// extracted.binaries → map of key → Buffer
+
+// Re-inject binaries
+const restored = divhunt.BinariesInject(extracted.data, extracted.binaries);
+```
+
+This enables transparent file transfers over the same gRPC stream without base64 encoding.
+
+## Store API
+
+Per-item in-memory key-value storage — useful for attaching runtime state (like gRPC streams) to items:
+
+```js
+// Set
+connection.StoreSet('node', nodeItem);
+connection.StoreSet('stream', streamObject);
+
+// Get
+const node = connection.StoreGet('node');
+const stream = connection.StoreGet('stream');
+```
+
+Store data is never persisted to the database. It exists only in memory for the lifetime of the item.
+
+## Requesting over gRPC
+
+Send a request to a connected node and await the response:
+
+```js
+const response = await stream.request('tool-slug', inputProperties, (chunk) => {
+    // Optional: handle streaming chunks
+    resolve(chunk.data, chunk.message, chunk.code, false);
+});
+
+// response.data, response.message, response.code, response.time
+```
+
+## Graceful shutdown
+
+The framework handles process signals through middleware:
+
+```js
+process.on('SIGINT', async () => {
+    await divhunt.Middleware('sigint');
+    await divhunt.Middleware('shutdown');
+    process.exit(0);
+});
+```
+
+Register shutdown handlers:
+
+```js
+divhunt.MiddlewareAdd('shutdown', async () => {
+    // Close connections, flush data, etc.
+});
+```

package/lib/LICENSE.txt

@@ -0,0 +1,40 @@
+Copyright © 2025 Divhunt GmbH
+
+This License governs use of the Divhunt framework (the "Software"). By accessing or using the Software, you agree to be bound by the terms of this License.
+
+1. GRANT OF LICENSE  
+   You are granted a limited, non-exclusive, non-transferable, non-sublicensable license to use the Software solely for:
+   - personal projects;
+   - internal business purposes;
+   - client work, provided the client is not reselling or redistributing the Software.
+
+2. ATTRIBUTION AND BRANDING  
+   a. All uses of the Software must retain visible attribution to “Divhunt”.  
+   b. You must not remove, obscure, alter, or suppress any branding, notices, or credits related to Divhunt.  
+   c. Any public project using the Software must clearly state that it uses the “Divhunt Framework”.
+
+3. PROHIBITED USES  
+   The following are strictly prohibited:  
+   a. Rebranding, renaming, or representing the Software as your own work;  
+   b. Creating derivative frameworks or similar software tools based on the Software with the intent of distribution;  
+   c. Redistributing, sublicensing, or selling the Software or any modified version thereof;  
+   d. Using the Software in any commercial product, service, or offering without explicit, written permission from Divhunt GmbH.
+
+4. MODIFICATIONS  
+   You may modify the Software for personal or internal use only. Modified versions may not be:  
+   - redistributed;  
+   - rebranded or marketed as original work;  
+   - offered as a service or product.
+
+5. ENFORCEMENT AND TERMINATION  
+   Any violation of this License will result in the immediate termination of all rights granted herein. Divhunt GmbH reserves the right to pursue legal remedies including but not limited to damages, injunctions, and recovery of profits obtained through unauthorized use.
+
+6. NO WARRANTY  
+   THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL JOVANAT GMBH BE LIABLE FOR ANY DAMAGES ARISING FROM THE USE OR INABILITY TO USE THE SOFTWARE.
+
+7. GOVERNING LAW  
+   This License shall be governed by and construed in accordance with the laws of Switzerland. All disputes shall be subject to the exclusive jurisdiction of the courts of Zug, Switzerland.
+
+---
+
+For commercial licensing or other questions, please contact: **dejan@divhunt.com**

package/lib/README.md

@@ -0,0 +1,132 @@
+## Built with the Divhunt Framework – non-commercial use only. For commercial use, contact dejan@divhunt.com.
+
+# Divhunt Framework
+
+A lightweight, extensible JavaScript framework built around an addon system with powerful data validation, event handling, and DOM manipulation capabilities.
+
+## Core Architecture
+
+The framework consists of a main `Divhunt` class with modular mixins and an extensible addon system:
+
+```
+Framework Core
+├── Divhunt Class (main)
+├── Mixins (functionality)
+│   ├── Addons
+│   ├── Data Validation
+│   ├── Event System
+│   ├── Middleware
+│   ├── DOM Manipulation
+│   └── Utilities
+└── Addon System
+    ├── DivhuntAddon
+    ├── DivhuntAddonItem
+    └── DivhuntAddonRender
+```
+
+## Quick Start
+
+### Server-side
+```javascript
+import Divhunt from './lib/load.js';
+
+const divhunt = new Divhunt();
+
+// Create an addon
+const users = divhunt.Addon('users', (addon) => {
+    addon.Field('name', ['string']);
+    addon.Field('email', ['string']);
+});
+
+// Add items
+users.Item({
+    name: 'John Doe',
+    email: 'john@example.com'
+});
+```
+
+### Browser
+```html
+<script src="framework/browser.js"></script>
+<script>
+    // window.divhunt is automatically available
+    const myAddon = window.divhunt.Addon('myAddon');
+</script>
+```
+
+## Core Features
+
+### 🔧 Addon System
+Create modular, reusable components with built-in validation
+
+### 📊 Data Validation
+Powerful schema-based validation with nested objects and arrays
+
+### 🎯 Event System
+Publisher-subscriber pattern for decoupled communication
+
+### ⚡ Middleware
+Intercept and modify operations with middleware chains
+
+### 🌐 DOM Manipulation
+Efficient DOM operations with state preservation
+
+### 🛠️ Utilities
+Helper functions for common operations and data manipulation
+
+## Documentation
+
+- [Installation](./docs/installation.md)
+- [Addons](./docs/addons.md)
+- [Data Validation](./docs/data-validation.md)
+- [Events & Middleware](./docs/events-middleware.md)
+- [DOM Manipulation](./docs/dom.md)
+- [Utilities](./docs/utilities.md)
+- [API Reference](./docs/api-reference.md)
+
+## Example Usage
+
+```javascript
+// Create a blog addon
+const blog = divhunt.Addon('blog', (addon) => {
+    addon.Field('title', ['string', '', true]);
+    addon.Field('content', ['string', '', true]);
+    addon.Field('author', ['object', {}, true], null, null, false, {
+        name: ['string'],
+        email: ['string']
+    });
+    addon.Field('tags', ['array'], null, null, false, {
+        each: ['string']
+    });
+});
+
+// Add a post
+const post = blog.Item({
+    title: 'Getting Started',
+    content: 'Welcome to our blog...',
+    author: {
+        name: 'Jane Smith',
+        email: 'jane@example.com'
+    },
+    tags: ['tutorial', 'getting-started']
+});
+
+// Listen for events
+divhunt.EmitOn('addon.item.add', (addon, item) => {
+    console.log(`New item added to ${addon.GetName()}`);
+});
+
+// Custom function
+blog.Fn('getByTag', function(tag) {
+    return Object.values(this.Items()).filter(item => 
+        item.Get('tags').includes(tag)
+    );
+});
+
+// Use the function
+const tutorials = blog.Fn('getByTag', 'tutorial');
+```
+
+## License
+
+Licensed under the Divhunt Framework License. See LICENSE.txt for terms.

package/lib/browser.js

@@ -0,0 +1,26 @@
+// © 2025 Divhunt GmbH — Licensed under the Divhunt Framework License. See LICENSE for terms.
+
+window.divhunt = window.divhunt = new Divhunt();
+
+if (document.readyState === 'loading')
+{
+    document.addEventListener('DOMContentLoaded', initBrowser);
+}
+else
+{
+    initBrowser();
+}
+
+function initBrowser()
+{
+    divhunt.Addon('browser', function(addon)
+    {
+        addon.Render('body', () =>
+        {
+            return document.body.outerHTML;
+        });
+
+        const render = addon.Render('body', window);
+        document.body.replaceChildren(...render.Element.children);
+    });
+}