ngx-universal-zone 0.0.1

package/fesm2022/ngx-universal-zone.mjs

@@ -0,0 +1,966 @@
+import * as i0 from '@angular/core';
+import { Injectable, makeEnvironmentProviders } from '@angular/core';
+import { Observable, Subject, switchMap, of, forkJoin, defer, delay } from 'rxjs';
+import Dexie from 'dexie';
+import { filter } from 'rxjs/operators';
+import * as i1 from '@angular/router';
+import { PreloadingStrategy } from '@angular/router';
+
+// https://blogs.msdn.microsoft.com/premier_developer/2018/06/17/angular-how-to-simplify-components-with-typescript-inheritance/
+class AppInjector {
+    static setInjector(injector) {
+        AppInjector.injector = injector;
+    }
+    static getInjector() {
+        return AppInjector.injector;
+    }
+}
+
+// @ts-ignore
+class DbServiceConfig {
+}
+var DbServiceType;
+(function (DbServiceType) {
+    DbServiceType[DbServiceType["IndexDd"] = 0] = "IndexDd";
+    DbServiceType[DbServiceType["Sqlite"] = 1] = "Sqlite";
+})(DbServiceType || (DbServiceType = {}));
+class DbService {
+    constructor() {
+        this.dbInitialized$ = new Observable();
+    }
+    get Db() {
+        return;
+    }
+    putLocal(store, data) {
+        // @ts-ignore
+        return;
+    }
+    putLocalRx(store, data) {
+        // @ts-ignore
+        return;
+    }
+    get(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getAll(store, opt) {
+        // @ts-ignore
+        return;
+    }
+    getAllRx(store, opt) {
+        // @ts-ignore
+        return;
+    }
+    remove(store, id) {
+        // @ts-ignore
+        return;
+    }
+    removeRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    removeAll(store) {
+        // @ts-ignore
+        return;
+    }
+    removeAllRx(store) {
+        // @ts-ignore
+        return;
+    }
+    count(store, opts) {
+        // @ts-ignore
+        return;
+    }
+    countRx(store, opts) {
+        // @ts-ignore
+        return;
+    }
+    deleteDb() {
+        // @ts-ignore
+        return;
+    }
+    deleteTable(store) {
+        // @ts-ignore
+        return;
+    }
+}
+
+// @Injectable()
+class DbWebService extends Dexie {
+    constructor(config, schemaService) {
+        super(config.dbName);
+        this.config = config;
+        this.schemaService = schemaService;
+        this.dbInitialized = new Subject();
+        this.dbInitialized$ = this.dbInitialized.asObservable();
+        const schema = {};
+        schemaService.schema.stores.forEach((s) => {
+            let cols = ``;
+            for (let c of s.columns) {
+                cols += `${c.isPrimaryKey ? `++${c.name}` : `,${c.name}`}`;
+            }
+            schema[s.name] = cols;
+        });
+        this.version(1).stores(schema);
+        this.open()
+            .then((d) => {
+            this._db = d;
+            this.dbInitialized.next(d);
+        })
+            .catch((e) => alert(e));
+    }
+    get Db() {
+        return this._db;
+    }
+    putLocal(store, data) {
+        return new Promise(async (resolve, reject) => {
+            const schema = this.schemaService.schema.stores.filter((s) => s.name == store)[0];
+            const key = schema.columns.filter((s) => s.isPrimaryKey)[0];
+            const exist = data[key.name] ? await this.get(store, data[key.name]) : null;
+            if (exist) {
+                //update
+                this.Db
+                    .table(store)
+                    .update(data[key.name], data)
+                    .then((r) => resolve(null), (e) => reject(e));
+            }
+            else {
+                this.Db
+                    .table(store)
+                    .add(data)
+                    .then((r) => resolve(null), (e) => reject(e));
+            }
+        });
+    }
+    putLocalRx(store, data) {
+        return new Observable((observer) => {
+            this.putLocal(store, data).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    get(store, key) {
+        return new Promise((resolve, reject) => {
+            if (!this.Db) {
+                return reject('Database not initialized. Please wait for dbInitialized$ to emit.');
+            }
+            this.Db
+                .table(store)
+                .get(key)
+                .then((r) => {
+                resolve(r);
+            }, (e) => reject(e));
+        });
+    }
+    getRx(store, key) {
+        return new Observable((observer) => {
+            this.get(store, key).then((value) => {
+                observer.next(value);
+                observer.complete();
+            });
+        });
+    }
+    getByFieldName(storeName, fieldName, key) {
+        const filter = {};
+        filter[fieldName] = key;
+        return this.Db.table(storeName).where(filter).toArray();
+    }
+    getAll(store, opt) {
+        return new Promise(async (resolve, reject) => {
+            if (!this.Db) {
+                return reject('Database not initialized. Please wait for dbInitialized$ to emit.');
+            }
+            let table = this.Db.table(store);
+            let collection = table.toCollection();
+            if (opt?.sortBy) {
+                collection = table.orderBy(opt.sortBy);
+            }
+            if (opt?.sortType && opt?.sortType == 'desc') {
+                collection = table.reverse();
+            }
+            // collection = this.Db.table(store).toCollection();
+            if (opt && opt.key && opt.value) {
+                if (!opt.keyRange) {
+                    opt.keyRange = KeyRangeType.equalTo;
+                }
+                switch (opt.keyRange) {
+                    case KeyRangeType.startsWithIgnoreCase:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .startsWithIgnoreCase(opt.value);
+                        break;
+                    case KeyRangeType.equalTo:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .equals(opt.value);
+                        break;
+                    case KeyRangeType.notEqualTo:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .notEqual(opt.value);
+                        break;
+                    case KeyRangeType.equalToIgnoreCase:
+                        collection = this.Db
+                            .table(store)
+                            .where(opt.key)
+                            .equalsIgnoreCase(opt.value);
+                        break;
+                }
+            }
+            if (opt?.pageIndex != null) {
+                collection = collection.offset((opt.pageIndex - 1) * opt.pageSize);
+            }
+            if (opt?.pageSize != null) {
+                collection = collection.limit(opt.pageSize);
+            }
+            // let data!: T;
+            // if(opt?.sortBy) {
+            //   data = <T>await collection.sortBy(opt.sortBy);
+            // } else {
+            //   data = <T>await collection.toArray();
+            // }
+            // if(opt.sortType == 'desc') {
+            //   data = <T>(<any[]>data).reverse();
+            // }
+            const data = await collection.toArray();
+            resolve(data);
+        });
+    }
+    getAllRx(store, opt) {
+        return new Observable((observer) => {
+            this.getAll(store, opt).then((value) => {
+                observer.next(value);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    remove(store, key) {
+        return this.Db.table(store).delete(key);
+    }
+    removeRx(store, key) {
+        return new Observable((observer) => {
+            this.remove(store, key).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    async removeAll(store) {
+        const all = await this.getAll(store);
+        const schema = this.schemaService.schema.stores.filter((s) => s.name == store)[0];
+        const key = schema.columns.filter((s) => s.isPrimaryKey)[0];
+        const promises = [];
+        for (let r of all) {
+            promises.push(this.Db.table(store).delete(key.name));
+        }
+        await Promise.all(promises);
+    }
+    removeAllRx(store) {
+        return this.getAllRx(store).pipe(switchMap((entries) => {
+            const observables = [];
+            for (let entry of entries) {
+                observables.push(this.removeRx(store, entry.id));
+            }
+            if (!observables.length) {
+                return of(null);
+            }
+            return forkJoin(observables);
+        }));
+    }
+    count(store, opts) {
+        if (opts && opts.key) {
+            const pk = this.schemaService.schema.stores
+                .filter((s) => s.name == store)[0]
+                .columns.filter((s) => s.isPrimaryKey)[0];
+            return this.Db.table(store).where(pk.name).equals(opts.key).count();
+        }
+        return this.Db.table(store).count();
+    }
+    countRx(store, opts) {
+        return new Observable((observer) => {
+            this.count(store, opts).then((value) => {
+                observer.next(value);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+    deleteDb() {
+        return new Promise(async (resolve, reject) => {
+            await this.Db.delete();
+            resolve(null);
+        });
+    }
+    deleteTable(store) {
+        return new Observable((observer) => {
+            this.Db.table(store).clear().then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (e) => observer.error(e));
+        });
+    }
+}
+var KeyRangeType;
+(function (KeyRangeType) {
+    KeyRangeType[KeyRangeType["equalToIgnoreCase"] = 1] = "equalToIgnoreCase";
+    KeyRangeType[KeyRangeType["startsWithIgnoreCase"] = 2] = "startsWithIgnoreCase";
+    KeyRangeType[KeyRangeType["equalTo"] = 3] = "equalTo";
+    KeyRangeType[KeyRangeType["notEqualTo"] = 4] = "notEqualTo";
+})(KeyRangeType || (KeyRangeType = {}));
+
+class SchemaService {
+    /**
+     * Represents a SchemaService that manages the database schema.
+     */
+    constructor() {
+        this.schema = {
+            stores: []
+        };
+        this.tables = {};
+        this._config = {};
+    }
+    get config() {
+        return this._config;
+    }
+    init(config) {
+        this._config = config;
+        if (config.schema && config.schema.length) {
+            this.schema.stores = this.config.schema;
+            this.schema.stores.forEach((s) => this.tables[s.name] = s.name);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: SchemaService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class DbSettingConstant {
+    static { this.SETTING = 'setting'; }
+}
+const DbSettingConfig = {
+    schema: {
+        name: DbSettingConstant.SETTING,
+        columns: [
+            {
+                name: 'key',
+                isPrimaryKey: true,
+                type: 'TEXT',
+            },
+            {
+                name: 'value',
+                type: 'TEXT',
+            },
+        ],
+    }
+};
+
+class DbSqliteService {
+    constructor(config, schemaSvc) {
+        this.config = config;
+        this.schemaSvc = schemaSvc;
+        this._isDbInitialized = false;
+        this.dbInitialized = new Subject();
+        this.dbInitialized$ = this.dbInitialized.asObservable();
+        this._dbName = config.dbName;
+        // await this._deleteDatabase();
+        // this._db = CapacitorSQLite;
+        this._db.open({ database: this._dbName }).then(async (response) => {
+            if (response.result) {
+                await this._dbSuccess();
+                this.initializeDb();
+            }
+        }, (e) => {
+            this._dbError(e);
+        });
+    }
+    getAllRx(store, opt) {
+        throw new Error('Method not implemented.');
+    }
+    testDb() {
+        this._db.transaction((tr) => {
+            tr.executeSql('SELECT upper(?) AS upperString', ['Test string'], (tr, rs) => {
+                console.log('Got upperString result: ' + rs.rows.item(0).upperString);
+            });
+        });
+    }
+    initializeDb() {
+        const delay = 50;
+        //workaround: don't proceed unless db is initialized...wait everytime 50ms
+        const _self = this;
+        let timerId = setTimeout(async function request() {
+            if (!_self._isDbInitialized) {
+                //retry
+                timerId = setTimeout(request, delay);
+            }
+            else {
+                //clear timeout
+                clearTimeout(timerId);
+                timerId = null;
+                await _self._prepareTables();
+                // heavy database operations should start from this...
+                _self.dbInitialized.next(_self._db);
+            }
+        }, delay);
+    }
+    get Db() {
+        return this._db;
+    }
+    putLocal(store, data) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `BEGIN TRANSACTION;`;
+            const values = [];
+            const total = await this.count(store);
+            if (total) {
+                //update
+                sql = `UPDATE ${store} SET `;
+                //columns
+                for (let prop in data) {
+                    if (data.hasOwnProperty(prop)) {
+                        sql += `${prop}='${data[prop]}',`;
+                    }
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+            }
+            else {
+                //insert
+                sql = `INSERT INTO ${store} `;
+                //columns
+                sql += `(`;
+                for (let prop in data) {
+                    if (data.hasOwnProperty(prop)) {
+                        sql += `${prop},`;
+                    }
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+                //values
+                sql += ` VALUES (`;
+                for (let prop in data) {
+                    sql += `?,`;
+                    values.push(data[prop]);
+                }
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+            }
+            sql += `COMMIT TRANSACTION;`;
+            const { changes } = await this._db.execute({
+                statements: sql,
+                values: values,
+            });
+            resolve(changes);
+            // this._db.transaction(async (tx) => {
+            //     const res = await this._executeSql<{ rowsAffected, insertId }>(tx, sql, values);
+            //     resolve(res);
+            // }, (error) => reject(error));
+        });
+    }
+    putLocalRx(store, data) {
+        return new Observable((observer) => {
+            this.putLocal(store, data).then((result) => {
+                observer.next(result);
+                observer.complete();
+            });
+        });
+    }
+    get(store, key) {
+        return new Promise(async (resolve, reject) => {
+            //get primary key field form schema
+            const table = this.schemaSvc.schema.stores.filter((s) => s.name === store)[0];
+            const pk = table.columns.filter((c) => c.isPrimaryKey)[0];
+            const pkName = pk.name;
+            let sql = `SELECT * FROM ${store} WHERE ${pkName} = '${key}' LIMIT 1`;
+            try {
+                let data;
+                const { values } = await this._db.query({ statement: sql, values: [] });
+                if (values.length) {
+                    data = values[0];
+                }
+                resolve(data);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    getRx(store, key) {
+        // @ts-ignore
+        return;
+    }
+    getAll(store, opt) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `SELECT * FROM ${store}`;
+            try {
+                let data;
+                const { values } = await this._db.query({ statement: sql, values: [] });
+                resolve(values);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    remove(store, key) {
+        return new Promise((resolve, reject) => {
+            throw 'remove not impleted in db-sql yet';
+        });
+    }
+    removeRx(store, key) {
+        throw 'remove not impleted in db-sql yet';
+    }
+    removeAll(store) {
+        return new Promise((resolve, reject) => {
+            throw 'removeAll not impleted in db-sql yet';
+        });
+    }
+    removeAllRx(store) {
+        throw 'removeAllRx not impleted in db-sql yet';
+    }
+    count(store, opts) {
+        return new Promise(async (resolve, reject) => {
+            let sql = `SELECT count(*) AS total FROM ${store} `;
+            const { values } = await this._db.query({ statement: sql, values: [] });
+            resolve(values);
+        });
+    }
+    countRx(store, opts) {
+        return new Observable((observer) => {
+            this.count(store, opts).then((result) => {
+                observer.next(result);
+                observer.complete();
+            }, (error) => observer.error(error));
+        });
+    }
+    deleteDb() {
+        return this._deleteDatabase();
+    }
+    deleteTable(store) {
+        throw 'deleteTable not impleted in db-sql yet';
+    }
+    _prepareTables() {
+        return new Promise(async (resolve, reject) => {
+            const schemas = this.schemaSvc.schema.stores;
+            const promises = [];
+            for (let schema of schemas) {
+                let sql = `BEGIN TRANSACTION;`;
+                sql += `CREATE TABLE IF NOT EXISTS ${schema.name} `;
+                sql += `(`;
+                for (let col of schema.columns) {
+                    //TODO: for user table, need to fix primary key
+                    // const ikPkTypeNumber = col['type'] == 'INTEGER';
+                    sql += `${col.name}${col.type ? ' ' + col.type : ''}${col['isPrimaryKey'] ? ' PRIMARY KEY' : ''},`;
+                }
+                //remove extra ',' at the end
+                sql = sql.substr(0, sql.length - 1);
+                sql += `)`;
+                sql += `COMMIT TRANSACTION;`;
+                const promise = this._db.execute({ statements: sql });
+                promises.push(promise);
+            }
+            try {
+                await Promise.all(promises);
+                resolve(null);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    _deleteDatabase() {
+        return this._db.deleteDatabase({ database: this._dbName });
+    }
+    _dbSuccess() {
+        this._isDbInitialized = true;
+    }
+    _dbError(err) {
+        alert('Open database ERROR: ' + JSON.stringify(err));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService, deps: [{ token: DbServiceConfig }, { token: SchemaService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: DbSqliteService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: DbServiceConfig }, { type: SchemaService }] });
+
+function dbFactory(schemaSvc) {
+    const dbConfig = schemaSvc.config;
+    switch (dbConfig.dbType) {
+        case DbServiceType.IndexDd:
+            return new DbWebService(dbConfig, schemaSvc);
+        case DbServiceType.Sqlite:
+            return new DbSqliteService(dbConfig, schemaSvc);
+    }
+}
+const provideDb = () => {
+    const providers = [
+        SchemaService,
+        {
+            provide: DbService,
+            useFactory: dbFactory,
+            deps: [SchemaService],
+        }
+    ];
+    return makeEnvironmentProviders(providers);
+};
+
+class AppSettingService {
+    static { this.settingCache = new Map(); }
+    constructor(_dbService, _schemaSvc) {
+        this._dbService = _dbService;
+        this._schemaSvc = _schemaSvc;
+    }
+    get(key) {
+        if (AppSettingService.settingCache.has(key)) {
+            return new Promise((resolve, reject) => {
+                let settingCacheMap = AppSettingService.settingCache.get(key);
+                resolve(settingCacheMap);
+            });
+        }
+        else {
+            return this._dbService
+                .get(this._schemaSvc.tables[DbSettingConstant.SETTING], key)
+                .then((setting) => {
+                if (setting && setting.value) {
+                    AppSettingService.settingCache.set(key, setting.value);
+                    return setting.value;
+                }
+                return null;
+            });
+        }
+    }
+    getRx(key) {
+        return new Observable((obs) => {
+            this.get(key).then((setting) => {
+                obs.next(setting);
+                obs.complete();
+            }, (error) => obs.error(error));
+        });
+    }
+    put(key, values) {
+        return this._dbService
+            .putLocal(this._schemaSvc.tables[DbSettingConstant.SETTING], {
+            key: key,
+            value: values,
+        })
+            .then(() => {
+            AppSettingService.settingCache.set(key, values);
+        });
+    }
+    putRx(key, values) {
+        return new Observable((obs) => {
+            this.put(key, values).then(() => {
+                obs.next();
+                obs.complete();
+            }, (error) => obs.error(error));
+        });
+    }
+    remove(key) {
+        return this._dbService
+            .remove(this._schemaSvc.tables[DbSettingConstant.SETTING], key)
+            .then(() => {
+            AppSettingService.settingCache.delete(key);
+        });
+    }
+    removeRx(key) {
+        return new Observable((obs) => {
+            this.remove(key).then(() => {
+                obs.next();
+                obs.complete();
+            }, (error) => obs.error(error));
+        });
+    }
+    removeCache(key) {
+        AppSettingService.settingCache.delete(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AppSettingService, deps: [{ token: DbService }, { token: SchemaService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AppSettingService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: AppSettingService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: DbService }, { type: SchemaService }] });
+
+class HelperService {
+    constructor() { }
+    deepCopy(obj) {
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (obj instanceof Array) {
+            return obj.reduce((arr, item, i) => {
+                arr[i] = this.deepCopy(item);
+                return arr;
+            }, []);
+        }
+        if (obj instanceof Object) {
+            return Object.keys(obj).reduce((newObj, key) => {
+                newObj[key] = this.deepCopy(obj[key]);
+                return newObj;
+            }, {});
+        }
+    }
+    //https://stackoverflow.com/a/20285053/859968
+    toDataURL(url) {
+        return new Promise((resolve) => {
+            let xhr = new XMLHttpRequest();
+            xhr.onload = function () {
+                const reader = new FileReader();
+                reader.onloadend = function () {
+                    resolve(reader.result);
+                };
+                reader.readAsDataURL(xhr.response);
+            };
+            xhr.open('GET', url);
+            xhr.responseType = 'blob';
+            xhr.send();
+        });
+    }
+    //https://stackoverflow.com/a/2117523/859968
+    generateGuid() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    getRandomNumber() {
+        const random = new Date().getTime() + Math.floor(Math.random() * 1000000);
+        return random;
+    }
+    getRandomColor() {
+        var letters = '0123456789ABCDEF';
+        var color = '#';
+        for (var i = 0; i < 6; i++) {
+            color += letters[Math.floor(Math.random() * 16)];
+        }
+        return color;
+    }
+    getFormValidationErrors(formName) {
+        Object.keys(formName.controls).forEach((key) => {
+            const controlErrors = formName.get(key).errors;
+            if (controlErrors != null) {
+                Object.keys(controlErrors).forEach((keyError) => {
+                    console.log('Key control: ' + key + ', keyError: ' + keyError + ', err value: ', controlErrors[keyError]);
+                });
+            }
+        });
+    }
+    removeFormValidationErrors(formName, controlName, errorKey) {
+        const controlErrors = formName.get(controlName).errors;
+        if (controlErrors != null) {
+            const error = Object.keys(controlErrors).filter((k) => k == errorKey);
+            if (error) {
+                controlErrors[errorKey] = undefined;
+                delete controlErrors[errorKey];
+            }
+        }
+    }
+    downloadCanvasAsImage(canvas) {
+        // const download = document.getElementById("download");
+        const image = canvas
+            .toDataURL('image/png')
+            .replace('image/png', 'image/octet-stream');
+        const link = document.createElement('a');
+        link.setAttribute('href', image);
+        link.download = `${this.generateGuid()}.png`;
+        link.click();
+        // setTimeout(() => {
+        //     link.remove();
+        // });
+    }
+    getParamsObjectsFromUrl(url) {
+        let obj;
+        if (url) {
+            url = decodeURI(url);
+        }
+        let urlArr = url.split(';');
+        if (urlArr.length) {
+            urlArr.shift();
+        }
+        for (const urlItem of urlArr) {
+            if (!obj) {
+                obj = {};
+            }
+            //e.g key = value
+            const urlItemObj = urlItem.split('=');
+            obj[urlItemObj[0]] = urlItemObj[1];
+        }
+        return obj;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: HelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: HelperService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: HelperService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+const provideUniversalZone = () => {
+    const providers = [
+        AppSettingService, HelperService
+    ];
+    return makeEnvironmentProviders(providers);
+};
+
+const EVENT_NAME = 'uz-message-bus';
+class MessageBus {
+    constructor() {
+        this.messageSubject = new Subject();
+        this.event$ = this.messageSubject.asObservable();
+        this.eventHandler = this.handleEvent.bind(this);
+    }
+    dispatch(message) {
+        const event = new CustomEvent(EVENT_NAME, { detail: message });
+        document.dispatchEvent(event);
+    }
+    startListening() {
+        document.addEventListener(EVENT_NAME, this.eventHandler);
+    }
+    stopListening() {
+        document.removeEventListener(EVENT_NAME, this.eventHandler);
+    }
+    handleEvent(customEvent) {
+        this.messageSubject.next(customEvent.detail);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MessageBus, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MessageBus, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: MessageBus, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/naming-convention */
+function props() {
+    return { _as: 'props', _p: undefined };
+}
+const arraysAreNotAllowedMsg = 'arrays are not allowed in action creators';
+const typePropertyIsNotAllowedMsg = 'type property is not allowed in action creators';
+function createMessage(type, config) {
+    if (typeof config === 'function') {
+        return defineType(type, (...args) => ({
+            ...config(...args),
+            type,
+        }));
+    }
+    const as = config ? config._as : 'empty';
+    switch (as) {
+        case 'empty':
+            return defineType(type, () => ({ type }));
+        case 'props':
+            return defineType(type, (propz) => ({
+                ...propz,
+                type,
+            }));
+        default:
+            throw new Error('Unexpected config.');
+    }
+}
+function defineType(type, creator) {
+    return Object.defineProperty(creator, 'type', {
+        value: type,
+        writable: false,
+    }); // Cast added to fix type system.
+}
+function ofMessageType(...allowedTypes) {
+    return filter((action) => allowedTypes.some((typeOrActionCreator) => {
+        if (typeof typeOrActionCreator === 'string') {
+            // Comparing the string to type
+            return typeOrActionCreator === action.type;
+        }
+        // We are filtering by ActionCreator
+        return typeOrActionCreator.type === action.type;
+    }));
+}
+
+function provideTestMessages(getMessages) {
+    return {
+        provide: MessageBus,
+        useFactory: () => ({
+            event$: defer(getMessages),
+        }),
+    };
+}
+
+/** Indicates that the global styling has changed & loaded (Light/Dark) */
+// export const applicationStylesChanged = createMessage('Application styles changed');
+
+class FlagBasedPreloadingStrategy extends PreloadingStrategy {
+    constructor(router) {
+        super();
+        this.router = router;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    preload(route, load) {
+        const preload = route.data?.["preload"];
+        const preloadNextRoutes = this.getCurrentRouteData()?.['preloadNextRoutes'] ?? [];
+        if (preload || preloadNextRoutes.length) {
+            if (preload) {
+                return load();
+            }
+            if (preloadNextRoutes.includes(route.path)) {
+                const delayTime = route.data?.["delay"] ?? 0;
+                return of(null).pipe(delay(delayTime), switchMap(() => this.waitForNetworkIdle()), switchMap(() => {
+                    return load();
+                }));
+            }
+        }
+        return of(null);
+    }
+    getCurrentRouteData() {
+        let route = this.router.routerState.snapshot.root;
+        while (route.firstChild) {
+            route = route.firstChild;
+        }
+        return route.data;
+    }
+    waitForNetworkIdle() {
+        return new Observable((observer) => {
+            if (navigator.connection && navigator.connection.downlink > 0) {
+                observer.next();
+                observer.complete();
+            }
+            else {
+                const onNetworkIdle = () => {
+                    if (navigator.connection.downlink > 0) {
+                        observer.next();
+                        observer.complete();
+                        navigator.connection.removeEventListener('change', onNetworkIdle);
+                    }
+                };
+                navigator.connection.addEventListener('change', onNetworkIdle);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FlagBasedPreloadingStrategy, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FlagBasedPreloadingStrategy, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FlagBasedPreloadingStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1.Router }] });
+
+/*
+ * Public API Surface of ngx-universal-zone
+ */
+//fix: Internal error: failed to get symbol for entrypoint
+// export default {};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppInjector, AppSettingService, EVENT_NAME, FlagBasedPreloadingStrategy, HelperService, MessageBus, arraysAreNotAllowedMsg, createMessage, ofMessageType, props, provideTestMessages, provideUniversalZone, typePropertyIsNotAllowedMsg };
+//# sourceMappingURL=ngx-universal-zone.mjs.map