@sumaris-net/ngx-components 18.14.0 → 18.14.2

package/esm2022/src/app/shared/rx-state/rx-state.decorators.mjs

@@ -0,0 +1,217 @@
+import { RxState } from '@rx-angular/state';
+let production = false;
+export function enableRxStateProdMode() {
+    production = true;
+}
+// Utility for decorators
+class DecoratorUtils {
+    static capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    static createMethodName(prefix, propertyKey) {
+        return `${prefix}${this.capitalize(propertyKey)}`;
+    }
+    static createPropertyName(prefix, propertyKey) {
+        return `${prefix}${this.capitalize(propertyKey)}`;
+    }
+    static validateStateProperty(target, stateVarName) {
+        if (!production && stateVarName !== 'this') {
+            return `
+        if (!${stateVarName}) {
+          throw new Error('Missing state! Please add a RxState in class: ' + this.constructor.name);
+        }
+      `;
+        }
+        return '';
+    }
+}
+const STATE_VAR_NAME_KEY = '__stateName';
+const DEFAULT_STATE_VAR_NAME = '_state';
+/**
+ * Decorator to register the RxState property in a component
+ * Must be used once per class hierarchy
+ */
+export function RxStateRegister() {
+    return function (target, key) {
+        if (target[STATE_VAR_NAME_KEY]) {
+            throw new Error(`Cannot define more than one @RxStateRegister() in class hierarchy. Found: ${target[STATE_VAR_NAME_KEY]} and ${key}`);
+        }
+        Object.defineProperty(target, STATE_VAR_NAME_KEY, {
+            value: key,
+            writable: false,
+            enumerable: false,
+            configurable: false,
+        });
+    };
+}
+/**
+ * Decorator for RxState properties with getter/setter access
+ * Creates reactive properties that sync with RxState
+ */
+export function RxStateProperty(statePropertyName, projectValueReducer) {
+    return function (target, key) {
+        // Vérification de type au runtime (optionnelle)
+        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (descriptor && typeof descriptor.value !== 'undefined') {
+            // On peut ajouter ici des vérifications de type runtime si nécessaire
+        }
+        const finalStatePropertyName = statePropertyName || key;
+        const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || DEFAULT_STATE_VAR_NAME;
+        const stateObject = stateVarName ? `this.${stateVarName}` : 'this';
+        // Generate method names
+        const getMethodName = DecoratorUtils.createMethodName('_get', key);
+        const setMethodName = DecoratorUtils.createMethodName('_set', key);
+        const reducerMethodName = DecoratorUtils.createMethodName('_reduce', key);
+        // State validation (only in development)
+        const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);
+        // Create reducer logic
+        const reducerLogic = projectValueReducer ? `(state) => this.${reducerMethodName}(state, value)` : '() => value';
+        // Create dynamic methods using Function constructor for better performance
+        const getter = new Function(`
+      return function ${getMethodName}() {
+        ${stateValidation}
+        return ${stateObject}.get('${finalStatePropertyName}');
+      }
+    `)();
+        const setter = new Function(`
+      return function ${setMethodName}(value) {
+        ${stateValidation}
+        ${stateObject}.set('${finalStatePropertyName}', ${reducerLogic});
+      }
+    `)();
+        // Attach methods to prototype
+        target[getMethodName] = getter;
+        target[setMethodName] = setter;
+        if (projectValueReducer) {
+            target[reducerMethodName] = projectValueReducer;
+        }
+        // Define property with getter/setter
+        Object.defineProperty(target, key, {
+            get: getter,
+            set: setter,
+            enumerable: true,
+            configurable: true,
+        });
+        // Development logging
+        if (!production) {
+            console.debug(`[RxStateProperty] ${target.constructor?.name}.${key} -> state.${finalStatePropertyName}`);
+        }
+    };
+}
+/**
+ * Decorator for RxState observable selectors
+ * Creates observable properties that select from RxState
+ *
+ * ⚠️ IMPORTANT: La propriété décorée DOIT être typée comme Observable<T>
+ *
+ * @example
+ * ```typescript
+ * @RxStateSelect()
+ * protected pmfms$: Observable<IPmfm[]>; // ✅ Correct
+ *
+ * @RxStateSelect()
+ * protected badProperty: boolean; // ❌ TypeScript Error
+ * ```
+ */
+export function RxStateSelect(statePropertyName, opts) {
+    return function (target, key) {
+        // Vérification simple basée sur la convention (optionnelle)
+        if (!production && !key.endsWith('$')) {
+            console.warn(`[RxStateSelect] Convention: Property ${target.constructor?.name}.${key} should end with '$' to indicate it's an Observable`);
+        }
+        // Determine state property name (remove trailing $ if present)
+        const finalStatePropertyName = statePropertyName || key.replace(/\$$/, '');
+        // Determine state object
+        const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || opts?.stateName || DEFAULT_STATE_VAR_NAME;
+        const stateObject = stateVarName ? `this.${stateVarName}` : 'this';
+        // Create cache property name
+        const cachePropertyName = `_${key}`;
+        // Generate method name
+        const getMethodName = DecoratorUtils.createMethodName('_get', key.replace(/\$$/, '') + '$');
+        // Create observable selector logic
+        const observableSelector = finalStatePropertyName === '$'
+            ? `${stateObject}.$`
+            : finalStatePropertyName.includes('.')
+                ? `${stateObject}.select('${finalStatePropertyName.split('.').join("', '")}')`
+                : `${stateObject}.select('${finalStatePropertyName}')`;
+        // State validation
+        const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);
+        // Create getter with caching
+        const getter = new Function(`
+      return function ${getMethodName}() {
+        ${stateValidation}
+        if (!this.${cachePropertyName}) {
+          this.${cachePropertyName} = ${observableSelector};
+        }
+        return this.${cachePropertyName};
+      }
+    `)();
+        // Attach method to prototype
+        target[getMethodName] = getter;
+        // Define property with getter only
+        Object.defineProperty(target, key, {
+            get: getter,
+            enumerable: true,
+            configurable: false,
+        });
+        // Development logging
+        if (!production) {
+            console.debug(`[RxStateSelect] ${target.constructor?.name}.${key} -> ${observableSelector}`);
+        }
+    };
+}
+/**
+ * Utility decorator to create computed observables from state
+ *
+ * ⚠️ IMPORTANT: La propriété décorée DOIT être typée comme Observable<T>
+ */
+export function RxStateComputed(dependencies, computeFn, opts) {
+    return function (target, key) {
+        // Vérification simple basée sur la convention (optionnelle)
+        if (!production && !key.endsWith('$')) {
+            console.warn(`[RxStateComputed] Convention: Property ${target.constructor?.name}.${key} should end with '$' to indicate it's an Observable`);
+        }
+        const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || opts?.stateName || DEFAULT_STATE_VAR_NAME;
+        const stateObject = stateVarName ? `this.${stateVarName}` : 'this';
+        const cachePropertyName = `_${key}`;
+        const getMethodName = DecoratorUtils.createMethodName('_get', key.replace(/\$$/, '') + '$');
+        const computeMethodName = DecoratorUtils.createMethodName('_compute', key);
+        const keyCompareMapPropertyName = DecoratorUtils.createPropertyName(`_compareMap`, key);
+        // State validation
+        const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);
+        // Create dependencies array as string for code generation
+        const dependenciesStr = dependencies.map((dep) => `'${dep}'`).join(', ');
+        // Create the compute method as string, for code generation
+        const computeMethodNameStr = computeFn ? `, (slice) => this.${computeMethodName}(slice)` : '';
+        // Create the comparator map function as string, for code generation
+        const keyCompareMapStr = opts?.keyCompareMap ? `, this.${keyCompareMapPropertyName}` : '';
+        // Create getter with caching using RxState's native multi-select + pipe(map())
+        const getter = new Function(`
+      return function ${getMethodName}() {
+        ${stateValidation}
+        if (!this.${cachePropertyName}) {
+          const { map } = require('rxjs/operators');
+          this.${cachePropertyName} = ${stateObject}.select([${dependenciesStr}]${computeMethodNameStr}${keyCompareMapStr});
+        }
+        return this.${cachePropertyName};
+      }
+    `)();
+        // Attach compute method, optional keyCompareMap with unique name, and getter to prototype
+        if (computeFn)
+            target[computeMethodName] = computeFn;
+        if (opts?.keyCompareMap)
+            target[keyCompareMapPropertyName] = opts.keyCompareMap;
+        target[getMethodName] = getter;
+        // Define property with getter only
+        Object.defineProperty(target, key, {
+            get: getter,
+            enumerable: true,
+            configurable: false,
+        });
+        // Development logging
+        if (!production) {
+            console.debug(`[RxStateComputed] ${target.constructor?.name}.${key} -> ${stateObject}.select([${dependenciesStr}]).pipe(map(computeFn))`);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rx-state.decorators.js","sourceRoot":"","sources":["../../../../../../src/app/shared/rx-state/rx-state.decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\nimport { ProjectValueReducer, RxState } from '@rx-angular/state';\n\nlet production = false;\nexport function enableRxStateProdMode() {\n  production = true;\n}\n\ndeclare type Constructor<T = any> = new (...args: any[]) => T;\n\ntype ObservablePropertyDecorator<T> = <K extends PropertyKey>(target: any, propertyKey: K) => void;\n\ntype StatePropertyDecorator<T> = <K extends PropertyKey>(target: any, propertyKey: K) => void;\n\n// Utility for decorators\nclass DecoratorUtils {\n  static capitalize(str: string): string {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n  }\n\n  static createMethodName(prefix: string, propertyKey: string): string {\n    return `${prefix}${this.capitalize(propertyKey)}`;\n  }\n  static createPropertyName(prefix: string, propertyKey: string): string {\n    return `${prefix}${this.capitalize(propertyKey)}`;\n  }\n\n  static validateStateProperty(target: any, stateVarName: string): string {\n    if (!production && stateVarName !== 'this') {\n      return `\n        if (!${stateVarName}) {\n          throw new Error('Missing state! Please add a RxState in class: ' + this.constructor.name);\n        }\n      `;\n    }\n    return '';\n  }\n}\n\nconst STATE_VAR_NAME_KEY = '__stateName';\nconst DEFAULT_STATE_VAR_NAME = '_state';\n\n/**\n * Decorator to register the RxState property in a component\n * Must be used once per class hierarchy\n */\nexport function RxStateRegister(): PropertyDecorator {\n  return function (target: Constructor<any>, key: string) {\n    if (target[STATE_VAR_NAME_KEY]) {\n      throw new Error(`Cannot define more than one @RxStateRegister() in class hierarchy. Found: ${target[STATE_VAR_NAME_KEY]} and ${key}`);\n    }\n\n    Object.defineProperty(target, STATE_VAR_NAME_KEY, {\n      value: key,\n      writable: false,\n      enumerable: false,\n      configurable: false,\n    });\n  };\n}\n\n/**\n * Decorator for RxState properties with getter/setter access\n * Creates reactive properties that sync with RxState\n */\nexport function RxStateProperty<T = any, K extends keyof T = any, V extends T[K] = any>(\n  statePropertyName?: string | K,\n  projectValueReducer?: ProjectValueReducer<T, K, V>\n): StatePropertyDecorator<V> {\n  return function <P extends PropertyKey>(target: any, key: P) {\n    // Vérification de type au runtime (optionnelle)\n    const descriptor = Object.getOwnPropertyDescriptor(target, key);\n    if (descriptor && typeof descriptor.value !== 'undefined') {\n      // On peut ajouter ici des vérifications de type runtime si nécessaire\n    }\n\n    const finalStatePropertyName = (statePropertyName as string) || (key as string);\n    const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || DEFAULT_STATE_VAR_NAME;\n    const stateObject = stateVarName ? `this.${stateVarName}` : 'this';\n\n    // Generate method names\n    const getMethodName = DecoratorUtils.createMethodName('_get', key as string);\n    const setMethodName = DecoratorUtils.createMethodName('_set', key as string);\n    const reducerMethodName = DecoratorUtils.createMethodName('_reduce', key as string);\n\n    // State validation (only in development)\n    const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);\n\n    // Create reducer logic\n    const reducerLogic = projectValueReducer ? `(state) => this.${reducerMethodName}(state, value)` : '() => value';\n\n    // Create dynamic methods using Function constructor for better performance\n    const getter = new Function(`\n      return function ${getMethodName}() {\n        ${stateValidation}\n        return ${stateObject}.get('${finalStatePropertyName}');\n      }\n    `)();\n\n    const setter = new Function(`\n      return function ${setMethodName}(value) {\n        ${stateValidation}\n        ${stateObject}.set('${finalStatePropertyName}', ${reducerLogic});\n      }\n    `)();\n\n    // Attach methods to prototype\n    target[getMethodName] = getter;\n    target[setMethodName] = setter;\n    if (projectValueReducer) {\n      target[reducerMethodName] = projectValueReducer;\n    }\n\n    // Define property with getter/setter\n    Object.defineProperty(target, key, {\n      get: getter,\n      set: setter,\n      enumerable: true,\n      configurable: true,\n    });\n\n    // Development logging\n    if (!production) {\n      console.debug(`[RxStateProperty] ${target.constructor?.name}.${key as string} -> state.${finalStatePropertyName}`);\n    }\n  };\n}\n\n/**\n * Decorator for RxState observable selectors\n * Creates observable properties that select from RxState\n *\n * ⚠️ IMPORTANT: La propriété décorée DOIT être typée comme Observable<T>\n *\n * @example\n * ```typescript\n * @RxStateSelect()\n * protected pmfms$: Observable<IPmfm[]>; // ✅ Correct\n *\n * @RxStateSelect()\n * protected badProperty: boolean; // ❌ TypeScript Error\n * ```\n */\nexport function RxStateSelect<T = any, R = T[keyof T]>(\n  statePropertyName?: string | keyof T | '$',\n  opts?: {\n    stateName?: string;\n  }\n): ObservablePropertyDecorator<Observable<R>> {\n  return function <P extends PropertyKey>(target: any, key: P) {\n    // Vérification simple basée sur la convention (optionnelle)\n    if (!production && !(key as string).endsWith('$')) {\n      console.warn(\n        `[RxStateSelect] Convention: Property ${target.constructor?.name}.${key as string} should end with '$' to indicate it's an Observable`\n      );\n    }\n\n    // Determine state property name (remove trailing $ if present)\n    const finalStatePropertyName = (statePropertyName as string) || (key as string).replace(/\\$$/, '');\n\n    // Determine state object\n    const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || opts?.stateName || DEFAULT_STATE_VAR_NAME;\n    const stateObject = stateVarName ? `this.${stateVarName}` : 'this';\n\n    // Create cache property name\n    const cachePropertyName = `_${key as string}`;\n\n    // Generate method name\n    const getMethodName = DecoratorUtils.createMethodName('_get', (key as string).replace(/\\$$/, '') + '$');\n\n    // Create observable selector logic\n    const observableSelector =\n      finalStatePropertyName === '$'\n        ? `${stateObject}.$`\n        : finalStatePropertyName.includes('.')\n          ? `${stateObject}.select('${finalStatePropertyName.split('.').join(\"', '\")}')`\n          : `${stateObject}.select('${finalStatePropertyName}')`;\n\n    // State validation\n    const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);\n\n    // Create getter with caching\n    const getter = new Function(`\n      return function ${getMethodName}() {\n        ${stateValidation}\n        if (!this.${cachePropertyName}) {\n          this.${cachePropertyName} = ${observableSelector};\n        }\n        return this.${cachePropertyName};\n      }\n    `)();\n\n    // Attach method to prototype\n    target[getMethodName] = getter;\n\n    // Define property with getter only\n    Object.defineProperty(target, key, {\n      get: getter,\n      enumerable: true,\n      configurable: false,\n    });\n\n    // Development logging\n    if (!production) {\n      console.debug(`[RxStateSelect] ${target.constructor?.name}.${key as string} -> ${observableSelector}`);\n    }\n  };\n}\n\n/**\n * Utility decorator to create computed observables from state\n *\n * ⚠️ IMPORTANT: La propriété décorée DOIT être typée comme Observable<T>\n */\nexport function RxStateComputed<T = any, K extends keyof T = any, R = any>(\n  dependencies: K[],\n  computeFn?: (slice: Pick<T, K>) => R,\n  opts?: {\n    stateName?: string;\n    keyCompareMap?: any;\n  }\n): ObservablePropertyDecorator<Observable<R>> {\n  return function <P extends PropertyKey>(target: any, key: P) {\n    // Vérification simple basée sur la convention (optionnelle)\n    if (!production && !(key as string).endsWith('$')) {\n      console.warn(\n        `[RxStateComputed] Convention: Property ${target.constructor?.name}.${key as string} should end with '$' to indicate it's an Observable`\n      );\n    }\n    const stateVarName = target instanceof RxState ? null : target[STATE_VAR_NAME_KEY] || opts?.stateName || DEFAULT_STATE_VAR_NAME;\n    const stateObject = stateVarName ? `this.${stateVarName}` : 'this';\n\n    const cachePropertyName = `_${key as string}`;\n    const getMethodName = DecoratorUtils.createMethodName('_get', (key as string).replace(/\\$$/, '') + '$');\n    const computeMethodName = DecoratorUtils.createMethodName('_compute', key as string);\n    const keyCompareMapPropertyName = DecoratorUtils.createPropertyName(`_compareMap`, key as string);\n\n    // State validation\n    const stateValidation = DecoratorUtils.validateStateProperty(target, stateObject);\n\n    // Create dependencies array as string for code generation\n    const dependenciesStr = dependencies.map((dep) => `'${dep as string}'`).join(', ');\n\n    // Create the compute method as string, for code generation\n    const computeMethodNameStr = computeFn ? `, (slice) => this.${computeMethodName}(slice)` : '';\n\n    // Create the comparator map function as string, for code generation\n    const keyCompareMapStr = opts?.keyCompareMap ? `, this.${keyCompareMapPropertyName}` : '';\n\n    // Create getter with caching using RxState's native multi-select + pipe(map())\n    const getter = new Function(`\n      return function ${getMethodName}() {\n        ${stateValidation}\n        if (!this.${cachePropertyName}) {\n          const { map } = require('rxjs/operators');\n          this.${cachePropertyName} = ${stateObject}.select([${dependenciesStr}]${computeMethodNameStr}${keyCompareMapStr});\n        }\n        return this.${cachePropertyName};\n      }\n    `)();\n\n    // Attach compute method, optional keyCompareMap with unique name, and getter to prototype\n    if (computeFn) target[computeMethodName] = computeFn;\n    if (opts?.keyCompareMap) target[keyCompareMapPropertyName] = opts.keyCompareMap;\n    target[getMethodName] = getter;\n\n    // Define property with getter only\n    Object.defineProperty(target, key, {\n      get: getter,\n      enumerable: true,\n      configurable: false,\n    });\n\n    // Development logging\n    if (!production) {\n      console.debug(\n        `[RxStateComputed] ${target.constructor?.name}.${key as string} -> ${stateObject}.select([${dependenciesStr}]).pipe(map(computeFn))`\n      );\n    }\n  };\n}\n"]}

package/esm2022/src/app/shared/rx-state/rx-state.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { RxFor } from '@rx-angular/template/for';
+import { RxIf } from '@rx-angular/template/if';
+import { RxPush } from '@rx-angular/template/push';
+import { RxLet } from '@rx-angular/template/let';
+import * as i0 from "@angular/core";
+export class RxStateModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RxStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: RxStateModule, imports: [RxPush, RxFor, RxIf, RxLet], exports: [RxPush, RxFor, RxIf, RxLet] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RxStateModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RxStateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [RxPush, RxFor, RxIf, RxLet],
+                    exports: [RxPush, RxFor, RxIf, RxLet],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicngtc3RhdGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zaGFyZWQvcngtc3RhdGUvcngtc3RhdGUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbkQsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQU1qRCxNQUFNLE9BQU8sYUFBYTt3R0FBYixhQUFhO3lHQUFiLGFBQWEsWUFIZCxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxLQUFLLGFBQzFCLE1BQU0sRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEtBQUs7eUdBRXpCLGFBQWE7OzRGQUFiLGFBQWE7a0JBSnpCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxLQUFLLENBQUM7aUJBQ3RDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJ4Rm9yIH0gZnJvbSAnQHJ4LWFuZ3VsYXIvdGVtcGxhdGUvZm9yJztcbmltcG9ydCB7IFJ4SWYgfSBmcm9tICdAcngtYW5ndWxhci90ZW1wbGF0ZS9pZic7XG5pbXBvcnQgeyBSeFB1c2ggfSBmcm9tICdAcngtYW5ndWxhci90ZW1wbGF0ZS9wdXNoJztcbmltcG9ydCB7IFJ4TGV0IH0gZnJvbSAnQHJ4LWFuZ3VsYXIvdGVtcGxhdGUvbGV0JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1J4UHVzaCwgUnhGb3IsIFJ4SWYsIFJ4TGV0XSxcbiAgZXhwb3J0czogW1J4UHVzaCwgUnhGb3IsIFJ4SWYsIFJ4TGV0XSxcbn0pXG5leHBvcnQgY2xhc3MgUnhTdGF0ZU1vZHVsZSB7fVxuIl19

package/esm2022/src/app/shared/rx-state/rx-state.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicngtc3RhdGUudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9yeC1zdGF0ZS9yeC1zdGF0ZS50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5leHBvcnQgdHlwZSBPYnNlcnZlZDxUPiA9IHtcbiAgW0sgaW4ga2V5b2YgVCBhcyBgJHtzdHJpbmcgJiBLfSRgXTogT2JzZXJ2YWJsZTxUW0tdPjtcbn07XG4iXX0=

package/esm2022/src/app/shared/services/entity-service.class.mjs

@@ -0,0 +1,10 @@
+export function mergeLoadResult(res1, res2) {
+    return {
+        data: (res1.data || []).concat(...res2.data),
+        total: (res1.total || res1.data?.length || 0) + (res2.total || res2.data?.length || 0),
+    };
+}
+export function isEntityService(service) {
+    return service && service.load && service.save && service.delete;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/services/job.utils.mjs

@@ -0,0 +1,92 @@
+import { BehaviorSubject, defer } from 'rxjs';
+import { isNil, isNotNil, toNumber } from '../functions';
+// @dynamic
+export class JobUtils {
+    static defers(runnableList, opts) {
+        return runnableList.map((runnable) => JobUtils.defer(runnable, opts));
+    }
+    static defer(runnable, opts) {
+        return defer(() => JobUtils.run(runnable, opts));
+    }
+    static run(runnable, opts) {
+        const progression = new BehaviorSubject(0);
+        runnable({ ...opts, progression })
+            .then(() => {
+            if (opts?.maxProgression)
+                progression.next(opts.maxProgression);
+            progression.complete();
+        })
+            .catch((err) => progression.error(err));
+        return progression;
+    }
+    static async fetchAllPages(loadPageFn, opts) {
+        const maxProgression = toNumber(opts?.maxProgression, 100);
+        const progression = opts?.progression;
+        let total;
+        let pageCount;
+        let progressionStep;
+        let currentPageDataCount;
+        const fetchSize = toNumber(opts?.fetchSize, 1000);
+        if (fetchSize <= 0)
+            throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);
+        let offset = 0;
+        let data = [];
+        do {
+            if (opts && opts.logPrefix)
+                console.debug(`${opts.logPrefix} Fetching page #${offset / fetchSize}...`);
+            // Fetch a page
+            const res = await loadPageFn(offset, fetchSize);
+            // Concat to previous result
+            data = data.concat(res.data);
+            // Compute variables, for next loop
+            currentPageDataCount = (res.data && res.data.length) || 0;
+            offset += currentPageDataCount;
+            // Set total count (only once)
+            if (isNil(total) && isNotNil(res.total)) {
+                total = res.total;
+                // Compute the number of page
+                pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer
+                // Compute step, by dividing maxProgression by number of page
+                if (progression) {
+                    progressionStep = maxProgression / pageCount;
+                    // DEBUG
+                    if (opts && opts.logPrefix)
+                        console.debug(`${opts.logPrefix} {pageCount: ${pageCount}, progress: ${progression.value?.toFixed(2)}, pageProgressStep: ${progressionStep?.toFixed(1)}}`);
+                }
+            }
+            // Increment progression on each iteration (if possible)
+            if (isNotNil(progressionStep)) {
+                progression.next(progression.value + progressionStep);
+            }
+            if (opts?.onPageLoaded)
+                opts.onPageLoaded(res);
+        } while (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && offset < total)));
+        // Complete progression to reach progressionStep value (because of round)
+        if (isNotNil(progressionStep)) {
+            // If total return by loadAll was bad !
+            if (isNotNil(total) && data.length < total) {
+                console.warn(`A function loadAll() returned a bad total (less than all page's data)! Expected ${total} but fetch ${data.length}`);
+                total = data.length;
+                pageCount = Math.round(data.length / fetchSize + 0.5);
+            }
+            // Compute final increment, using the real page count
+            progressionStep = Math.max(0, maxProgression - progressionStep * pageCount);
+        }
+        // Or increment once (e.g. when total is not known, in received LoadResult)
+        else if (progression) {
+            progressionStep = maxProgression;
+        }
+        // DEBUG
+        if (opts && opts.logPrefix)
+            console.debug(`${opts.logPrefix} All pages fetched - {progress: ${progression.value?.toFixed(2)}, lastProgressStep: ${progressionStep?.toFixed(1)}`);
+        // Final increment
+        if (progression && progressionStep > 0) {
+            progression.next(progression.value + progressionStep);
+        }
+        return {
+            data,
+            total,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/services/job.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,EAAc,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAUzD,WAAW;AACX,MAAM,OAAO,QAAQ;IACnB,MAAM,CAAC,MAAM,CAA2C,YAA4C,EAAE,IAAQ;QAC5G,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;IACxE,CAAC;IAED,MAAM,CAAC,KAAK,CAA2C,QAAsC,EAAE,IAAQ;QACrG,OAAO,KAAK,CAAqB,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,CAAC,GAAG,CAA2C,QAAsC,EAAE,IAAO;QAClG,MAAM,WAAW,GAAG,IAAI,eAAe,CAAS,CAAC,CAAC,CAAC;QACnD,QAAQ,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,CAAC;aAC/B,IAAI,CAAC,GAAG,EAAE;YACT,IAAI,IAAI,EAAE,cAAc;gBAAE,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAChE,WAAW,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1C,OAAO,WAAW,CAAC;IACrB,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,aAAa,CACxB,UAAiC,EACjC,IAMC;QAED,MAAM,cAAc,GAAG,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,CAAC,CAAC;QAC3D,MAAM,WAAW,GAAG,IAAI,EAAE,WAAW,CAAC;QACtC,IAAI,KAAK,CAAC;QACV,IAAI,SAAS,CAAC;QACd,IAAI,eAAe,CAAC;QACpB,IAAI,oBAA4B,CAAC;QACjC,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;QAClD,IAAI,SAAS,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,GAAG,SAAS,CAAC,CAAC;QAC9F,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,IAAI,IAAI,GAAQ,EAAE,CAAC;QACnB,GAAG,CAAC;YACF,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS;gBAAE,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,mBAAmB,MAAM,GAAG,SAAS,KAAK,CAAC,CAAC;YAEvG,eAAe;YACf,MAAM,GAAG,GAAG,MAAM,UAAU,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YAEhD,4BAA4B;YAC5B,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAE7B,mCAAmC;YACnC,oBAAoB,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC1D,MAAM,IAAI,oBAAoB,CAAC;YAE/B,8BAA8B;YAC9B,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBACxC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;gBAClB,6BAA6B;gBAC7B,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,2BAA2B;gBAChF,6DAA6D;gBAC7D,IAAI,WAAW,EAAE,CAAC;oBAChB,eAAe,GAAG,cAAc,GAAG,SAAS,CAAC;oBAC7C,QAAQ;oBACR,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS;wBACxB,OAAO,CAAC,KAAK,CACX,GAAG,IAAI,CAAC,SAAS,gBAAgB,SAAS,eAAe,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,uBAAuB,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAC5I,CAAC;gBACN,CAAC;YACH,CAAC;YAED,wDAAwD;YACxD,IAAI,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;gBAC9B,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,eAAe,CAAC,CAAC;YACxD,CAAC;YAED,IAAI,IAAI,EAAE,YAAY;gBAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC,QAAQ,oBAAoB,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,oBAAoB,KAAK,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC,EAAE;QAEpI,yEAAyE;QACzE,IAAI,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;YAC9B,uCAAuC;YACvC,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,KAAK,EAAE,CAAC;gBAC3C,OAAO,CAAC,IAAI,CAAC,mFAAmF,KAAK,cAAc,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;gBAClI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;gBACpB,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,SAAS,GAAG,GAAG,CAAC,CAAC;YACxD,CAAC;YAED,qDAAqD;YACrD,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,cAAc,GAAG,eAAe,GAAG,SAAS,CAAC,CAAC;QAC9E,CAAC;QAED,2EAA2E;aACtE,IAAI,WAAW,EAAE,CAAC;YACrB,eAAe,GAAG,cAAc,CAAC;QACnC,CAAC;QAED,QAAQ;QACR,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS;YACxB,OAAO,CAAC,KAAK,CACX,GAAG,IAAI,CAAC,SAAS,mCAAmC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,uBAAuB,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CACtI,CAAC;QAEJ,kBAAkB;QAClB,IAAI,WAAW,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;YACvC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,GAAG,eAAe,CAAC,CAAC;QACxD,CAAC;QAED,OAAO;YACL,IAAI;YACJ,KAAK;SACN,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { BehaviorSubject, defer, Observable } from 'rxjs';\nimport { isNil, isNotNil, toNumber } from '../functions';\nimport { LoadResult, LoadResultByPageFn } from './entity-service.class';\n\nexport type CallableWithProgressionFn<O extends CallableWithProgressionOptions> = (opts?: O) => Promise<any>;\nexport interface CallableWithProgressionOptions {\n  maxProgression?: number;\n  progression?: BehaviorSubject<number>;\n  [key: string]: any;\n}\n\n// @dynamic\nexport class JobUtils {\n  static defers<O extends CallableWithProgressionOptions>(runnableList: CallableWithProgressionFn<O>[], opts?: O): Observable<number>[] {\n    return runnableList.map((runnable) => JobUtils.defer(runnable, opts));\n  }\n\n  static defer<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts?: O): Observable<number> {\n    return defer<Observable<number>>(() => JobUtils.run(runnable, opts));\n  }\n\n  static run<O extends CallableWithProgressionOptions>(runnable: CallableWithProgressionFn<O>, opts: O): Observable<number> {\n    const progression = new BehaviorSubject<number>(0);\n    runnable({ ...opts, progression })\n      .then(() => {\n        if (opts?.maxProgression) progression.next(opts.maxProgression);\n        progression.complete();\n      })\n      .catch((err) => progression.error(err));\n    return progression;\n  }\n\n  static async fetchAllPages<T>(\n    loadPageFn: LoadResultByPageFn<T>,\n    opts?: {\n      progression?: BehaviorSubject<number>;\n      maxProgression?: number;\n      onPageLoaded?: (pageResult: LoadResult<T>) => any;\n      logPrefix?: string;\n      fetchSize?: number;\n    }\n  ): Promise<LoadResult<T>> {\n    const maxProgression = toNumber(opts?.maxProgression, 100);\n    const progression = opts?.progression;\n    let total;\n    let pageCount;\n    let progressionStep;\n    let currentPageDataCount: number;\n    const fetchSize = toNumber(opts?.fetchSize, 1000);\n    if (fetchSize <= 0) throw new Error('Unable to fetch pages: invalid fetchSize: ' + fetchSize);\n    let offset = 0;\n    let data: T[] = [];\n    do {\n      if (opts && opts.logPrefix) console.debug(`${opts.logPrefix} Fetching page #${offset / fetchSize}...`);\n\n      // Fetch a page\n      const res = await loadPageFn(offset, fetchSize);\n\n      // Concat to previous result\n      data = data.concat(res.data);\n\n      // Compute variables, for next loop\n      currentPageDataCount = (res.data && res.data.length) || 0;\n      offset += currentPageDataCount;\n\n      // Set total count (only once)\n      if (isNil(total) && isNotNil(res.total)) {\n        total = res.total;\n        // Compute the number of page\n        pageCount = Math.round(res.total / fetchSize + 0.5); // Round to HALF_UP integer\n        // Compute step, by dividing maxProgression by number of page\n        if (progression) {\n          progressionStep = maxProgression / pageCount;\n          // DEBUG\n          if (opts && opts.logPrefix)\n            console.debug(\n              `${opts.logPrefix} {pageCount: ${pageCount}, progress: ${progression.value?.toFixed(2)}, pageProgressStep: ${progressionStep?.toFixed(1)}}`\n            );\n        }\n      }\n\n      // Increment progression on each iteration (if possible)\n      if (isNotNil(progressionStep)) {\n        progression.next(progression.value + progressionStep);\n      }\n\n      if (opts?.onPageLoaded) opts.onPageLoaded(res);\n    } while (currentPageDataCount > 0 && ((isNil(total) && currentPageDataCount === fetchSize) || (isNotNil(total) && offset < total)));\n\n    // Complete progression to reach progressionStep value (because of round)\n    if (isNotNil(progressionStep)) {\n      // If total return by loadAll was bad !\n      if (isNotNil(total) && data.length < total) {\n        console.warn(`A function loadAll() returned a bad total (less than all page's data)! Expected ${total} but fetch ${data.length}`);\n        total = data.length;\n        pageCount = Math.round(data.length / fetchSize + 0.5);\n      }\n\n      // Compute final increment, using the real page count\n      progressionStep = Math.max(0, maxProgression - progressionStep * pageCount);\n    }\n\n    // Or increment once (e.g. when total is not known, in received LoadResult)\n    else if (progression) {\n      progressionStep = maxProgression;\n    }\n\n    // DEBUG\n    if (opts && opts.logPrefix)\n      console.debug(\n        `${opts.logPrefix} All pages fetched - {progress: ${progression.value?.toFixed(2)}, lastProgressStep: ${progressionStep?.toFixed(1)}`\n      );\n\n    // Final increment\n    if (progression && progressionStep > 0) {\n      progression.next(progression.value + progressionStep);\n    }\n\n    return {\n      data,\n      total,\n    };\n  }\n}\n"]}