structured-fw 0.7.2

package/build/system/client/DataStore.d.ts

@@ -0,0 +1,22 @@
+import { AsteriskAny, StoreChangeCallback } from '../Types.js';
+import { ClientComponent } from './ClientComponent.js';
+export declare class DataStore {
+    protected data: {
+        [componentId: string]: {
+            [key: string]: any;
+        };
+    };
+    protected changeListeners: {
+        [componentId: string]: {
+            [key: string]: Array<StoreChangeCallback>;
+        };
+    };
+    set(component: ClientComponent, key: string, val: any, force?: boolean, triggerListeners?: boolean): DataStore;
+    get(componentId: string, key?: string): any;
+    hasKey(componentId: string, key: string): boolean;
+    clear(componentId: string): void;
+    destroy(componentId: string): void;
+    onChange(componentId: string, key: string | AsteriskAny, callback: StoreChangeCallback): DataStore;
+    onChangeCallbacks(componentId: string): Record<string, Array<StoreChangeCallback>>;
+    private unbindAll;
+}

package/build/system/client/DataStore.js

@@ -0,0 +1,64 @@
+import { equalDeep } from '../Util.js';
+export class DataStore {
+    constructor() {
+        this.data = {};
+        this.changeListeners = {};
+    }
+    set(component, key, val, force = false, triggerListeners = true) {
+        const componentId = component.getData('componentId');
+        const oldValue = this.get(componentId, key);
+        if (!force && equalDeep({ value: oldValue }, { value: val })) {
+            return this;
+        }
+        if (!this.data[componentId]) {
+            this.data[componentId] = {};
+        }
+        this.data[componentId][key] = val;
+        if (triggerListeners) {
+            if (this.changeListeners[componentId] && (this.changeListeners[componentId][key] || this.changeListeners[componentId]['*'])) {
+                (this.changeListeners[componentId][key] || []).concat(this.changeListeners[componentId]['*'] || []).forEach((cb) => {
+                    cb.apply(component, [key, val, oldValue, componentId]);
+                });
+            }
+        }
+        return this;
+    }
+    get(componentId, key) {
+        if (!this.data[componentId]) {
+            return undefined;
+        }
+        if (typeof key !== 'string') {
+            return this.data[componentId];
+        }
+        return this.data[componentId][key];
+    }
+    hasKey(componentId, key) {
+        if (!(componentId in this.data)) {
+            return false;
+        }
+        return key in this.data[componentId];
+    }
+    clear(componentId) {
+        this.data[componentId] = {};
+    }
+    destroy(componentId) {
+        this.unbindAll(componentId);
+        this.clear(componentId);
+    }
+    onChange(componentId, key, callback) {
+        if (!(componentId in this.changeListeners)) {
+            this.changeListeners[componentId] = {};
+        }
+        if (!(key in this.changeListeners[componentId])) {
+            this.changeListeners[componentId][key] = [];
+        }
+        this.changeListeners[componentId][key].push(callback);
+        return this;
+    }
+    onChangeCallbacks(componentId) {
+        return this.changeListeners[componentId];
+    }
+    unbindAll(componentId) {
+        delete this.changeListeners[componentId];
+    }
+}

package/build/system/client/DataStoreView.d.ts

@@ -0,0 +1,19 @@
+import { AsteriskAny, StoreChangeCallback } from '../Types.js';
+import { ClientComponent } from './ClientComponent.js';
+import { DataStore } from './DataStore.js';
+export declare class DataStoreView {
+    private store;
+    private component;
+    private destroyed;
+    constructor(store: DataStore, component: ClientComponent);
+    set(key: string, val: any, force?: boolean, triggerListeners?: boolean): DataStoreView;
+    get<T>(key: string): T | undefined;
+    toggle(key: string): void;
+    keys(): Array<string>;
+    import(fields?: Array<string>, force?: boolean, triggerListeners?: boolean): void;
+    clear(): void;
+    destroy(): void;
+    private componentId;
+    onChange(key: string | AsteriskAny, callback: StoreChangeCallback): DataStoreView;
+    onChangeCallbacks(): Record<string, Array<StoreChangeCallback>>;
+}

package/build/system/client/DataStoreView.js

@@ -0,0 +1,56 @@
+export class DataStoreView {
+    constructor(store, component) {
+        this.destroyed = false;
+        this.store = store;
+        this.component = component;
+    }
+    set(key, val, force = false, triggerListeners = true) {
+        if (!this.destroyed) {
+            this.store.set(this.component, key, val, force, triggerListeners);
+        }
+        return this;
+    }
+    get(key) {
+        if (this.destroyed) {
+            return undefined;
+        }
+        return this.store.get(this.componentId(), key);
+    }
+    toggle(key) {
+        this.set(key, !this.get(key));
+    }
+    keys() {
+        if (this.destroyed) {
+            return [];
+        }
+        return Object.keys(this.store.get(this.componentId()));
+    }
+    import(fields, force = false, triggerListeners = true) {
+        const fieldsImported = Array.isArray(fields) ? fields : Object.keys(this.component.getData());
+        fieldsImported.forEach((field) => {
+            if (force || !this.store.hasKey(this.componentId(), field)) {
+                this.set(field, this.component.getData(field), force, triggerListeners);
+            }
+        });
+    }
+    clear() {
+        this.store.clear(this.componentId());
+    }
+    destroy() {
+        this.store.destroy(this.componentId());
+        this.destroyed = true;
+    }
+    componentId() {
+        return this.component.getData('componentId');
+    }
+    onChange(key, callback) {
+        if (this.destroyed) {
+            return this;
+        }
+        this.store.onChange(this.componentId(), key, callback);
+        return this;
+    }
+    onChangeCallbacks() {
+        return this.store.onChangeCallbacks(this.componentId());
+    }
+}

package/build/system/client/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+import { EventEmitterCallback } from "../Types.js";
+export declare class EventEmitter {
+    protected listeners: Record<string, Array<EventEmitterCallback>>;
+    on(eventName: string, callback: EventEmitterCallback): void;
+    emit(eventName: string, payload?: any): void;
+    unbind(eventName: string, callback: EventEmitterCallback): void;
+}

package/build/system/client/EventEmitter.js

@@ -0,0 +1,31 @@
+export class EventEmitter {
+    constructor() {
+        this.listeners = {};
+    }
+    on(eventName, callback) {
+        if (!Array.isArray(this.listeners[eventName])) {
+            this.listeners[eventName] = [];
+        }
+        this.listeners[eventName].push(callback);
+    }
+    emit(eventName, payload) {
+        if (Array.isArray(this.listeners[eventName])) {
+            this.listeners[eventName].forEach((callback) => {
+                callback(payload);
+            });
+        }
+    }
+    unbind(eventName, callback) {
+        if (Array.isArray(this.listeners[eventName])) {
+            while (true) {
+                const index = this.listeners[eventName].indexOf(callback);
+                if (index > -1) {
+                    this.listeners[eventName].splice(index, 1);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+}

package/build/system/client/Net.d.ts

@@ -0,0 +1,13 @@
+import { IncomingHttpHeaders } from 'node:http';
+import { LooseObject, RequestMethod } from '../Types.js';
+export declare class Net {
+    request(method: RequestMethod, url: string, headers?: IncomingHttpHeaders, body?: any, responseType?: XMLHttpRequestResponseType): Promise<string>;
+    get(url: string, headers?: IncomingHttpHeaders): Promise<string>;
+    delete(url: string, headers?: IncomingHttpHeaders): Promise<string>;
+    post(url: string, data: any, headers?: IncomingHttpHeaders): Promise<string>;
+    put(url: string, data: any, headers?: IncomingHttpHeaders): Promise<string>;
+    getJSON<T>(url: string, headers?: IncomingHttpHeaders): Promise<T>;
+    postJSON<T>(url: string, data: LooseObject, headers?: IncomingHttpHeaders): Promise<T>;
+    deleteJSON<T>(url: string, headers?: IncomingHttpHeaders): Promise<T>;
+    putJSON<T>(url: string, data: LooseObject, headers?: IncomingHttpHeaders): Promise<T>;
+}

package/build/system/client/Net.js

@@ -0,0 +1,39 @@
+import { NetRequest } from './NetRequest.js';
+export class Net {
+    async request(method, url, headers = {}, body, responseType = 'text') {
+        const request = new NetRequest(method, url, headers, responseType);
+        return request.send(body);
+    }
+    async get(url, headers = {}) {
+        return this.request('GET', url, headers);
+    }
+    async delete(url, headers = {}) {
+        return this.request('DELETE', url, headers);
+    }
+    async post(url, data, headers = {}) {
+        if (typeof data === 'object' && !headers['content-type'] && !(data instanceof FormData)) {
+            headers['content-type'] = 'application/json';
+            data = JSON.stringify(data);
+        }
+        return await this.request('POST', url, headers, data);
+    }
+    async put(url, data, headers = {}) {
+        if (typeof data === 'object' && !headers['content-type']) {
+            headers['content-type'] = 'application/json';
+            data = JSON.stringify(data);
+        }
+        return this.request('PUT', url, headers, data);
+    }
+    async getJSON(url, headers) {
+        return JSON.parse(await this.get(url, headers));
+    }
+    async postJSON(url, data, headers) {
+        return JSON.parse(await this.post(url, data, headers));
+    }
+    async deleteJSON(url, headers) {
+        return JSON.parse(await this.delete(url, headers));
+    }
+    async putJSON(url, data, headers) {
+        return JSON.parse(await this.put(url, data, headers));
+    }
+}

package/build/system/client/NetRequest.d.ts

@@ -0,0 +1,13 @@
+import { IncomingHttpHeaders } from 'node:http';
+import { RequestMethod } from '../Types.js';
+export declare class NetRequest {
+    xhr: XMLHttpRequest;
+    method: RequestMethod;
+    url: string;
+    headers: IncomingHttpHeaders;
+    responseType: XMLHttpRequestResponseType;
+    body: any;
+    requestSent: boolean;
+    constructor(method: RequestMethod, url: string, headers?: IncomingHttpHeaders, responseType?: XMLHttpRequestResponseType, body?: any);
+    send(body?: any): Promise<string>;
+}

package/build/system/client/NetRequest.js

@@ -0,0 +1,45 @@
+export class NetRequest {
+    constructor(method, url, headers = {}, responseType = 'text', body) {
+        this.xhr = new XMLHttpRequest();
+        this.requestSent = false;
+        this.method = method;
+        this.url = url;
+        this.headers = headers;
+        this.responseType = responseType;
+        this.body = body;
+        this.xhr.open(this.method, this.url);
+        this.xhr.responseType = this.responseType;
+        if (!('x-requested-with' in headers)) {
+            headers['x-requested-with'] = 'xmlhttprequest';
+        }
+        for (const header in headers) {
+            const headerValue = headers[header];
+            if (typeof headerValue === 'string') {
+                this.xhr.setRequestHeader(header, headerValue);
+            }
+            else {
+                console.warn('Only string header values are supported');
+            }
+        }
+    }
+    async send(body) {
+        if (this.requestSent) {
+            return '';
+        }
+        this.requestSent = true;
+        if (typeof body !== 'undefined') {
+            this.body = body;
+        }
+        return new Promise((resolve, reject) => {
+            this.xhr.onreadystatechange = () => {
+                if (this.xhr.readyState == 4) {
+                    resolve(this.xhr.responseText);
+                }
+            };
+            this.xhr.onerror = (err) => {
+                reject(err);
+            };
+            this.xhr.send(body);
+        });
+    }
+}

package/build/system/server/Application.d.ts

@@ -0,0 +1,31 @@
+import { Server } from 'node:http';
+import { ApplicationEvents, LooseObject, RequestCallback, StructuredConfig } from '../Types';
+import { Components } from './Components.js';
+import { Session } from './Session.js';
+import { Request } from './Request.js';
+import { Handlebars } from './Handlebars.js';
+import { Cookies } from './Cookies.js';
+import { RequestContextData } from '../../app/Types.js';
+export declare class Application {
+    readonly config: StructuredConfig;
+    server: null | Server;
+    listening: boolean;
+    private readonly eventEmitter;
+    readonly cookies: Cookies;
+    readonly session: Session;
+    readonly request: Request;
+    readonly components: Components;
+    readonly handlebars: Handlebars;
+    readonly exportedRequestContextData: Array<keyof RequestContextData>;
+    constructor(config: StructuredConfig);
+    init(): Promise<void>;
+    start(): Promise<void>;
+    on(evt: ApplicationEvents, callback: RequestCallback | ((payload?: any) => void)): void;
+    emit(eventName: ApplicationEvents, payload?: any): Promise<Array<any>>;
+    importEnv<T extends LooseObject>(smartPrimitives?: boolean): T;
+    exportContextFields(...fields: Array<keyof RequestContextData>): void;
+    contentType(extension: string): string | false;
+    private respondWithComponent;
+    memoryUsage(): NodeJS.MemoryUsage;
+    printMemoryUsage(): void;
+}

package/build/system/server/Application.js

@@ -0,0 +1,171 @@
+import { EventEmitter } from 'node:events';
+import { existsSync, readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import * as path from 'node:path';
+import * as mime from 'mime-types';
+import { Document } from './Document.js';
+import { Components } from './Components.js';
+import { Session } from './Session.js';
+import { toSnakeCase } from '../Util.js';
+import { Request } from './Request.js';
+import { Handlebars } from './Handlebars.js';
+import { Cookies } from './Cookies.js';
+export class Application {
+    constructor(config) {
+        this.server = null;
+        this.listening = false;
+        this.eventEmitter = new EventEmitter();
+        this.handlebars = new Handlebars();
+        this.exportedRequestContextData = [];
+        this.config = config;
+        this.cookies = new Cookies();
+        this.session = new Session(this);
+        this.request = new Request(this);
+        this.components = new Components(this);
+        this.session.start();
+        if (this.config.autoInit) {
+            this.init();
+        }
+    }
+    async init() {
+        this.eventEmitter.setMaxListeners(10);
+        try {
+            await this.handlebars.loadHelpers('../Helpers.js');
+        }
+        catch (e) {
+            console.error(e.message);
+        }
+        await this.emit('beforeComponentLoad');
+        this.components.loadComponents();
+        await this.emit('afterComponentLoad');
+        await this.emit('beforeRoutes');
+        await this.request.loadHandlers();
+        await this.emit('afterRoutes');
+        if (this.config.url.componentRender !== false) {
+            this.request.on('POST', `${this.config.url.componentRender}`, async (ctx) => {
+                const input = ctx.body;
+                await this.respondWithComponent(ctx, input.component, input.attributes || undefined, typeof input.unwrap === 'boolean' ? input.unwrap : true);
+            });
+        }
+        this.request.on('GET', /^\/assets\/client-js/, async ({ request, response }) => {
+            const uri = request.url?.substring(18);
+            const filePath = path.resolve('./system/', uri);
+            if (existsSync(filePath)) {
+                response.setHeader('Content-Type', 'application/javascript');
+                response.write(readFileSync(filePath));
+                response.end();
+            }
+            else {
+                response.statusCode = 404;
+            }
+            return;
+        }, this, true);
+        await this.start();
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => {
+                this.request.handle(req, res);
+            });
+            this.server.listen(this.config.http.port, this.config.http.host || '127.0.0.1', async () => {
+                const address = (this.config.http.host !== undefined ? this.config.http.host : '') + ':' + this.config.http.port;
+                await this.emit('serverStarted');
+                console.log(`Server started on ${address}`);
+                resolve();
+            });
+        });
+    }
+    on(evt, callback) {
+        this.eventEmitter.on(evt, callback);
+    }
+    async emit(eventName, payload) {
+        const promises = [];
+        const listeners = this.eventEmitter.rawListeners(eventName);
+        for (let i = 0; i < listeners.length; i++) {
+            promises.push(listeners[i](payload));
+        }
+        const results = await Promise.allSettled(promises);
+        return results.filter((res) => {
+            return res.status === 'fulfilled';
+        }).map((res) => {
+            return res.value;
+        });
+    }
+    importEnv(smartPrimitives = true) {
+        const values = {};
+        const usePrefix = typeof this.config.envPrefix === 'string';
+        const prefixLength = usePrefix ? this.config.envPrefix.length : 0;
+        for (const key in process.env) {
+            if (!usePrefix || key.startsWith(this.config.envPrefix)) {
+                let value = process.env[key];
+                const keyWithoutPrefix = key.substring(prefixLength + 1);
+                if (smartPrimitives) {
+                    if (value === 'undefined') {
+                        value = undefined;
+                    }
+                    else if (value === 'null') {
+                        value = null;
+                    }
+                    else if (value === 'true') {
+                        value = true;
+                    }
+                    else if (value === 'false') {
+                        value = false;
+                    }
+                    else if (/^-?\d+$/.test(value)) {
+                        value = parseInt(value);
+                    }
+                    else if (/^\d+\.\d+$/.test(value)) {
+                        value = parseFloat(value);
+                    }
+                }
+                values[keyWithoutPrefix] = value;
+            }
+        }
+        return values;
+    }
+    exportContextFields(...fields) {
+        fields.forEach((field) => {
+            if (!this.exportedRequestContextData.includes(field)) {
+                this.exportedRequestContextData.push(field);
+            }
+        });
+    }
+    contentType(extension) {
+        return mime.contentType(extension);
+    }
+    async respondWithComponent(ctx, componentName, attributes, unwrap = true) {
+        const component = this.components.getByName(componentName);
+        if (component) {
+            const document = new Document(this, '', ctx);
+            const data = attributes;
+            await document.loadComponent(component.name, data);
+            const exportedData = component.exportData ? document.data : (component.exportFields ? component.exportFields.reduce((prev, curr) => {
+                prev[curr] = document.children[0].data[curr];
+                return prev;
+            }, {}) : {});
+            ctx.respondWith({
+                html: document.children[0].dom[unwrap ? 'innerHTML' : 'outerHTML'],
+                initializers: document.initInitializers(),
+                data: exportedData
+            });
+            return true;
+        }
+        return false;
+    }
+    memoryUsage() {
+        return process.memoryUsage();
+    }
+    printMemoryUsage() {
+        const usage = this.memoryUsage();
+        let total = 0;
+        const totals = Object.keys(usage).reduce((prev, key) => {
+            const usedMb = usage[key] / 1000000;
+            prev[toSnakeCase(key).replaceAll('_', ' ')] = [parseFloat(usedMb.toFixed(1)), 'Mb'];
+            total += usedMb;
+            return prev;
+        }, {});
+        totals.total = [parseFloat(total.toFixed(1)), 'Mb'];
+        console.table(totals);
+    }
+}

package/build/system/server/Component.d.ts

@@ -0,0 +1,27 @@
+import { Document } from './Document.js';
+import { ComponentEntry, LooseObject } from '../Types.js';
+import { DOMNode } from './dom/DOMNode.js';
+export declare class Component {
+    id: string;
+    name: string;
+    document: Document;
+    parent: null | Document | Component;
+    children: Array<Component>;
+    path: Array<string>;
+    attributesRaw: Record<string, string | true>;
+    attributes: Record<string, string | number | boolean | LooseObject | null>;
+    dom: DOMNode;
+    data: LooseObject;
+    entry: null | ComponentEntry;
+    isRoot: boolean;
+    constructor(name: string, node?: DOMNode, parent?: Document | Component, autoInit?: boolean);
+    init(html: string, data?: LooseObject): Promise<void>;
+    setAttributes(attributes: Record<string, any>, prefix?: string, encode?: boolean): void;
+    private initChildren;
+    protected importedParentData(parentData: LooseObject): LooseObject;
+    protected initAttributesData(domNode?: DOMNode): void;
+    private attributePreffix;
+    private attributeDataType;
+    private attributeUnpreffixed;
+    protected fillData(data: LooseObject): void;
+}