@social-mail/social-mail-hosted-web 1.2.18 → 1.2.21

package/node_modules/@web-atoms/entity/src/services/Query.ts

@@ -3,6 +3,7 @@ import IPagedList from "../models/IPagedList";
 import type BaseEntityService from "./BaseEntityService";
 import type { ICollection, IListParams, IModel, IPagedListParams, IQueryMethod } from "./BaseEntityService";
 import StringHelper from "./StringHelper";
+import FetchBuilder from "@web-atoms/core/dist/services/FetchBuilder";
 
 export type stepTypes = "Day" | "Month" | "Year" | "Week" | "Hour";
 
@@ -127,6 +128,7 @@ interface IQueryContext {
     traceQuery?: boolean;
     queryFunction?: string;
     args?: any[];
+    entityKey?: string;
     queryProcessor?: "DotNet" | "JavaScript"
 }
 
@@ -303,7 +305,7 @@ export default class Query<T> {
         return r.items;
     }
 
-    public toPagedList(
+    async toPagedList(
         {
             start = 0,
             size = 100,
@@ -313,7 +315,8 @@ export default class Query<T> {
             splitInclude = false,
             cacheSeconds = 0,
             cacheImmutable = cacheSeconds > 0,
-            count = true
+            count = true,
+            expandable
         }: IPagedListParams = {}): Promise<IPagedList<T>> {
         let url;
 
@@ -322,9 +325,13 @@ export default class Query<T> {
             name,
             service,
             queryFunction,
+            entityKey,
             args
         } = this.context;
 
+        // @ts-expect-error
+        using busy = service.createBusyIndicator(hideActivityIndicator);
+
         const trace = traceQuery;
         const methods = JSON.stringify(this.methods);
         const fm = new URLSearchParams();
@@ -342,27 +349,38 @@ export default class Query<T> {
         if (queryFunction) {
             fm.append("function", queryFunction);
             fm.append("args", JSON.stringify(args ?? "[]"));
+            if (entityKey) {
+                fm.append("entityKey", entityKey);
+            }
+        }
+        if (expandable) {
+            fm.append("expandable", "1");
         }
         const encodedMethods = fm.toString();
+        let result;
         if (encodedMethods.length > 1824) {
             if (cacheSeconds > 0) {
                 throw new Error("Generated query too big for caching");
             }
             url = `${service.url}methods/${name}`;
-            return (service as any).postJson({
-                url,
-                cancelToken,
-                body: {
+            result = await FetchBuilder.post(url)
+                .cancelToken(cancelToken)
+                .jsonBody({
                     methods: this.methods,
                     start,
                     size,
                     split: splitInclude,
                     count,
                     trace,
+                    expandable: expandable ? 1 : void 0,
                     function: queryFunction || void 0,
-                    args: queryFunction ? args : void 0
-                }
-            });
+                    args: queryFunction ? args : void 0,
+                    entityKey: entityKey ?? void 0
+                })
+                .asJson();
+            // @ts-expect-error
+            result = service.resultConverter(result);
+            return result;
         }
         if (cacheSeconds > 0) {
             fm.append("cache", cacheSeconds.toString());
@@ -373,12 +391,19 @@ export default class Query<T> {
         } else {
         }
         url  = `${service.url}query/${name}?${fm.toString()}`;
+        result = await FetchBuilder.get(url)
+            .cancelToken(cancelToken)
+            .asJson();
+        // @ts-expect-error
+        return service.resultConverter(result);
         // @ts-ignore
-        return service.getJson({
-            url,
-            cancelToken,
-            hideActivityIndicator
-        });
+        // return service.getJson({
+        //     url,
+        //     cancelToken,
+        //     hideActivityIndicator
+        // });
+
+
     }
 
     protected thenInclude(a): any {

package/node_modules/@web-atoms/entity/src/services/mergeProperties.ts

@@ -121,6 +121,10 @@ export default function mergeProperties(
                 mergeProperties(srcElement, targetElement, path + "." + key, visited, merged);
                 continue;
             }
+            if (targetElement === void 0 && srcElement) {
+                target[key] = srcElement;
+                continue;
+            }
             target[key] = targetElement;
             if (cloneTarget && targetElement !== void 0) {
                 cloneTarget[key] = targetElement;

package/node_modules/@web-atoms/entity/src/tests/schema-test/SchemaTest.test.ts

@@ -0,0 +1,32 @@
+import BaseEntityService, { IModel, Model } from "../../services/BaseEntityService";
+import HttpSession from "../../services/HttpSession";
+import { QueryProcessor } from "../../services/QueryProcessor";
+
+interface IItem {
+    $type: string, name: string, desc: string
+}
+
+const m1: IModel<IItem> = new Model<IItem>(
+    "n1",
+    ["name"],
+    void 0,
+    {
+        keys: [  { name:"name" }],
+        name: "n1",
+        properties: [ { name: "desc"}],
+        relations: [],
+        queries: {
+            run: "run"
+        }
+    }
+);
+
+class EnttiyService extends BaseEntityService {
+
+    public queryProcessor: QueryProcessor;
+
+}
+
+const es = new EnttiyService();
+
+es.query(m1, "run");

package/node_modules/@web-atoms/entity/src/tests/task-manager/TaskManagerTests.ts

@@ -8,7 +8,7 @@ const sleep = (n) => new Promise((r) => setTimeout(r, n));
 export class TestTaskManager extends TaskManager {
 
     public sleep(fx: () => any) {
-        return this.run(async () => {
+        return this.queueRun(async () => {
             fx();
             await sleep(100);    
         })

package/node_modules/@web-atoms/module-loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-atoms/module-loader",
-  "version": "2.1.42",
+  "version": "2.1.85",
   "description": "AMD & SystemJS Module loader for Web Atoms",
   "main": "index.js",
   "scripts": {

package/node_modules/@web-atoms/module-loader/umd/src/AmdLoader.ts

@@ -22,7 +22,9 @@ const promiseDone = Promise.resolve(0);
 
 class AmdLoader {
 
-    public static isMedia = /\.(jpg|jpeg|gif|png|mp4|mp3|css|html|svg|webp|webm)$/i;
+    public static isMedia = /\.(jpg|jpeg|gif|png|mp4|mp3|css|less|scss|html|svg|webp|webm)$/i;
+
+    public static isCss = /\.(css|less|scss)$/i;
 
     public static isJson = /\.json$/i;
 
@@ -100,16 +102,18 @@ class AmdLoader {
     public setup(name: string): void {
         const jsModule: Module = this.get(name);
         // tslint:disable-next-line:ban-types
-        const define: Function = this.define;
-        jsModule.loader = promiseDone;
+        // const define: Function = this.define;
+        // jsModule.loader = promiseDone;
+        // AmdLoader.current = jsModule;
+        // if (define) {
+        //     define();
+        // }
+        // if (jsModule.exportVar) {
+        //     jsModule.exports = AmdLoader.globalVar[jsModule.exportVar];
+        // }
+        // jsModule.isLoaded = true;
+        jsModule.packed = true;
         AmdLoader.current = jsModule;
-        if (define) {
-            define();
-        }
-        if (jsModule.exportVar) {
-            jsModule.exports = AmdLoader.globalVar[jsModule.exportVar];
-        }
-        jsModule.isLoaded = true;
         // this is not possible as
         // dynamically injected module may be pending to be injected
         // jsModule.getExports();
@@ -192,7 +196,7 @@ class AmdLoader {
                     path = path + "/" + name;
                     const i = name.lastIndexOf("/");
                     const fileName = name.substring(i + 1);
-                    if (!/\.(js|jpg|jpeg|gif|png|mp4|mp3|css|html|svg|webp|webm|json)$/i.test(fileName)) {
+                    if (!/\.(js|mjs|jpg|jpeg|gif|png|mp4|mp3|css|less|scss|html|svg|webp|webm|json)$/i.test(fileName)) {
                         path = path + defExt;
                     }
                     // if (defExt && !path.endsWith(defExt)) {
@@ -323,12 +327,7 @@ class AmdLoader {
         if (m) {
             return m;
         }
-        if (module.isResolved) {
-            module.importPromise = Promise.resolve(module.getExports());
-            return module.importPromise;
-        }
-        module.importPromise = this.importAsync(module);
-        return module.importPromise;
+        return module.importPromise ??= module.isResolved ? Promise.resolve(module.getExports()) : this.importAsync(module);
     }
 
     public importNodeModule(module: Module) {
@@ -423,6 +422,48 @@ class AmdLoader {
             return module.loader;
         }
 
+        if (AmdLoader.isCss.test(module.url)) {
+
+            // simply attach CSS to browser
+
+            const m = {
+                get url() {
+                    let mUrl = !module.url.startsWith(module.package.url)
+                    ? (module.package.url + module.url)
+                    : module.url;
+
+                    const [ _, g1 ] = /\.((global|local)[^\.]{0,10})\.(css|less|scss)$/i.exec(mUrl) ?? [] ;
+                    let segment = g1 ?? "local-high";
+                    if (!/^(global|local)/.test(segment)) {
+                        segment = "local-high";
+                    }
+
+                    // install CSS
+                    if(!/\.css$/i.test(mUrl)) {
+                        mUrl += ".css";
+                    }
+
+                    if (!module.packed) {
+                        (window as any).installStyleSheet(mUrl);
+                    }
+
+                    return mUrl;
+                },
+                toString() {
+                    return this.url;
+                }
+            };
+            const e = {
+                __esModule: true,
+                default: m.url
+            };
+            module.exports = e;
+            module.emptyExports = e;
+            module.loader = promiseDone;
+            module.isLoaded = true;
+            return module.loader;
+        }
+
         if (AmdLoader.isMedia.test(module.url)) {
             // in case of packed loader
             // module.package.url isn't set
@@ -448,7 +489,7 @@ class AmdLoader {
         }
         module.loader = new Promise<void>((resolve, reject) => {
 
-            AmdLoader.moduleLoader(module.name, module.url, () => {
+            const script = AmdLoader.moduleLoader(module.name, module.url, () => {
 
                 try {
                     AmdLoader.current = module;
@@ -477,6 +518,8 @@ class AmdLoader {
                 reject(error);
             });
 
+            script[currentModuleSymbol] = module;
+
         });
 
         return module.loader;
@@ -509,6 +552,7 @@ AmdLoader.moduleLoader = (name, url, success, error) => {
     };
     script.onerror = (e) => { error(e); };
     document.body.appendChild(script);
+    return script;
 };
 
 AmdLoader.httpTextLoader = (url, success, error) => {

package/node_modules/@web-atoms/module-loader/umd/src/Define.ts

@@ -62,6 +62,16 @@ var define: IDefine = (
     }
 
     AmdLoader.instance.define = () => {
+
+        if (!AmdLoader.current) {
+            // dynamic loader
+            const amdModule = document.currentScript?.[currentModuleSymbol];
+
+            if (amdModule) {
+                AmdLoader.current = amdModule;
+            }
+        }
+
         const current: Module = AmdLoader.current;
         if (!current) {
             return;

package/node_modules/@web-atoms/module-loader/umd/src/Module.ts

@@ -1,3 +1,5 @@
+const currentModuleSymbol = Symbol("currentModule");
+
 interface IPackage {
     name: string;
     version: string;
@@ -23,6 +25,8 @@ class Module {
 
     public emptyExports: any = {};
 
+    public packed = false;
+
     public dependencyHooks: [(...a: any) => void, () => void];
 
     public resolveHooks: [(... a: any) => void, () => void];
@@ -75,6 +79,8 @@ class Module {
      */
     public resolver: () => Promise<any>;
 
+    public setup: IModuleSetup;
+
     private rID: number = null;
 
     constructor(

package/node_modules/@web-atoms/module-loader/umd/src/System.ts

@@ -1,3 +1,5 @@
+/// <reference path="./Module.ts"/>
+
 interface IContext {
     import(name: string): Promise<any>;
 }
@@ -51,65 +53,115 @@ class System {
         importsOrSetup: string[] | IModuleSetup,
         setup?: IModuleSetup) {
 
-            const instance = AmdLoader.instance;
-            instance.define = () => {
+        const instance = AmdLoader.instance;
 
-            const name = typeof nameOrImports === "string"
-                ? nameOrImports
-                : AmdLoader.current.name;
+        const currentModule: Module = document.currentScript?.[currentModuleSymbol] ?? AmdLoader.current;
 
-            let imports = importsOrSetup as string[];
-            if (arguments.length === 2) {
-                imports = nameOrImports as string[];
-                setup = importsOrSetup as IModuleSetup;
-            }
+        const name = typeof nameOrImports === "string"
+            ? nameOrImports
+            : void 0;
+
+        let imports = importsOrSetup as string[];
+        if (arguments.length === 2) {
+            imports = nameOrImports as string[];
+            setup = importsOrSetup as IModuleSetup;
+        }
 
-            const module = instance.get(name);
-            if (module.isLoaded) {
-                return;
+        const module = name ? instance.get(name) : currentModule;
+
+        if (module.packed) {
+            for(const d of imports) {
+                const absolutePath = module.require.resolve(d);
+                const dm = instance.get(absolutePath);
+                if (/\.(css|less)$/i.test(absolutePath)) {
+                    // we will not add it as a dependency
+                    // ass css/less are packed.
+                    dm.packed = true;
+                }
+                module.dependencies.push(dm);
             }
-            module.dependencies.push(... imports.map((x) => instance.get(module.require.resolve(x))));
-            module.isLoaded = true;
-
-            const postResolve = new Promise<void>((resolve, reject) => {
-                module.factory = () => {
-                    const r = setup((key, value) => {
-                                if (typeof key === "object") {
-                                    merge(module.exports, key);
-                                    return module.exports;
-                                }
-                                module.exports[key] = value;
-                                return value;
-                            }, module);
-
-                    var list = module.dependencies;
-
-                    const { setters } = r;
-                    for (let index = 0; index < list.length; index++) {
-                        const element = list[index];
-                        setters[index](element.getExports());
-                    }
+        } else {
+            for(const d of imports) {
+                const absolutePath = module.require.resolve(d);
+                const dm = instance.get(absolutePath);
+                module.dependencies.push(dm);
+            }
+        }
+        module.isLoaded = true;
 
-                    const rp = r.execute() as any;
-                    if (rp?.then) {
-                        rp.then(resolve, reject);
-                        // rp.catch((error) => {
-                        //     console.error(error);
-                        // });
-                    } else {
-                        resolve();
-                    }
+        if (module.exportVar) {
+            module.exports = AmdLoader.globalVar[module.exportVar];
+        }
 
-                    return module.exports;
-                };
-            });
+        module.setup = setup;
 
-            module.resolver = async () => {
-                await AmdLoader.instance.resolve(module);
-                await postResolve;
+        module.loader = promiseDone;
+
+        const r = module.setup((key, value) => {
+            if (typeof key === "object") {
+                merge(module.exports, key);
+                if (!module.exports.default) {
+                    module.exports.default = module.exports;
+                }
                 return module.exports;
-            };
+            }
+            module.exports[key] = value;
+            return value;
+        }, module);
+
+        module.resolver = async () => {
+
+            const ds = [];
+
+            const { setters } = r;
+            let isCircularDependency;
+            let index = 0;
+            for (const iterator of module.dependencies) {
+
+                const set = setters[index++];
+
+                if (iterator.isResolved) {
+                    set(iterator.getExports());
+                    continue;
+                }
+
+                const setP = this.import(iterator).then(set);
+
+                if (iterator.isDependentOn(module)) {
+                    isCircularDependency = true;
+                    continue;
+                }
+                ds.push(setP);
+            }
+
+            await Promise.all(ds);
+
+            if (isCircularDependency) {
+                await new Promise((resolve) => setTimeout(resolve,1));
+            }
+
+            const rp = r.execute() as any;
+            if (rp?.then) {
+                await rp;
+            }
+            module.isResolved = true;
+            module.getExports();
+            if (module.postExports) {
+                module.postExports();
+            }
+    
+            if (module.dynamicImports) {
+                for (const iterator of module.dynamicImports) {
+                    if (iterator.replacedModule.importPromise) {
+                        continue;
+                    }
+                    await this.import(iterator.replacedModule);
+                }
+            }
+            return module.exports;
         };
+
+        return module;
         
     }
 }

package/node_modules/@web-atoms/module-loader/umd/src/UMDClass.ts

@@ -120,6 +120,10 @@ class UMDClass {
         }
     }
 
+    public installStyleSheet(path: string, imports = {}) {
+        // do nothing...
+    }
+
 }
 
 const UMD: UMDClass = new UMDClass();
@@ -129,3 +133,50 @@ const UMD: UMDClass = new UMDClass();
     globalNS.System = System;
     AmdLoader.instance.registerModule("tslib", setupTSLib());
 })(UMD);
+
+if (window) {
+
+    let first = document.head.firstElementChild;
+
+    const markers = {
+
+    };
+
+    const addMarker = (name) => {
+        const m = document.createElement("meta");
+        m.name = name + "-marker";
+        if (first) {
+            first.insertAdjacentElement("afterend", m);
+        } else {
+            document.head.insertAdjacentElement("afterbegin", m);
+        }
+        first = m;
+        markers[name] = m;
+        return m;
+    }
+
+    addMarker("global-low");
+    addMarker("global");
+    addMarker("global-high");
+    
+    addMarker("local-low");
+    addMarker("local");
+    addMarker("local-high");
+
+
+    (window as any).installStyleSheet = UMD.installStyleSheet = (path, { imports }: { imports? } = {}) => {
+
+        const [ _, g1 ] = /\.((global|local)[^\.]{0,10})\.(css|less|scss)$/i.exec(path) ?? [] ;
+        let segment = g1 ?? "local-high";
+        if (!/^(global|local)/.test(segment)) {
+            segment = "local-high";
+        }
+
+        const marker = (markers[segment] ?? markers["local"]) as HTMLElement;
+
+        const link =  document.createElement("link");
+        link.rel = "stylesheet";
+        link.href = path;
+        marker.insertAdjacentElement("beforebegin", link);
+    }; 
+}

package/node_modules/@web-atoms/module-loader/umd.d.ts

@@ -56,6 +56,7 @@ declare namespace Reflect {
     function deleteMetadata(metadataKey: any, target: any): boolean;
     function deleteMetadata(metadataKey: any, target: any, propertyKey: string | symbol): boolean;
 }
+declare const currentModuleSymbol: unique symbol;
 interface IPackage {
     name: string;
     version: string;
@@ -75,6 +76,7 @@ declare class Module {
     next: Module;
     package: IPackage;
     emptyExports: any;
+    packed: boolean;
     dependencyHooks: [(...a: any) => void, () => void];
     resolveHooks: [(...a: any) => void, () => void];
     dynamicImports: MockType[];
@@ -96,6 +98,7 @@ declare class Module {
     get filename(): string;
     importPromise: Promise<any>;
     resolver: () => Promise<any>;
+    setup: IModuleSetup;
     private rID;
     constructor(name: string, folder?: string);
     import(name: string): Promise<any>;
@@ -108,6 +111,7 @@ declare var md: any;
 declare const promiseDone: Promise<number>;
 declare class AmdLoader {
     static isMedia: RegExp;
+    static isCss: RegExp;
     static isJson: RegExp;
     static globalVar: any;
     static moduleProgress: (name: string, modules: Map<string, Module>, status: "done" | "loading") => void;
@@ -207,5 +211,6 @@ declare class UMDClass {
     load(path: string, designMode?: boolean): Promise<any>;
     hostView(id: string | HTMLElement, path: string, designMode?: boolean): Promise<any>;
     loadView(path: string, designMode?: boolean, appPath?: string): Promise<any>;
+    installStyleSheet(path: string, imports?: {}): void;
 }
 declare const UMD: UMDClass;