@social-mail/social-mail-hosted-web 1.0.2

package/node_modules/@web-atoms/core/src/core/AtomDispatcher.ts

@@ -0,0 +1,62 @@
+export class AtomDispatcher {
+
+    // public static instance: AtomDispatcher = new AtomDispatcher();
+    public paused: boolean;
+    public head = null;
+    public tail = null;
+
+    public  onTimeout(): void {
+        if (this.paused) {
+            return;
+        }
+        if (!this.head) {
+            return;
+        }
+        const item = this.head;
+        this.head = item.next;
+        item.next = null;
+        if (!this.head) {
+            this.tail = null;
+        }
+
+        item();
+        setTimeout(() => {
+            this.onTimeout();
+        }, 1);
+    }
+
+    public pause(): void {
+        this.paused = true;
+    }
+
+    public start(): void {
+        this.paused = false;
+        setTimeout(() => {
+            this.onTimeout();
+        }, 1);
+    }
+
+    public callLater(f: () => void) {
+
+        if (this.tail) {
+            this.tail.next = f;
+            this.tail = f;
+        } else {
+
+            this.head = f;
+            this.tail = f;
+        }
+        if (!this.paused) {
+            this.start();
+        }
+    }
+
+    public waitForAll(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.callLater(() => {
+                resolve();
+            });
+        });
+    }
+
+}

package/node_modules/@web-atoms/core/src/core/AtomDisposableList.ts

@@ -0,0 +1,33 @@
+import { IDisposable } from "./types";
+
+export class AtomDisposableList implements IDisposable {
+
+    // tslint:disable-next-line:ban-types
+    private disposables: IDisposable[] = [];
+
+    // tslint:disable-next-line:ban-types
+    public add(d: (() => void) | IDisposable): IDisposable {
+        if (typeof d === "function") {
+            const fx = d;
+            d = {
+                dispose: fx
+            };
+        }
+        this.disposables.push(d);
+        const dx = d;
+        return {
+            dispose: () => {
+                this.disposables = this.disposables.filter((x) => x !== dx);
+                dx.dispose();
+            }
+        };
+    }
+
+    public dispose(): void {
+        for (const iterator of this.disposables) {
+            iterator.dispose();
+        }
+        this.disposables.length = 0;
+    }
+
+}

package/node_modules/@web-atoms/core/src/core/AtomEnumerator.ts

@@ -0,0 +1,21 @@
+export default class AtomEnumerator<T> {
+
+    private index: number = -1;
+
+    constructor(private readonly items: T[]) {
+    }
+
+    public next(): boolean {
+        this.index ++;
+        return this.index < this.items.length;
+    }
+
+    public get current(): T {
+        return this.items[this.index];
+    }
+
+    public get currentIndex(): number {
+        return this.index;
+    }
+
+}

package/node_modules/@web-atoms/core/src/core/AtomList.ts

@@ -0,0 +1,325 @@
+import { AtomBinder, IWatchableObject, IWatchFunctionCollection, WatchFunction } from "./AtomBinder";
+import { IDisposable } from "./types";
+
+    /**
+     *
+     *
+     * @export
+     * @class AtomList
+     * @extends {Array<T>}
+     * @template T
+     */
+    export class AtomList<T> extends Array<T> {
+        // public next: Function;
+        // public prev: Function;
+        public next: (() => any);
+        public prev: (() => any);
+
+        private startValue: number = 0;
+        private totalValue: number = 0;
+        private sizeValue: number = 10;
+        // private version: number = 1;
+        constructor() {
+            super();
+
+            // tslint:disable-next-line
+            this["__proto__"] = AtomList.prototype;
+
+            this.next = () => {
+                this.start = this.start + this.size;
+            };
+
+            this.prev = () => {
+                if (this.start >= this.size) {
+                    this.start = this.start - this.size;
+                }
+            };
+        }
+        public get start(): number {
+            return this.startValue;
+        }
+        public set start(v: number) {
+            if (v === this.startValue) {
+                return ;
+            }
+            this.startValue = v;
+            AtomBinder.refreshValue(this, "start");
+        }
+
+        public get total(): number {
+            return this.totalValue;
+        }
+        public set total(v: number) {
+            if (v === this.totalValue) {
+                return ;
+            }
+            this.totalValue = v;
+            AtomBinder.refreshValue(this, "total");
+        }
+
+        public get size(): number {
+            return this.sizeValue;
+        }
+        public set size(v: number) {
+            if (v === this.sizeValue) {
+                return ;
+            }
+            this.sizeValue = v;
+            AtomBinder.refreshValue(this, "size");
+        }
+        /**
+         * Adds the item in the list and refresh bindings
+         * @param {T} item
+         * @returns {number}
+         * @memberof AtomList
+         */
+        public add(item: T): number {
+            const i: number = this.length;
+            const n: number = this.push(item);
+            AtomBinder.invokeItemsEvent(this, "add", i, item);
+            AtomBinder.refreshValue(this, "length");
+            // this.version++;
+            return n;
+        }
+
+        /**
+         * Add given items in the list and refresh bindings
+         * @param {Array<T>} items
+         * @memberof AtomList
+         */
+        public addAll(items: T[]): void {
+            for (const item of items) {
+                const i: number = this.length;
+                this.push(item);
+                AtomBinder.invokeItemsEvent(this, "add", i, item);
+                AtomBinder.refreshValue(this, "length");
+            }
+            // tslint:disable-next-line:no-string-literal
+            const t: number = items["total"];
+            if (t) {
+                this.total = t;
+            }
+            // this.version++;
+        }
+
+        /**
+         * Replaces list with given items, use this
+         * to avoid flickering in screen
+         * @param {T[]} items
+         * @memberof AtomList
+         */
+        public replace(items: T[], start?: number, size?: number): void {
+            this.length = items.length;
+            for (let i: number = 0; i < items.length; i++) {
+                this[i] = items[i];
+            }
+            this.refresh();
+            // tslint:disable-next-line:no-string-literal
+            const t: number = items["total"];
+            if (t) {
+                this.total = t;
+            }
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (size !== undefined) {
+                this.size = size;
+            }
+        }
+
+        /**
+         * Inserts given number in the list at position `i`
+         * and refreshes the bindings.
+         * @param {number} i
+         * @param {T} item
+         * @memberof AtomList
+         */
+        public insert(i: number, item: T): void {
+            const n: any = this.splice(i, 0, item);
+            AtomBinder.invokeItemsEvent(this, "add", i, item);
+            AtomBinder.refreshValue(this, "length");
+        }
+
+        /**
+         * Replaces given item in the list at position `i`
+         * and refreshes the bindings.
+         * @param {number} i
+         * @param {T} item
+         * @memberof AtomList
+         */
+        public set(i: number, item: T): void {
+            const old = this[i];
+            this[i] = item;
+            AtomBinder.invokeItemsEvent(this, "replace", i, item, old);
+            AtomBinder.refreshValue(this, "length");
+        }
+
+        /**
+         * Removes item at given index i and refresh the bindings
+         * @param {number} i
+         * @memberof AtomList
+         */
+        public removeAt(i: number): T {
+            const item: T = this[i];
+            this.splice(i, 1);
+            AtomBinder.invokeItemsEvent(this, "remove", i, item);
+            AtomBinder.refreshValue(this, "length");
+            return item;
+        }
+
+        /**
+         * Removes given item or removes all items that match
+         * given lambda as true and refresh the bindings
+         * @param {(T | ((i:T) => boolean))} item
+         * @returns {boolean} `true` if any item was removed
+         * @memberof AtomList
+         */
+        public remove(item: T | ((i: T) => boolean)): boolean {
+
+            if (item instanceof Function) {
+                let index: number = 0;
+                let removed: boolean = false;
+                for (const it of this) {
+                    if (item(it)) {
+                        this.removeAt(index);
+                        removed = true;
+                        continue;
+                    }
+                    index++;
+                }
+                return removed;
+            }
+
+            const n: number = this.indexOf(item);
+            if (n !== -1) {
+                this.removeAt(n);
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * Removes all items from the list and refreshes the bindings
+         * @memberof AtomList
+         */
+        public clear(): void {
+            this.length = 0;
+            this.refresh();
+        }
+
+        public refresh(): void {
+            AtomBinder.invokeItemsEvent(this, "refresh", -1, null);
+            AtomBinder.refreshValue(this, "length");
+            // this.version++;
+        }
+
+        public watch(
+            f: (target: any, key: string, index?: number, item?: any) => void,
+            wrap?: boolean
+        ): IDisposable {
+            if (wrap) {
+                const fx = f;
+                f = (function() {
+                    const p: any[] = [];
+                    // tslint:disable-next-line:prefer-for-of
+                    for (let i: number = 0; i < arguments.length ; i++) {
+                        const iterator = arguments[i];
+                        p.push(iterator);
+                    }
+                    return fx.call(this, p);
+                });
+            }
+            return AtomBinder.add_CollectionChanged(this, f);
+        }
+
+        public count(f: (item) => boolean) {
+            let total = 0;
+            for (const iterator of this) {
+                if (f(iterator)) {
+                    total++;
+                }
+            }
+            return total;
+        }
+
+        public avg(f: (item) => number) {
+            if (!this.length) {
+                return 0;
+            }
+            let sum = 0;
+            for (const iterator of this) {
+                sum += f(iterator);
+            }
+            return sum / this.length;
+        }
+
+        public includes(item) {
+            return this.indexOf(item) !== -1;
+        }
+
+    }
+
+    // tslint:disable
+    const ap = Array.prototype;
+    for (const key of Object.getOwnPropertyNames(AtomList.prototype)) {
+        const { value } = Object.getOwnPropertyDescriptor(AtomList.prototype, key);        
+        switch(key) {
+            case "add":
+            case "addAll":
+            case "clear":
+            case "refresh":
+            case "set":
+            case "remove":
+            case "removeAt":
+            case "watch":
+            case "replace":
+            case "insert":
+            case "count":
+            case "avg":
+            case "includes":
+                if (key in ap) {
+                    continue;
+                }
+                Object.defineProperty(ap, key, {
+                    enumerable: false,
+                    value,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+        }
+        
+    }
+    // Array.prototype["add"] = AtomList.prototype.add;
+    // Array.prototype["addAll"] = AtomList.prototype.addAll;
+    // Array.prototype["clear"] = AtomList.prototype.clear;
+    // Array.prototype["refresh"] = AtomList.prototype.refresh;
+    // Array.prototype["set"] = AtomList.prototype.set;
+    // Array.prototype["remove"] = AtomList.prototype.remove;
+    // Array.prototype["removeAt"] = AtomList.prototype.removeAt;
+    // Array.prototype["watch"] = AtomList.prototype.watch;
+    // Array.prototype["replace"] = AtomList.prototype.replace;
+    // Array.prototype["insert"] = AtomList.prototype.insert;
+    // Array.prototype["count"] = AtomList.prototype.count;
+    // Array.prototype["avg"] = AtomList.prototype.avg;
+    // Array.prototype["includes"] = AtomList.prototype.includes;
+
+declare global { 
+    interface Array<T> {
+        add?(item:T):number;
+        addAll?(item:T[]):void;
+        clear?():void;
+        refresh?():void;
+        insert?(index: number, item: T): void;
+        remove?(item: T | ((i:T) => boolean)):boolean;
+        removeAt?(i: number):T;
+        set?(index: number, item: T): void;
+        watch?(
+            f: (target: any, key: string, index?: number, item?: any) => void,
+            wrap?: boolean): IDisposable;
+        replace(items: T[], start?: number, size?: number): void;
+        includes(item:T): boolean;
+        count?(f: (item: T) => boolean): number;
+        avg?(f: (item: T) => number): number;
+    }
+}

package/node_modules/@web-atoms/core/src/core/AtomLoader.ts

@@ -0,0 +1,264 @@
+import type { App } from "../App";
+import { JsonService } from "../services/JsonService";
+import ReferenceService from "../services/ReferenceService";
+import { AtomWindowViewModel } from "../view-model/AtomWindowViewModel";
+import type { AtomControl } from "../web/controls/AtomControl";
+import type { AtomDisposableList } from "./AtomDisposableList";
+import { AtomUri } from "./AtomUri";
+import { displayRouteSymbol } from "./Command";
+import { getOwnInheritedProperty } from "./InheritedProperty";
+import { CancelToken, DI, IClassOf, IDisposable } from "./types";
+
+export class AtomLoader {
+
+    public static id: number = 1;
+
+    public static async load<T>(url: string | AtomUri | any, app: App): Promise<T> {
+
+        if (typeof url === "string") {
+            const type = await DI.resolveViewClassAsync(url);
+            if (!type) {
+                throw new Error(`Type not found for ${url}`);
+            }
+            url = type;
+        }
+
+        if (url instanceof AtomUri) {
+            if (url.host === "reference") {
+                const r = app.get(ReferenceService).get(url.path);
+                if (!r) {
+                    throw new Error("reference not found");
+                }
+                return r.consume();
+            }
+            if (url.host === "class") {
+                const r = app.get(ReferenceService).get(url.path);
+                if (!r) {
+                    throw new Error("reference not found");
+                }
+                return app.resolve(r.consume(), true);
+            }
+            url = url.path;
+
+            const type = await DI.resolveViewClassAsync(url);
+            if (!type) {
+                throw new Error(`Type not found for ${url}`);
+            }
+            url = type;
+
+        }
+        const obj = app.resolve(url, true);
+        return obj;
+    }
+
+    public static async loadView<T extends { viewModel: any, element: any,
+        dispose: () => any, disposables: AtomDisposableList }>(
+        url: AtomUri,
+        app: App,
+        hookCloseEvents: boolean,
+        vmFactory?: () => any): Promise<{
+            view: T,
+            disposables?: AtomDisposableList,
+            returnPromise?: Promise<any>,
+            id?: string}> {
+
+        const busyIndicator = app.createBusyIndicator({
+            title: url.toString(),
+            description: `Loading View ${url}`
+        });
+
+        try {
+            const view = await AtomLoader.load<T>(url, app);
+            let vm = view.viewModel;
+            if (!vm) {
+                if (!vmFactory) {
+                    return { view };
+                }
+                vm = vmFactory();
+                view.viewModel = vm;
+            }
+            if ("parameters" in view) {
+                vm = (view as any).parameters;
+            }
+            if (vm) {
+                const jsonService = app.get(JsonService);
+                for (const key in url.query) {
+                    if (url.query.hasOwnProperty(key)) {
+                        const element = url.query[key];
+                        if (typeof element === "object") {
+                            vm[key] = jsonService.parse(jsonService.stringify(element));
+                            continue;
+                        }
+                        if (/^json\:/.test(key)) {
+                            const k = key.split(":")[1];
+                            vm[k] = jsonService.parse(element.toString());
+                            continue;
+                        }
+                        if (/^ref\:/.test(key)) {
+                            const rs = app.get(ReferenceService);
+                            const v = rs.get(element as string);
+                            vm[key.split(":", 2)[1]] = v.consume();
+                            continue;
+                        }
+                        try {
+                            vm[key] = element;
+                        } catch (e) {
+                            // tslint:disable-next-line: no-console
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+
+            // register hooks !! if it is a window !!
+            if (hookCloseEvents && vm) {
+
+                const disposables = view.disposables;
+
+                const id = (AtomLoader.id++).toString();
+                (view as any).id = id;
+
+                const returnPromise = new Promise((resolve, reject) => {
+                    disposables.add( app.subscribe(`atom-window-close:${id}`, (m, r) => {
+                        resolve(r);
+                        view.dispose();
+                    }));
+                    disposables.add( app.subscribe(`atom-window-cancel:${id}`, () => {
+                        reject("cancelled");
+                        view.dispose();
+                    }));
+                });
+
+                // it is responsibility of view holder to dispose the view
+                // disposables.add((view as any));
+
+                vm.windowName = id;
+
+                (view as any).returnPromise = returnPromise;
+
+                return { view, disposables, returnPromise, id };
+            }
+
+            return { view };
+        } finally {
+            busyIndicator.dispose();
+        }
+    }
+
+    public static async loadClass<T extends AtomControl>(
+        url: string | any,
+        { title, [displayRouteSymbol]: route, ... parameters }: any = {},
+        app: App): Promise<T> {
+
+        const busyIndicator = app.createBusyIndicator({
+            title: url?.toString(),
+            description: `Loading View ${url}`
+        });
+
+        try {
+            const view = await AtomLoader.load<T>(url, app);
+            const vm = getOwnInheritedProperty(view, "viewModel");
+            let params;
+            if ("parameters" in view) {
+                params = (view as any).parameters;
+            }
+            if (!vm) {
+                params = (view as any).parameters ??= {};
+            } else {
+                console.warn("ViewModel is deprecated");
+            }
+            if (title) {
+                (view as any).title = title;
+            }
+            if (params) {
+                params[displayRouteSymbol] = route;
+            }
+            if ((vm || params) && parameters) {
+                for (const key in parameters) {
+                    if (parameters.hasOwnProperty(key)) {
+                        const element = parameters[key];
+                        try {
+                            if (vm) { vm[key] = element; }
+                            if (params) { params[key] = element; }
+                        } catch (e) {
+                            // tslint:disable-next-line: no-console
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+            (view as any).init?.()
+                ?.catch((error) => {
+                    if (!CancelToken.isCancelled(error)) {
+                        // tslint:disable-next-line: no-console
+                        console.error(error);
+                    }
+                });
+            return view;
+        } finally {
+            busyIndicator.dispose();
+        }
+    }
+
+    public static async loadControl<T extends AtomControl>(
+        url: AtomUri,
+        app: App): Promise<T> {
+
+        const busyIndicator = app.createBusyIndicator({
+            title: url?.toString(),
+            description: `Loading View ${url}`
+        });
+
+        try {
+            const view = await AtomLoader.load<T>(url, app);
+            const vm = getOwnInheritedProperty(view, "viewModel");
+            let params;
+            if ("parameters" in view) {
+                params = (view as any).parameters;
+            }
+            if (!vm) {
+                params = (view as any).parameters ??= {};
+            }
+            if (vm || params) {
+                const jsonService = app.get(JsonService);
+                for (const key in url.query) {
+                    if (url.query.hasOwnProperty(key)) {
+                        const element = url.query[key];
+                        if (/^json\:/.test(key)) {
+                            const k = key.split(":")[1];
+                            const v = jsonService.parse(element.toString());
+                            if (vm) { vm[k] = v; }
+                            if (params) { params[k] = v; }
+                            continue;
+                        }
+                        if (/^ref\:/.test(key)) {
+                            const rs = app.get(ReferenceService);
+                            const v = rs.get(element as string).consume();
+                            const keyName = key.split(":", 2)[1];
+                            if (vm) { vm[keyName] = v; }
+                            if (params) { params[keyName] = v; }
+                            continue;
+                        }
+                        try {
+                            if (vm) { vm[key] = element; }
+                            if (params) { params[key] = element; }
+                        } catch (e) {
+                            // tslint:disable-next-line: no-console
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+            (view as any).init?.()
+                ?.catch((error) => {
+                    if (!CancelToken.isCancelled(error)) {
+                        console.error(error);
+                    }
+                });
+            return view;
+        } finally {
+            busyIndicator.dispose();
+        }
+    }
+
+}