@dignite-ng/expand.core 0.0.3 → 0.0.6

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

@@ -0,0 +1,84 @@
+import { LocalizationService } from '@abp/ng.core';
+import { ToasterService } from '@abp/ng.theme.shared';
+import { inject, Injectable } from '@angular/core';
+import { FormGroup, FormArray, FormControl, FormBuilder } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class ValidatorsService {
+    constructor() {
+        this.fb = inject(FormBuilder);
+        this.toaster = inject(ToasterService);
+        this._LocalizationService = inject(LocalizationService);
+    }
+    /**检查表单- */
+    isCheckForm(input, module = 'AbpValidation') {
+        let keys = Object.keys(input);
+        for (let i = 0; i < keys.length; i++) {
+            const element = keys[i];
+            if (input[element] == false) {
+                let info = `"${this._LocalizationService.instant(`${module}::${element}`)}" `;
+                if (element.includes('.') && !element.includes('].')) {
+                    let arr = element.split('.');
+                    info = `"${this._LocalizationService.instant(`${module}::${arr[0]}`)}.${this._LocalizationService.instant(`${module}::${arr[1]}`)}"`;
+                }
+                if (element.includes('].')) {
+                    let arr = element.split('].');
+                    let arrStart = arr[0].split('[');
+                    info = `"${this._LocalizationService.instant(`${module}::${arrStart[0]}`)}[${arrStart[1]}].${this._LocalizationService.instant(`${module}::${arr[1]}`)}"`;
+                }
+                info = info + this._LocalizationService.instant(`AbpValidation::ThisFieldIsNotValid.`);
+                //使用abp多语言提示
+                this.toaster.warn(info);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**获取表单所有字段是否通过验证 */
+    getFormValidationStatus(formEntity) {
+        let validationStatus = {};
+        // 递归遍历表单组和表单控件集合
+        const traverseForm = (form, prefix = '') => {
+            if (form instanceof FormGroup) {
+                Object.keys(form.controls).forEach(key => {
+                    const control = form.controls[key];
+                    let displayName = key.charAt(0).toUpperCase() + key.slice(1);
+                    const fullKey = prefix ? `${prefix}.${displayName}` : displayName;
+                    if (control instanceof FormControl) {
+                        validationStatus[fullKey] = control.valid;
+                    }
+                    else if (control instanceof FormArray) {
+                        traverseForm(control, fullKey);
+                    }
+                    else if (control instanceof FormGroup) {
+                        traverseForm(control, fullKey);
+                    }
+                });
+            }
+            else if (form instanceof FormArray) {
+                form.controls.forEach((control, index) => {
+                    const fullKey = prefix ? `${prefix}[${index}]` : `[${index}]`;
+                    if (control instanceof FormControl) {
+                        validationStatus[fullKey] = control.valid;
+                    }
+                    else if (control instanceof FormArray) {
+                        traverseForm(control, fullKey);
+                    }
+                    else if (control instanceof FormGroup) {
+                        traverseForm(control, fullKey);
+                    }
+                });
+            }
+        };
+        traverseForm(formEntity);
+        return validationStatus;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: ValidatorsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: ValidatorsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.5", ngImport: i0, type: ValidatorsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.service.js","sourceRoot":"","sources":["../../../../../projects/core/src/lib/services/validators.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { LocalizationService } from '@abp/ng.core';\r\nimport { ToasterService } from '@abp/ng.theme.shared';\r\nimport { inject, Injectable } from '@angular/core';\r\nimport { FormGroup, FormArray, FormControl, FormBuilder } from '@angular/forms';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ValidatorsService {\r\n  constructor() {}\r\n\r\n  private fb = inject(FormBuilder);\r\n  private toaster = inject(ToasterService);\r\n  private _LocalizationService = inject(LocalizationService);\r\n  \r\n  /**检查表单- */\r\n  isCheckForm(input: any, module = 'AbpValidation') {\r\n    let keys = Object.keys(input);\r\n    for (let i = 0; i < keys.length; i++) {\r\n      const element = keys[i];\r\n      if (input[element] == false) {\r\n        let info = `\"${this._LocalizationService.instant(`${module}::${element}`)}\" `;\r\n        if (element.includes('.') && !element.includes('].')) {\r\n          let arr = element.split('.');\r\n          info = `\"${this._LocalizationService.instant(\r\n            `${module}::${arr[0]}`\r\n          )}.${this._LocalizationService.instant(`${module}::${arr[1]}`)}\"`;\r\n        }\r\n        if (element.includes('].')) {\r\n          let arr = element.split('].');\r\n          let arrStart = arr[0].split('[');\r\n          info = `\"${this._LocalizationService.instant(`${module}::${arrStart[0]}`)}[${\r\n            arrStart[1]\r\n          }].${this._LocalizationService.instant(`${module}::${arr[1]}`)}\"`;\r\n        }\r\n        info =info+ this._LocalizationService.instant(`AbpValidation::ThisFieldIsNotValid.`);\r\n        //使用abp多语言提示\r\n        this.toaster.warn(info);\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**获取表单所有字段是否通过验证 */\r\n  getFormValidationStatus(formEntity: FormGroup | FormArray): { [key: string]: any } {\r\n    let validationStatus: { [key: string]: any } = {};\r\n\r\n    // 递归遍历表单组和表单控件集合\r\n    const traverseForm = (form: FormGroup | FormArray, prefix = '') => {\r\n      if (form instanceof FormGroup) {\r\n        Object.keys(form.controls).forEach(key => {\r\n          const control = form.controls[key];\r\n          let displayName = key.charAt(0).toUpperCase() + key.slice(1);\r\n          const fullKey = prefix ? `${prefix}.${displayName}` : displayName;\r\n          if (control instanceof FormControl) {\r\n            validationStatus[fullKey] = control.valid;\r\n          } else if (control instanceof FormArray) {\r\n            traverseForm(control, fullKey);\r\n          } else if (control instanceof FormGroup) {\r\n            traverseForm(control, fullKey);\r\n          }\r\n        });\r\n      } else if (form instanceof FormArray) {\r\n        form.controls.forEach((control, index) => {\r\n          const fullKey = prefix ? `${prefix}[${index}]` : `[${index}]`;\r\n          if (control instanceof FormControl) {\r\n            validationStatus[fullKey] = control.valid;\r\n          } else if (control instanceof FormArray) {\r\n            traverseForm(control, fullKey);\r\n          } else if (control instanceof FormGroup) {\r\n            traverseForm(control, fullKey);\r\n          }\r\n        });\r\n      }\r\n    };\r\n\r\n    traverseForm(formEntity);\r\n\r\n    return validationStatus;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/strategies/index.mjs

@@ -0,0 +1,2 @@
+export * from './simple-reuse-strategy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvc3RyYXRlZ2llcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zaW1wbGUtcmV1c2Utc3RyYXRlZ3knO1xyXG4iXX0=

package/esm2022/lib/strategies/simple-reuse-strategy.mjs

@@ -0,0 +1,84 @@
+/**
+ * 路由复用策略
+ *
+ * 1. 实现shouldReuseRoute方法，判断是否同一路由时复用路由
+ * 2. 实现retrieve方法，获取存储路由
+ * 3. 实现shouldDetach方法，判断是否有路由存储
+ * 4. 实现store方法，存储路由
+ * 5. 实现shouldAttach方法，判断是否有路由存储
+ * 6. 实现retrieve方法，获取存储路由
+ * 7. 实现destroy方法，销毁路由
+ *
+ * *使用方法
+    @NgModule({
+        providers: [
+            { provide: RouteReuseStrategy, useClass: SimpleReuseStrategy }
+        ],
+    })
+
+    data: { keep: true }
+ */
+export class SimpleReuseStrategy {
+    static { this.cacheRouters = new Map(); }
+    static deleteRouteCache(url) {
+        if (SimpleReuseStrategy.cacheRouters.has(url)) {
+            const handle = SimpleReuseStrategy.cacheRouters.get(url);
+            try {
+                handle.componentRef.destory();
+            }
+            catch (e) { }
+            SimpleReuseStrategy.cacheRouters.delete(url);
+        }
+    }
+    static deleteAllRouteCache() {
+        SimpleReuseStrategy.cacheRouters.forEach((handle, key) => {
+            SimpleReuseStrategy.deleteRouteCache(key);
+        });
+    }
+    // one 进入路由触发，是否同一路由时复用路由
+    shouldReuseRoute(future, curr) {
+        return (future.routeConfig === curr.routeConfig &&
+            JSON.stringify(future.params) === JSON.stringify(curr.params));
+    }
+    // 获取存储路由
+    retrieve(route) {
+        const url = this.getFullRouteURL(route);
+        if (route.data.keep && SimpleReuseStrategy.cacheRouters.has(url)) {
+            return SimpleReuseStrategy.cacheRouters.get(url);
+        }
+        else {
+            return null;
+        }
+    }
+    // Whether to allow multiplexing routes
+    shouldDetach(route) {
+        return Boolean(route.data.keep);
+    }
+    //It is triggered when the route leaves. The route is stored
+    store(route, handle) {
+        const url = this.getFullRouteURL(route);
+        // 先把之前缓存的删除,
+        SimpleReuseStrategy.cacheRouters.forEach((handle, key) => {
+            SimpleReuseStrategy.deleteRouteCache(key);
+        });
+        SimpleReuseStrategy.cacheRouters.set(url, handle);
+    }
+    //  Whether to allow route restoration
+    shouldAttach(route) {
+        const url = this.getFullRouteURL(route);
+        return Boolean(route.data.keep) && SimpleReuseStrategy.cacheRouters.has(url);
+    }
+    // Gets the current route url
+    getFullRouteURL(route) {
+        const { pathFromRoot } = route;
+        let fullRouteUrlPath = [];
+        pathFromRoot.forEach((item) => {
+            fullRouteUrlPath = fullRouteUrlPath.concat(this.getRouteUrlPath(item));
+        });
+        return `/${fullRouteUrlPath.join('/')}`;
+    }
+    getRouteUrlPath(route) {
+        return route.url.map(urlSegment => urlSegment.path);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-reuse-strategy.js","sourceRoot":"","sources":["../../../../../projects/core/src/lib/strategies/simple-reuse-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["import { RouteReuseStrategy, ActivatedRouteSnapshot, DetachedRouteHandle } from '@angular/router';\r\n/**\r\n * 路由复用策略\r\n * \r\n * 1. 实现shouldReuseRoute方法，判断是否同一路由时复用路由\r\n * 2. 实现retrieve方法，获取存储路由\r\n * 3. 实现shouldDetach方法，判断是否有路由存储\r\n * 4. 实现store方法，存储路由\r\n * 5. 实现shouldAttach方法，判断是否有路由存储\r\n * 6. 实现retrieve方法，获取存储路由\r\n * 7. 实现destroy方法，销毁路由\r\n * \r\n * *使用方法\r\n    @NgModule({\r\n        providers: [\r\n            { provide: RouteReuseStrategy, useClass: SimpleReuseStrategy }\r\n        ],\r\n    })\r\n\r\n    data: { keep: true }\r\n */\r\nexport class SimpleReuseStrategy implements RouteReuseStrategy {\r\n    static cacheRouters = new Map<string, DetachedRouteHandle>();\r\n\r\n    public static deleteRouteCache(url): void {\r\n        if (SimpleReuseStrategy.cacheRouters.has(url)) {\r\n            const handle: any = SimpleReuseStrategy.cacheRouters.get(url);\r\n            try {\r\n                handle.componentRef.destory();\r\n            } catch (e) { }\r\n            SimpleReuseStrategy.cacheRouters.delete(url);\r\n        }\r\n    }\r\n\r\n    public static deleteAllRouteCache(): void {\r\n        SimpleReuseStrategy.cacheRouters.forEach((handle: any, key) => {\r\n            SimpleReuseStrategy.deleteRouteCache(key);\r\n        });\r\n    }\r\n\r\n    // one 进入路由触发，是否同一路由时复用路由\r\n    shouldReuseRoute(future: ActivatedRouteSnapshot, curr: ActivatedRouteSnapshot): boolean {\r\n        return (\r\n            future.routeConfig === curr.routeConfig &&\r\n            JSON.stringify(future.params) === JSON.stringify(curr.params)\r\n        );\r\n    }\r\n\r\n    // 获取存储路由\r\n    retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle {\r\n        const url = this.getFullRouteURL(route);\r\n        if (route.data.keep && SimpleReuseStrategy.cacheRouters.has(url)) {\r\n            return SimpleReuseStrategy.cacheRouters.get(url);\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    // Whether to allow multiplexing routes\r\n    shouldDetach(route: ActivatedRouteSnapshot): boolean {\r\n        return Boolean(route.data.keep);\r\n    }\r\n    //It is triggered when the route leaves. The route is stored\r\n    store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle): void {\r\n        const url = this.getFullRouteURL(route);\r\n        // 先把之前缓存的删除,\r\n        SimpleReuseStrategy.cacheRouters.forEach((handle: any, key) => {\r\n            SimpleReuseStrategy.deleteRouteCache(key);\r\n        });\r\n        SimpleReuseStrategy.cacheRouters.set(url, handle);\r\n    }\r\n    //  Whether to allow route restoration\r\n    shouldAttach(route: ActivatedRouteSnapshot): boolean {\r\n        const url = this.getFullRouteURL(route);\r\n        return Boolean(route.data.keep) && SimpleReuseStrategy.cacheRouters.has(url);\r\n    }\r\n\r\n    // Gets the current route url\r\n    private getFullRouteURL(route: ActivatedRouteSnapshot): string {\r\n        const { pathFromRoot } = route;\r\n        let fullRouteUrlPath: string[] = [];\r\n        pathFromRoot.forEach((item: ActivatedRouteSnapshot) => {\r\n            fullRouteUrlPath = fullRouteUrlPath.concat(this.getRouteUrlPath(item));\r\n        });\r\n        return `/${fullRouteUrlPath.join('/')}`;\r\n    }\r\n    private getRouteUrlPath(route: ActivatedRouteSnapshot) {\r\n        return route.url.map(urlSegment => urlSegment.path);\r\n    }\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -1,8 +1,9 @@
 /*
  * Public API Surface of core
  */
-export * from './lib/core.module';
+export * from './lib/strategies';
 export * from './lib/services';
-export * from './lib/constants';
-export * from './lib/providers';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjb3JlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29yZS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Byb3ZpZGVycyc7Il19
+export * from './lib/pipes';
+export * from './lib/expand';
+export * from './lib/directives';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2NvcmUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjb3JlXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc3RyYXRlZ2llcyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvcGlwZXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9leHBhbmQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzJztcclxuIl19