@dignite-ng/expand.core 0.0.3 → 0.0.5

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