@rosoftlab/rdict 1.0.0-alpha-15

package/esm2022/lib/core.mjs

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './models';
+export * from './rsl-material-module';
+export * from './services';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Jvc29mdGxhYi9yZGljdC9zcmMvbGliL2NvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcclxuZXhwb3J0ICogZnJvbSAnLi9yc2wtbWF0ZXJpYWwtbW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcyc7XHJcblxyXG4iXX0=

package/esm2022/lib/models/index.mjs

@@ -0,0 +1,4 @@
+export { Menu } from './menu';
+export { Right } from './right';
+export { User } from './user';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yb3NvZnRsYWIvcmRpY3Qvc3JjL2xpYi9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUM3QixPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFBO0FBQy9CLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxRQUFRLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBNZW51IH0gZnJvbSAnLi9tZW51J1xyXG5leHBvcnQgeyBSaWdodCB9IGZyb20gJy4vcmlnaHQnXHJcbmV4cG9ydCB7IFVzZXIgfSBmcm9tICcuL3VzZXInXHJcbiJdfQ==

package/esm2022/lib/models/menu.mjs

@@ -0,0 +1,60 @@
+import { __decorate, __metadata } from "tslib";
+import { Attribute, BaseModel, BaseModelConfig } from "dist/@rosoftlab/core";
+let Menu = class Menu extends BaseModel {
+};
+__decorate([
+    Attribute({ serializedName: 'id' }),
+    __metadata("design:type", String)
+], Menu.prototype, "id", void 0);
+__decorate([
+    Attribute({ serializedName: 'header' }),
+    __metadata("design:type", String)
+], Menu.prototype, "header", void 0);
+__decorate([
+    Attribute({ serializedName: 'icon' }),
+    __metadata("design:type", String)
+], Menu.prototype, "icon", void 0);
+__decorate([
+    Attribute({ serializedName: 'link' }),
+    __metadata("design:type", String)
+], Menu.prototype, "link", void 0);
+__decorate([
+    Attribute({ serializedName: 'title' }),
+    __metadata("design:type", String)
+], Menu.prototype, "title", void 0);
+__decorate([
+    Attribute({ serializedName: 'sublinks' }),
+    __metadata("design:type", Array)
+], Menu.prototype, "sublinks", void 0);
+__decorate([
+    Attribute({ serializedName: 'target' }),
+    __metadata("design:type", String)
+], Menu.prototype, "target", void 0);
+__decorate([
+    Attribute({ serializedName: 'external' }),
+    __metadata("design:type", Boolean)
+], Menu.prototype, "external", void 0);
+__decorate([
+    Attribute({ serializedName: 'description' }),
+    __metadata("design:type", String)
+], Menu.prototype, "description", void 0);
+__decorate([
+    Attribute({ serializedName: 'order' }),
+    __metadata("design:type", Number)
+], Menu.prototype, "order", void 0);
+__decorate([
+    Attribute({ serializedName: 'translationKey' }),
+    __metadata("design:type", String)
+], Menu.prototype, "translationKey", void 0);
+__decorate([
+    Attribute({ serializedName: 'color' }),
+    __metadata("design:type", String)
+], Menu.prototype, "color", void 0);
+Menu = __decorate([
+    BaseModelConfig({
+        type: 'user',
+        modelEndpointUrl: 'user/menus'
+    })
+], Menu);
+export { Menu };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/right.mjs

@@ -0,0 +1,57 @@
+// import { Attribute, BaseModel, BaseModelConfig } from '@rosoftlab/core';
+import { __decorate, __metadata } from "tslib";
+import { Attribute, BaseModel, BaseModelConfig } from "dist/@rosoftlab/core";
+let Right = class Right extends BaseModel {
+};
+__decorate([
+    Attribute({ serializedName: 'id' }),
+    __metadata("design:type", String)
+], Right.prototype, "id", void 0);
+__decorate([
+    Attribute({ serializedName: 'name' }),
+    __metadata("design:type", String)
+], Right.prototype, "name", void 0);
+__decorate([
+    Attribute({ serializedName: 'rightKey' }),
+    __metadata("design:type", String)
+], Right.prototype, "rightKey", void 0);
+__decorate([
+    Attribute({ serializedName: 'pagePath' }),
+    __metadata("design:type", String)
+], Right.prototype, "pagePath", void 0);
+__decorate([
+    Attribute({ serializedName: 'order' }),
+    __metadata("design:type", Number)
+], Right.prototype, "order", void 0);
+__decorate([
+    Attribute({ serializedName: 'isMenu' }),
+    __metadata("design:type", Boolean)
+], Right.prototype, "isMenu", void 0);
+__decorate([
+    Attribute({ serializedName: 'resourceName' }),
+    __metadata("design:type", String)
+], Right.prototype, "resourceName", void 0);
+__decorate([
+    Attribute({ serializedName: 'parentId' }),
+    __metadata("design:type", String)
+], Right.prototype, "parentId", void 0);
+__decorate([
+    Attribute({ serializedName: 'color' }),
+    __metadata("design:type", String)
+], Right.prototype, "color", void 0);
+__decorate([
+    Attribute({ serializedName: 'defaultRoles' }),
+    __metadata("design:type", String)
+], Right.prototype, "defaultRoles", void 0);
+__decorate([
+    Attribute({ serializedName: 'icon' }),
+    __metadata("design:type", String)
+], Right.prototype, "icon", void 0);
+Right = __decorate([
+    BaseModelConfig({
+        type: 'right',
+        modelEndpointUrl: 'user/rights'
+    })
+], Right);
+export { Right };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/user.mjs

@@ -0,0 +1,30 @@
+import { __decorate, __metadata } from "tslib";
+import { Attribute, BaseModel, BaseModelConfig } from "dist/@rosoftlab/core";
+let User = class User extends BaseModel {
+    get fullName() {
+        return this.firstName + ' ' + this.lastName;
+    }
+};
+__decorate([
+    Attribute({ serializedName: 'id' }),
+    __metadata("design:type", String)
+], User.prototype, "id", void 0);
+__decorate([
+    Attribute({ serializedName: 'firstName' }),
+    __metadata("design:type", String)
+], User.prototype, "firstName", void 0);
+__decorate([
+    Attribute({ serializedName: 'lastName' }),
+    __metadata("design:type", String)
+], User.prototype, "lastName", void 0);
+__decorate([
+    Attribute({ serializedName: 'email' }),
+    __metadata("design:type", String)
+], User.prototype, "email", void 0);
+User = __decorate([
+    BaseModelConfig({
+        type: 'user'
+    })
+], User);
+export { User };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3Jvc29mdGxhYi9yZGljdC9zcmMvbGliL21vZGVscy91c2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxlQUFlLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUt0RSxJQUFNLElBQUksR0FBVixNQUFNLElBQUssU0FBUSxTQUFTO0lBYy9CLElBQUksUUFBUTtRQUNSLE9BQU8sSUFBSSxDQUFDLFNBQVMsR0FBRyxHQUFHLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUNoRCxDQUFDO0NBQ0osQ0FBQTtBQWRZO0lBRFIsU0FBUyxDQUFDLEVBQUUsY0FBYyxFQUFFLElBQUksRUFBRSxDQUFDOztnQ0FDZjtBQUdyQjtJQURDLFNBQVMsQ0FBQyxFQUFFLGNBQWMsRUFBRSxXQUFXLEVBQUUsQ0FBQzs7dUNBQ3hCO0FBR25CO0lBREMsU0FBUyxDQUFDLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxDQUFDOztzQ0FDeEI7QUFHbEI7SUFEQyxTQUFTLENBQUMsRUFBRSxjQUFjLEVBQUUsT0FBTyxFQUFFLENBQUM7O21DQUN4QjtBQVpOLElBQUk7SUFIaEIsZUFBZSxDQUFDO1FBQ2IsSUFBSSxFQUFFLE1BQU07S0FDZixDQUFDO0dBQ1csSUFBSSxDQWlCaEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBdHRyaWJ1dGUsIEJhc2VNb2RlbCwgQmFzZU1vZGVsQ29uZmlnIH0gZnJvbSBcImRpc3QvQHJvc29mdGxhYi9jb3JlXCI7XHJcblxyXG5AQmFzZU1vZGVsQ29uZmlnKHtcclxuICAgIHR5cGU6ICd1c2VyJ1xyXG59KVxyXG5leHBvcnQgY2xhc3MgVXNlciBleHRlbmRzIEJhc2VNb2RlbCB7XHJcblxyXG4gICAgQEF0dHJpYnV0ZSh7IHNlcmlhbGl6ZWROYW1lOiAnaWQnIH0pXHJcbiAgICBvdmVycmlkZSBpZCE6IHN0cmluZztcclxuXHJcbiAgICBAQXR0cmlidXRlKHsgc2VyaWFsaXplZE5hbWU6ICdmaXJzdE5hbWUnIH0pXHJcbiAgICBmaXJzdE5hbWUhOiBzdHJpbmc7XHJcblxyXG4gICAgQEF0dHJpYnV0ZSh7IHNlcmlhbGl6ZWROYW1lOiAnbGFzdE5hbWUnIH0pXHJcbiAgICBsYXN0TmFtZSE6IHN0cmluZztcclxuXHJcbiAgICBAQXR0cmlidXRlKHsgc2VyaWFsaXplZE5hbWU6ICdlbWFpbCcgfSlcclxuICAgIGVtYWlsITogc3RyaW5nO1xyXG5cclxuICAgIGdldCBmdWxsTmFtZSgpOiBzdHJpbmcge1xyXG4gICAgICAgIHJldHVybiB0aGlzLmZpcnN0TmFtZSArICcgJyArIHRoaXMubGFzdE5hbWU7XHJcbiAgICB9XHJcbn1cclxuXHJcbiJdfQ==

package/esm2022/lib/reactive-dictionary.mjs

@@ -0,0 +1,173 @@
+import { BehaviorSubject } from "rxjs";
+export class ReactiveDictionary extends Map {
+    static { this.instance = new Map; }
+    constructor(socketService, authToken) {
+        super();
+        this.changes$ = new BehaviorSubject(null);
+        this.isInitialized = false;
+        this._authToken = null;
+        this._authToken = authToken;
+        this._socketService = socketService;
+        this._socketService.initSocket(authToken);
+        this._socketService.getSetEvent(this);
+    }
+    // Method to get the singleton instance
+    static getInstance(socketService, authToken, instance_key) {
+        if (!instance_key)
+            instance_key = 'root';
+        if (!ReactiveDictionary.instance.has(instance_key)) {
+            ReactiveDictionary.instance.set(instance_key, new ReactiveDictionary(socketService, authToken));
+        }
+        const instance = ReactiveDictionary.instance.get(instance_key);
+        if (!instance) {
+            throw new Error(`No instance found for key: ${instance_key}`); // Handle undefined case
+        }
+        return instance; // Now TypeScript knows 'instance' is not undefined
+    }
+    // str_keys(): string[] {
+    keys() {
+        const excludedKeys = ['__guid', '__type']; // Key to exclude
+        const iterator = super.keys();
+        const filteredIterator = {
+            [Symbol.iterator]: () => ({
+                next: () => {
+                    let result;
+                    // Loop until we find a valid key or run out of keys
+                    do {
+                        result = iterator.next(); // Get the next entry ([key, value])
+                        if (result.done)
+                            return { done: true }; // Stop if done
+                        const key = result.value; // Destructure the entry
+                        const value = super.get(key);
+                        // Check if the key is in excludedKeys or if the value is an object
+                        if (!excludedKeys.includes(key) &&
+                            !(typeof value === 'object' && value !== null)) {
+                            return { value: key, done: false }; // Return the valid key
+                        }
+                    } while (true); // Continue until a valid key is found
+                }
+            })
+        };
+        return filteredIterator;
+    }
+    // Asynchronous method to get a value by key
+    async asyncGet(key) {
+        // console.log('Get key: ', key);
+        const keys = key.split('.');
+        if (keys.length === 1) {
+            if (this.has(key)) {
+                const value = this.get(key);
+                if (value instanceof ReactiveDictionary) {
+                    return value;
+                }
+                if (typeof value === 'object' && value !== null) {
+                    const dict_type = value['__type'];
+                    // console.log('value type : ', dict_type);
+                    if (dict_type === 'dict' || dict_type === 'lazy') {
+                        const lazyLoadData = await this.lazyLoadSync(this.get('__guid'), key);
+                        // console.log(lazyLoadData)
+                        if (lazyLoadData) {
+                            const dict = new ReactiveDictionary(this._socketService, this._authToken);
+                            await dict.asyncInit(lazyLoadData.data);
+                            this.set(key, dict);
+                            return dict;
+                        }
+                    }
+                }
+                return value;
+            }
+        }
+        else {
+            const obj = await this.asyncGet(keys[0]);
+            if (obj)
+                return await obj.asyncGet(keys.slice(1).join('.'));
+            else
+                return null;
+        }
+    }
+    // Asynchronous method to set a value by key
+    async asyncSet(key, value, emmit_event = true) {
+        if (emmit_event) {
+            try {
+                await this._socketService.emitSet(this.get('__guid'), key, value);
+            }
+            catch (error) {
+                console.error('Error emitting set event:', error);
+            }
+        }
+        this.set(key, value);
+        this.changes$.next({ key, value });
+    }
+    // Asynchronous method to initialize with a set of key-value pairs
+    async asyncInit(initialData) {
+        if (!this.isInitialized) {
+            try {
+                // If initial data is not provided, fetch it
+                const data = initialData || await this._socketService.getInitialData();
+                // this.known_dicts.set(data.__guid,data);
+                // Set the initial properties on the proxy
+                for (const [key, value] of Object.entries(data)) {
+                    this.set(key, value);
+                }
+                this.isInitialized = true;
+            }
+            catch (error) {
+                console.error('Error during initialization:', error);
+            }
+        }
+    }
+    async lazyLoadSync(guid, prop) {
+        try {
+            const data = await this._socketService.requestLazyLoad(guid, String(prop));
+            return data;
+        }
+        catch (error) {
+            console.error('Error fetching data:', error);
+            throw error;
+        }
+    }
+    getPlainObject() {
+        const plainObject = {};
+        this.forEach((value, key) => {
+            if (value instanceof ReactiveDictionary)
+                plainObject[key] = value.getPlainObject();
+            else
+                plainObject[key] = value; // Add key-value pairs to the plain object
+        });
+        return plainObject; // Return the plain object
+    }
+    async getTable(key) {
+        const data = await this.asyncGet(key); // Get rooms from the ReactiveDictionary
+        if (!data) {
+            return []; // Return an empty array if data is undefined
+        }
+        // Filter and get only entries that are instances of ReactiveDictionary
+        const result = await Promise.all(Array.from(data.entries()).map(async (key) => await data.asyncGet(key[0])) // Get data from asyncGet
+        ) || []; // Return an empty array if the above yields undefined
+        return result.filter((entry) => entry instanceof ReactiveDictionary);
+    }
+    async getTableWithoutGuid(key) {
+        const data = await this.asyncGet(key); // Get rooms from the ReactiveDictionary
+        if (!data) {
+            return []; // Return an empty array if data is undefined
+        }
+        // Filter and get only entries that are instances of ReactiveDictionary
+        const result = await Promise.all(Array.from(data.entries()).map(async (key) => await data.asyncGet(key[0])) // Get data from asyncGet
+        ) || []; // Return an empty array if the above yields undefined
+        var filteredResults = result.filter((entry) => entry instanceof ReactiveDictionary);
+        return filteredResults.map(dictionary => {
+            // Convert Map to object and filter out __guid
+            const filteredObject = {};
+            for (const [key, value] of dictionary.entries()) {
+                if (key !== '__guid') {
+                    filteredObject[key] = value;
+                }
+            }
+            return filteredObject;
+        });
+    }
+    onChanges() {
+        return this.changes$.asObservable();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reactive-dictionary.js","sourceRoot":"","sources":["../../../../../projects/rosoftlab/rdict/src/lib/reactive-dictionary.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable } from \"rxjs\";\nimport { SocketService } from \"./services/socket.service\";\n\nexport class ReactiveDictionary extends Map<string, any> {\n    private static instance: Map<string, ReactiveDictionary> = new Map<string, ReactiveDictionary>;\n    private _socketService: SocketService;\n    private changes$: BehaviorSubject<any> = new BehaviorSubject(null);\n    private isInitialized: boolean = false;\n    private _authToken: string = null;\n    private constructor(socketService: SocketService,\n        authToken: string) {\n        super();\n        this._authToken = authToken;\n        this._socketService = socketService;\n        this._socketService.initSocket(authToken)\n        this._socketService.getSetEvent(this)\n    }\n\n    // Method to get the singleton instance\n    public static getInstance(socketService: SocketService, authToken: string, instance_key?: string): ReactiveDictionary {\n        if (!instance_key)\n            instance_key = 'root'\n        if (!ReactiveDictionary.instance.has(instance_key)) {\n            ReactiveDictionary.instance.set(instance_key, new ReactiveDictionary(socketService, authToken));\n        }\n        const instance = ReactiveDictionary.instance.get(instance_key);\n        if (!instance) {\n            throw new Error(`No instance found for key: ${instance_key}`); // Handle undefined case\n        }\n\n        return instance; // Now TypeScript knows 'instance' is not undefined\n    }\n    // str_keys(): string[] {\n    override keys(): IterableIterator<string> {\n        const excludedKeys = ['__guid', '__type']; // Key to exclude\n        const iterator = super.keys();\n\n        const filteredIterator = {\n            [Symbol.iterator]: () => ({\n                next: () => {\n                    let result;\n\n                    // Loop until we find a valid key or run out of keys\n                    do {\n                        result = iterator.next(); // Get the next entry ([key, value])\n                        if (result.done) return { done: true }; // Stop if done\n\n                        const key = result.value; // Destructure the entry\n                        const value = super.get(key)\n                        // Check if the key is in excludedKeys or if the value is an object\n                        if (\n                            !excludedKeys.includes(key) &&\n                            !(typeof value === 'object' && value !== null)\n                        ) {\n                            return { value: key, done: false }; // Return the valid key\n                        }\n                    } while (true); // Continue until a valid key is found\n                }\n            })\n        };\n\n        return filteredIterator as IterableIterator<string>;\n    }\n    // Asynchronous method to get a value by key\n    async asyncGet(key: string): Promise<any> {\n        // console.log('Get key: ', key);\n        const keys = key.split('.')\n        if (keys.length === 1) {\n            if (this.has(key)) {\n                const value = this.get(key)\n                if (value instanceof ReactiveDictionary) {\n                    return value\n                }\n                if (typeof value === 'object' && value !== null) {\n                    const dict_type = value['__type']\n                    // console.log('value type : ', dict_type);\n                    if (dict_type === 'dict' || dict_type === 'lazy') {\n                        const lazyLoadData = await this.lazyLoadSync(this.get('__guid'), key);\n                        // console.log(lazyLoadData)\n                        if (lazyLoadData) {\n                            const dict = new ReactiveDictionary(this._socketService, this._authToken);\n                            await dict.asyncInit(lazyLoadData.data)\n                            this.set(key, dict)\n                            return dict\n                        }\n                    }\n                }\n                return value\n            }\n        } else {\n            const obj = await this.asyncGet(keys[0]) as ReactiveDictionary\n            if (obj)\n                return await obj.asyncGet(keys.slice(1).join('.'))\n            else\n                return null;\n        }\n    }\n\n    // Asynchronous method to set a value by key\n    async asyncSet(key: string, value: any, emmit_event: boolean = true): Promise<void> {\n        if (emmit_event) {\n            try {\n                await this._socketService.emitSet(this.get('__guid'), key, value);\n            } catch (error) {\n                console.error('Error emitting set event:', error);\n            }\n        }\n        this.set(key, value)\n        this.changes$.next({ key, value });\n    }\n\n    // Asynchronous method to initialize with a set of key-value pairs\n    async asyncInit(initialData?: Record<string, any>) {\n        if (!this.isInitialized) {\n            try {\n                // If initial data is not provided, fetch it\n                const data = initialData || await this._socketService.getInitialData();\n                // this.known_dicts.set(data.__guid,data);\n                // Set the initial properties on the proxy\n                for (const [key, value] of Object.entries(data)) {\n                    this.set(key, value);\n                }\n                this.isInitialized = true\n            } catch (error) {\n                console.error('Error during initialization:', error);\n            }\n        }\n    }\n\n    async lazyLoadSync(guid: string, prop: string | symbol): Promise<any> {\n        try {\n            const data = await this._socketService.requestLazyLoad(guid, String(prop));\n            return data;\n        } catch (error) {\n            console.error('Error fetching data:', error);\n            throw error;\n        }\n    }\n    public getPlainObject(): Record<string, any> {\n        const plainObject: Record<string, any> = {};\n        this.forEach((value, key) => {\n            if (value instanceof ReactiveDictionary)\n                plainObject[key] = value.getPlainObject()\n            else\n                plainObject[key] = value; // Add key-value pairs to the plain object\n        });\n        return plainObject; // Return the plain object\n    }\n    async getTable(key: string): Promise<any[]> {\n        const data = await this.asyncGet(key); // Get rooms from the ReactiveDictionary\n        if (!data) {\n            return []; // Return an empty array if data is undefined\n        }\n\n        // Filter and get only entries that are instances of ReactiveDictionary\n        const result = await Promise.all(Array.from(data.entries()).map(async (key: any) => await data.asyncGet(key[0])) // Get data from asyncGet\n        ) || []; // Return an empty array if the above yields undefined\n\n\n        return result.filter((entry: any) => entry instanceof ReactiveDictionary);\n    }\n    async getTableWithoutGuid(key: string): Promise<any[]> {\n        const data = await this.asyncGet(key); // Get rooms from the ReactiveDictionary\n        if (!data) {\n            return []; // Return an empty array if data is undefined\n        }\n\n        // Filter and get only entries that are instances of ReactiveDictionary\n        const result = await Promise.all(Array.from(data.entries()).map(async (key: any) => await data.asyncGet(key[0])) // Get data from asyncGet\n        ) || []; // Return an empty array if the above yields undefined\n\n\n        var filteredResults = result.filter((entry: any) => entry instanceof ReactiveDictionary);\n\n        return filteredResults.map(dictionary => {\n            // Convert Map to object and filter out __guid\n            const filteredObject = {};\n            for (const [key, value] of dictionary.entries()) {\n                if (key !== '__guid') {\n                    filteredObject[key] = value;\n                }\n            }\n            return filteredObject;\n        });\n    }\n    onChanges(): Observable<any> {\n        return this.changes$.asObservable();\n    }\n}\n"]}

package/esm2022/lib/rsl-material-module.mjs

@@ -0,0 +1,95 @@
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { PortalModule } from '@angular/cdk/portal';
+import { CdkStepperModule } from '@angular/cdk/stepper';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatBadgeModule } from '@angular/material/badge';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatCardModule } from '@angular/material/card';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatNativeDateModule, MatOptionModule, MatRippleModule } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatGridListModule } from '@angular/material/grid-list';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatSortModule } from '@angular/material/sort';
+import { MatStepperModule } from '@angular/material/stepper';
+import { MatTableModule } from '@angular/material/table';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatTreeModule } from '@angular/material/tree';
+import { TranslateModule } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+const COMMON_MODULES = [
+    CommonModule,
+    ReactiveFormsModule,
+    MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule, MatCheckboxModule, MatChipsModule, MatDatepickerModule,
+    MatDialogModule, MatExpansionModule, MatGridListModule, MatIconModule,
+    MatInputModule, MatListModule, MatMenuModule, MatNativeDateModule,
+    MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule, MatRadioModule, MatRippleModule, MatSelectModule, MatSidenavModule,
+    MatSliderModule, MatSlideToggleModule, MatSnackBarModule, MatSortModule, MatTableModule, MatTabsModule, MatToolbarModule,
+    MatTooltipModule, MatOptionModule, DragDropModule, MatDividerModule, PortalModule, MatTreeModule, MatBadgeModule, MatStepperModule,
+    CdkStepperModule
+];
+export class RSLMaterialModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: RSLMaterialModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: RSLMaterialModule, imports: [CommonModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule, MatCheckboxModule, MatChipsModule, MatDatepickerModule,
+            MatDialogModule, MatExpansionModule, MatGridListModule, MatIconModule,
+            MatInputModule, MatListModule, MatMenuModule, MatNativeDateModule,
+            MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule, MatRadioModule, MatRippleModule, MatSelectModule, MatSidenavModule,
+            MatSliderModule, MatSlideToggleModule, MatSnackBarModule, MatSortModule, MatTableModule, MatTabsModule, MatToolbarModule,
+            MatTooltipModule, MatOptionModule, DragDropModule, MatDividerModule, PortalModule, MatTreeModule, MatBadgeModule, MatStepperModule,
+            CdkStepperModule, TranslateModule], exports: [CommonModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule, MatCheckboxModule, MatChipsModule, MatDatepickerModule,
+            MatDialogModule, MatExpansionModule, MatGridListModule, MatIconModule,
+            MatInputModule, MatListModule, MatMenuModule, MatNativeDateModule,
+            MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule, MatRadioModule, MatRippleModule, MatSelectModule, MatSidenavModule,
+            MatSliderModule, MatSlideToggleModule, MatSnackBarModule, MatSortModule, MatTableModule, MatTabsModule, MatToolbarModule,
+            MatTooltipModule, MatOptionModule, DragDropModule, MatDividerModule, PortalModule, MatTreeModule, MatBadgeModule, MatStepperModule,
+            CdkStepperModule, TranslateModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: RSLMaterialModule, imports: [COMMON_MODULES, TranslateModule, CommonModule,
+            ReactiveFormsModule,
+            MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule, MatCheckboxModule, MatChipsModule, MatDatepickerModule,
+            MatDialogModule, MatExpansionModule, MatGridListModule, MatIconModule,
+            MatInputModule, MatListModule, MatMenuModule, MatNativeDateModule,
+            MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule, MatRadioModule, MatRippleModule, MatSelectModule, MatSidenavModule,
+            MatSliderModule, MatSlideToggleModule, MatSnackBarModule, MatSortModule, MatTableModule, MatTabsModule, MatToolbarModule,
+            MatTooltipModule, MatOptionModule, DragDropModule, MatDividerModule, PortalModule, MatTreeModule, MatBadgeModule, MatStepperModule,
+            CdkStepperModule, TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: RSLMaterialModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        ...COMMON_MODULES,
+                        TranslateModule
+                    ],
+                    exports: [
+                        ...COMMON_MODULES,
+                        TranslateModule
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rsl-material-module.js","sourceRoot":"","sources":["../../../../../projects/rosoftlab/rdict/src/lib/rsl-material-module.ts"],"names":[],"mappings":"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","sourcesContent":["import { DragDropModule } from '@angular/cdk/drag-drop';\r\nimport { PortalModule } from '@angular/cdk/portal';\r\nimport { CdkStepperModule } from '@angular/cdk/stepper';\r\nimport { CommonModule } from '@angular/common';\r\nimport { NgModule } from '@angular/core';\r\nimport { ReactiveFormsModule } from '@angular/forms';\r\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\r\nimport { MatBadgeModule } from '@angular/material/badge';\r\nimport { MatButtonModule } from '@angular/material/button';\r\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\r\nimport { MatCardModule } from '@angular/material/card';\r\nimport { MatCheckboxModule } from '@angular/material/checkbox';\r\nimport { MatChipsModule } from '@angular/material/chips';\r\nimport { MatNativeDateModule, MatOptionModule, MatRippleModule } from '@angular/material/core';\r\nimport { MatDatepickerModule } from '@angular/material/datepicker';\r\nimport { MatDialogModule } from '@angular/material/dialog';\r\nimport { MatDividerModule } from '@angular/material/divider';\r\nimport { MatExpansionModule } from '@angular/material/expansion';\r\nimport { MatGridListModule } from '@angular/material/grid-list';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatInputModule } from '@angular/material/input';\r\nimport { MatListModule } from '@angular/material/list';\r\nimport { MatMenuModule } from '@angular/material/menu';\r\nimport { MatPaginatorModule } from '@angular/material/paginator';\r\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\r\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\r\nimport { MatRadioModule } from '@angular/material/radio';\r\nimport { MatSelectModule } from '@angular/material/select';\r\nimport { MatSidenavModule } from '@angular/material/sidenav';\r\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\r\nimport { MatSliderModule } from '@angular/material/slider';\r\nimport { MatSnackBarModule } from '@angular/material/snack-bar';\r\nimport { MatSortModule } from '@angular/material/sort';\r\nimport { MatStepperModule } from '@angular/material/stepper';\r\nimport { MatTableModule } from '@angular/material/table';\r\nimport { MatTabsModule } from '@angular/material/tabs';\r\nimport { MatToolbarModule } from '@angular/material/toolbar';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { MatTreeModule } from '@angular/material/tree';\r\nimport { TranslateModule } from '@ngx-translate/core';\r\n\r\n\r\nconst COMMON_MODULES = [\r\n  CommonModule,\r\n  ReactiveFormsModule,\r\n  MatAutocompleteModule, MatButtonModule, MatButtonToggleModule, MatCardModule, MatCheckboxModule, MatChipsModule, MatDatepickerModule,\r\n  MatDialogModule, MatExpansionModule, MatGridListModule, MatIconModule,\r\n  MatInputModule, MatListModule, MatMenuModule, MatNativeDateModule,\r\n  MatPaginatorModule, MatProgressBarModule, MatProgressSpinnerModule, MatRadioModule, MatRippleModule, MatSelectModule, MatSidenavModule,\r\n  MatSliderModule, MatSlideToggleModule, MatSnackBarModule, MatSortModule, MatTableModule, MatTabsModule, MatToolbarModule,\r\n  MatTooltipModule, MatOptionModule, DragDropModule, MatDividerModule, PortalModule, MatTreeModule, MatBadgeModule, MatStepperModule,\r\n  CdkStepperModule\r\n];\r\n\r\n@NgModule({\r\n  imports: [\r\n    ...COMMON_MODULES,\r\n    TranslateModule\r\n  ],\r\n  exports: [\r\n    ...COMMON_MODULES,\r\n    TranslateModule],\r\n})\r\nexport class RSLMaterialModule {\r\n}\r\n"]}

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,4 @@
+export { SocketService } from './socket.service';
+export { UserService } from './user.service';
+export { WsAuthService } from './ws-auth.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yb3NvZnRsYWIvcmRpY3Qvc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFDaEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBQzVDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFNvY2tldFNlcnZpY2UgfSBmcm9tICcuL3NvY2tldC5zZXJ2aWNlJ1xyXG5leHBvcnQgeyBVc2VyU2VydmljZSB9IGZyb20gJy4vdXNlci5zZXJ2aWNlJ1xyXG5leHBvcnQgeyBXc0F1dGhTZXJ2aWNlIH0gZnJvbSAnLi93cy1hdXRoLnNlcnZpY2UnXHJcbiJdfQ==

package/esm2022/lib/services/socket.service.mjs

@@ -0,0 +1,92 @@
+import { Inject, Injectable } from '@angular/core';
+import { io } from 'socket.io-client';
+import * as msgpackParser from 'socket.io-msgpack-parser';
+import { SOCKET_URL } from '../socket-config.token';
+import * as i0 from "@angular/core";
+export class SocketService {
+    constructor(socketUrl) {
+        this.socketUrl = socketUrl;
+        // Replace with your actual server URL
+        // this.socket.on("connect", () => {
+        //   const engine = this.socket.io.engine;
+        //   (engine.transport.name); // in most cases, prints "polling"
+        //   engine.once("upgrade", () => {
+        //     // called when the transport is upgraded (i.e. from HTTP long-polling to WebSocket)
+        //     (engine.transport.name); // in most cases, prints "websocket"
+        //   });
+        // });
+    }
+    initSocket(authToken) {
+        if (this.socket == null && authToken !== null) {
+            this.socket = io(this.socketUrl, {
+                withCredentials: true,
+                parser: msgpackParser,
+                auth: {
+                    token: authToken, // Include the authentication token
+                },
+                query: {
+                    "access_token": authToken
+                }
+            });
+        }
+    }
+    getInitialData() {
+        return new Promise((resolve, reject) => {
+            this.socket.on('init', (data) => {
+                if (data) {
+                    resolve(data["dict_data"]);
+                }
+                else {
+                    reject('No data received from init event');
+                }
+            });
+        });
+    }
+    getSetEvent(rdict) {
+        this.socket.on('set', (data) => {
+            // (rdict.get('__guid'), data, this.socket.id)
+            if (rdict.get('__guid') === data.did) {
+                // ('Set the data')
+                rdict.asyncSet(data.key, data.value, false);
+            }
+        });
+    }
+    // Emit the 'lazy_load' event with callback to get the response
+    requestLazyLoad(did, key) {
+        return new Promise((resolve, reject) => {
+            this.socket.emit('lazy_load', { did, key }, (response) => {
+                if (response && response.error) {
+                    reject(response.error); // Handle error if present
+                }
+                else {
+                    resolve(response); // Resolve with the response data
+                }
+            });
+        });
+    }
+    // Emit the 'set' event to update the data on the server
+    emitSet(did, key, value) {
+        return new Promise((resolve, reject) => {
+            this.socket.emit('set', { did, key, value }, (response) => {
+                if (response && response.error) {
+                    reject(response.error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SocketService, deps: [{ token: SOCKET_URL }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SOCKET_URL]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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