@coolon/angular-ui-powerups 12.4.0-alpha.0 → 12.4.0-alpha.1

package/fesm2015/coolon-angular-ui-powerups.js

@@ -5979,234 +5979,6 @@ __decorate([
     PlaceComponent.injectDefinition = injectDefinition;
 })(PlaceComponent || (PlaceComponent = {}));
 
-/**
- * This a work around for the fact that an activated route with multiple segments doesn't
- * include the segment params in the paramMap as well as each segment returns an empty
- * param map even when `parameter`s has content.
- */
-class ConsolidatedParameterMap {
-    constructor(urlSegments, paramMap) {
-        this.paramMaps = [];
-        // TODO: can we get all our params from teh url segments? If so we can drop the paramMap altogether.
-        const segmentParams = (urlSegments || []).map(s => new ParamMapAdapter(s.parameters));
-        this.paramMaps = segmentParams
-            .concat(paramMap)
-            .filter(m => !!m); // the activated route param map can be null
-    }
-    get(name) {
-        const paramMap = this.paramMaps.find(m => m.has(name));
-        return paramMap.get(name);
-    }
-    getAll(name) {
-        const paramMap = this.paramMaps.find(m => m.has(name));
-        return paramMap.getAll(name);
-    }
-    has(name) {
-        return !!this.paramMaps.find(m => m.has(name));
-    }
-    get keys() {
-        return this.paramMaps.reduce((result, params) => result.concat(params.keys), []);
-    }
-}
-__decorate([
-    Memoize(),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], ConsolidatedParameterMap.prototype, "keys", null);
-class ParamMapAdapter {
-    constructor(params) {
-        this.params = params;
-    }
-    get(name) {
-        return this.params[name];
-    }
-    getAll(name) {
-        const value = this.get(name);
-        return Array.isArray(value) ? value : [value];
-    }
-    has(name) {
-        return this.keys.includes(name);
-    }
-    get keys() {
-        return Object.keys(this.params);
-    }
-}
-
-class Visit {
-    constructor(placeDefinition, visitParameters = {}) {
-        this.placeDefinition = placeDefinition;
-        this.visitParameters = visitParameters;
-    }
-    // @Trace()
-    getRouteId() {
-        return this.placeDefinition.getRouteIdFrom(this);
-    }
-    // @Trace()
-    hasRouteId() {
-        return !_.isNil(this.getRouteId());
-    }
-    /**
-     * Returns the value of the place parameter with the specified name.  The parameter
-     * name is taken from the `as` option, e.g. {as: 'aCustomName'} otherwise it is the
-     * same as the the ValueModel property name.
-     * @param parameterDef the visit parameter definition
-     */
-    getParameterValue(parameterDef) {
-        return this.visitParameters[parameterDef.name];
-    }
-    // @Trace()
-    hasParameter(parameterDef) {
-        return Object.keys(this.visitParameters).includes(parameterDef.name);
-    }
-    replace(parameter, value) {
-        return new Visit(this.placeDefinition, Object.assign(Object.assign({}, this.visitParameters), { [parameter.name]: value }));
-    }
-    mergeRouteParameters(routeParams) {
-        // todo: whitelist parameters.
-        const routeParameterKeys = Object.keys(routeParams);
-        const params = {};
-        this.placeDefinition.getVisitParameterDefs().forEach(def => {
-            if (def.isRouteId || def.isRouteParameter) {
-                if (routeParameterKeys.includes(def.name)) {
-                    params[def.name] = routeParams[def.name];
-                }
-            }
-            else {
-                // copy non route params as is, but only if they already exist otherwise we'll inject nil values and break the
-                // defaults and remember sanitisation process.
-                const value = this.getParameterValue(def);
-                if (this.hasParameter(def)) {
-                    params[def.name] = value;
-                }
-            }
-        });
-        return new Visit(this.placeDefinition, params);
-    }
-    hasRoutingChangedFrom(other) {
-        const samePlace = other.placeDefinition === this.placeDefinition;
-        const sameRouteParameters = _.isEqual(this.placeDefinition.getFormattedRouteParameters(this, true), this.placeDefinition.getFormattedRouteParameters(other, true));
-        return !samePlace || !sameRouteParameters;
-    }
-    hasChangedFrom(other) {
-        const sameNonRouteParameters = _.isEqual(this.placeDefinition.getNonRouteParameters(this), this.placeDefinition.getNonRouteParameters(other));
-        return !sameNonRouteParameters || this.hasRoutingChangedFrom(other);
-    }
-    toDebugString() {
-        return Object.keys(this.visitParameters).map(k => `${k}=${this.visitParameters[k]}`).join(',');
-    }
-}
-
-function extractPrimarySegments(urlTree) {
-    return urlTree.root.children.primary.segments;
-}
-class UrlSnapshot {
-    // TODO: Update this accept a url Parser so it can be immutable and generate new trees on mutation using toString() are parseUrl.
-    constructor(urlSerializer, url) {
-        this.urlSerializer = urlSerializer;
-        this.url = url;
-        this.urlTree = urlSerializer.parse(url);
-    }
-    updateVisitSegments(visit) {
-        const newUrlTree = this.urlSerializer.parse(this.url);
-        // Ugly, but it works for now.
-        const segments = [...extractPrimarySegments(newUrlTree)];
-        const visitSegments = this.getSegmentsFor(visit);
-        const replaceAt = segments.findIndex(segment => segment.path === visitSegments[0].path);
-        // do not use the return value, it's the items that were removed!
-        segments.splice(replaceAt, visitSegments.length, ...visitSegments);
-        newUrlTree.root.children.primary.segments = segments;
-        return new UrlSnapshot(this.urlSerializer, newUrlTree.toString());
-    }
-    getPrimarySegments() {
-        return extractPrimarySegments(this.urlTree);
-    }
-    /**
-     * Converts the visit into segments.  Please not that these segments are not e
-     * @param visit
-     */
-    getSegmentsFor(visit) {
-        return visit.placeDefinition.hasRouteId() ?
-            [
-                // NOTE:
-                // It's important to attach the params to the root path and not the id.  If we attach them
-                // to an empty id then the angular router won't match the pattern.
-                new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit)),
-                new UrlSegment(visit.placeDefinition.getFormattedRouteId(visit), {})
-            ]
-            :
-                [
-                    new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit))
-                ];
-    }
-    includesPathOf(placeDef) {
-        return this.getPrimarySegments().find(s => s.path === placeDef.path);
-    }
-    createVisitFor(placeDef) {
-        return new Visit(placeDef, new ConsolidatedParameterMap(this.getPrimarySegments()));
-    }
-    getInteractionIds() {
-        const queryParam = this.urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM];
-        if (queryParam) {
-            return UrlSnapshot.parseInteractionIds(queryParam);
-        }
-        else {
-            return [];
-        }
-    }
-    hasInteractions() {
-        return this.getInteractionIds().length > 0;
-    }
-    hasInteractionIds(ids) {
-        return ___default.isEqual(this.getInteractionIds(), ids);
-    }
-    // @Trace()
-    updateInteractionIds(ids) {
-        if (ids.length === 0) {
-            return this.removeInteractionIds();
-        }
-        else {
-            const urlTree = this.urlSerializer.parse(this.url);
-            urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM] = UrlSnapshot.createPathIdFor(ids);
-            return new UrlSnapshot(this.urlSerializer, urlTree.toString());
-        }
-    }
-    // @Trace()
-    removeInteractionIds() {
-        const urlTree = this.urlSerializer.parse(this.url);
-        if (urlTree.queryParams && urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM]) {
-            urlTree.queryParams = {}; //[UrlSnapshot.INTERACTION_ROUTER_OUTLET]
-        }
-        return new UrlSnapshot(this.urlSerializer, urlTree.toString());
-    }
-    toString() {
-        return `UrlSnapshot(${this.url})`;
-    }
-}
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Visit]),
-    __metadata("design:returntype", UrlSnapshot)
-], UrlSnapshot.prototype, "updateVisitSegments", null);
-__decorate([
-    Memoize(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Array)
-], UrlSnapshot.prototype, "getPrimarySegments", null);
-(function (UrlSnapshot) {
-    UrlSnapshot.INTERACTION_QUERY_PARAM = 'aup-interactions';
-    UrlSnapshot.INTERACTION_ID_SEPARATOR = '--';
-    function parseInteractionIds(path) {
-        return path.split(UrlSnapshot.INTERACTION_ID_SEPARATOR);
-    }
-    UrlSnapshot.parseInteractionIds = parseInteractionIds;
-    function createPathIdFor(interactionIds) {
-        return interactionIds.join(UrlSnapshot.INTERACTION_ID_SEPARATOR);
-    }
-    UrlSnapshot.createPathIdFor = createPathIdFor;
-})(UrlSnapshot || (UrlSnapshot = {}));
-
 /**
  * This class handles the logic around canDeactivate for a given router state transition.  It's core responsibilities are:
  * 1. Ensure we only ask the component to deactivate once on a given navigation cycle (since visit sanitisation can result in multiple round trips to through the router.)
@@ -6243,6 +6015,7 @@ class PlaceComponentDeactivationHandler {
             return this.canDeactivatePromise;
         });
     }
+    // @Trace()
     canDeactivateComponent(currentUrl, nextState) {
         return __awaiter(this, void 0, void 0, function* () {
             // Automatically cancel any active activities if the navigation session was triggered by the back button.
@@ -6290,12 +6063,6 @@ class PlaceComponentDeactivationHandler {
         return !nextState.includesPathOf(this.component.placeDefinition);
     }
 }
-__decorate([
-    Trace(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [UrlSnapshot, UrlSnapshot]),
-    __metadata("design:returntype", Promise)
-], PlaceComponentDeactivationHandler.prototype, "canDeactivateComponent", null);
 
 /**
  * Transient states
@@ -7125,6 +6892,234 @@ PlaceHistory.ctorParameters = () => [];
     // }
 })(PlaceHistory || (PlaceHistory = {}));
 
+/**
+ * This a work around for the fact that an activated route with multiple segments doesn't
+ * include the segment params in the paramMap as well as each segment returns an empty
+ * param map even when `parameter`s has content.
+ */
+class ConsolidatedParameterMap {
+    constructor(urlSegments, paramMap) {
+        this.paramMaps = [];
+        // TODO: can we get all our params from teh url segments? If so we can drop the paramMap altogether.
+        const segmentParams = (urlSegments || []).map(s => new ParamMapAdapter(s.parameters));
+        this.paramMaps = segmentParams
+            .concat(paramMap)
+            .filter(m => !!m); // the activated route param map can be null
+    }
+    get(name) {
+        const paramMap = this.paramMaps.find(m => m.has(name));
+        return paramMap.get(name);
+    }
+    getAll(name) {
+        const paramMap = this.paramMaps.find(m => m.has(name));
+        return paramMap.getAll(name);
+    }
+    has(name) {
+        return !!this.paramMaps.find(m => m.has(name));
+    }
+    get keys() {
+        return this.paramMaps.reduce((result, params) => result.concat(params.keys), []);
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [])
+], ConsolidatedParameterMap.prototype, "keys", null);
+class ParamMapAdapter {
+    constructor(params) {
+        this.params = params;
+    }
+    get(name) {
+        return this.params[name];
+    }
+    getAll(name) {
+        const value = this.get(name);
+        return Array.isArray(value) ? value : [value];
+    }
+    has(name) {
+        return this.keys.includes(name);
+    }
+    get keys() {
+        return Object.keys(this.params);
+    }
+}
+
+class Visit {
+    constructor(placeDefinition, visitParameters = {}) {
+        this.placeDefinition = placeDefinition;
+        this.visitParameters = visitParameters;
+    }
+    // @Trace()
+    getRouteId() {
+        return this.placeDefinition.getRouteIdFrom(this);
+    }
+    // @Trace()
+    hasRouteId() {
+        return !_.isNil(this.getRouteId());
+    }
+    /**
+     * Returns the value of the place parameter with the specified name.  The parameter
+     * name is taken from the `as` option, e.g. {as: 'aCustomName'} otherwise it is the
+     * same as the the ValueModel property name.
+     * @param parameterDef the visit parameter definition
+     */
+    getParameterValue(parameterDef) {
+        return this.visitParameters[parameterDef.name];
+    }
+    // @Trace()
+    hasParameter(parameterDef) {
+        return Object.keys(this.visitParameters).includes(parameterDef.name);
+    }
+    replace(parameter, value) {
+        return new Visit(this.placeDefinition, Object.assign(Object.assign({}, this.visitParameters), { [parameter.name]: value }));
+    }
+    mergeRouteParameters(routeParams) {
+        // todo: whitelist parameters.
+        const routeParameterKeys = Object.keys(routeParams);
+        const params = {};
+        this.placeDefinition.getVisitParameterDefs().forEach(def => {
+            if (def.isRouteId || def.isRouteParameter) {
+                if (routeParameterKeys.includes(def.name)) {
+                    params[def.name] = routeParams[def.name];
+                }
+            }
+            else {
+                // copy non route params as is, but only if they already exist otherwise we'll inject nil values and break the
+                // defaults and remember sanitisation process.
+                const value = this.getParameterValue(def);
+                if (this.hasParameter(def)) {
+                    params[def.name] = value;
+                }
+            }
+        });
+        return new Visit(this.placeDefinition, params);
+    }
+    hasRoutingChangedFrom(other) {
+        const samePlace = other.placeDefinition === this.placeDefinition;
+        const sameRouteParameters = _.isEqual(this.placeDefinition.getFormattedRouteParameters(this, true), this.placeDefinition.getFormattedRouteParameters(other, true));
+        return !samePlace || !sameRouteParameters;
+    }
+    hasChangedFrom(other) {
+        const sameNonRouteParameters = _.isEqual(this.placeDefinition.getNonRouteParameters(this), this.placeDefinition.getNonRouteParameters(other));
+        return !sameNonRouteParameters || this.hasRoutingChangedFrom(other);
+    }
+    toDebugString() {
+        return Object.keys(this.visitParameters).map(k => `${k}=${this.visitParameters[k]}`).join(',');
+    }
+}
+
+function extractPrimarySegments(urlTree) {
+    return urlTree.root.children.primary.segments;
+}
+class UrlSnapshot {
+    // TODO: Update this accept a url Parser so it can be immutable and generate new trees on mutation using toString() are parseUrl.
+    constructor(urlSerializer, url) {
+        this.urlSerializer = urlSerializer;
+        this.url = url;
+        this.urlTree = urlSerializer.parse(url);
+    }
+    updateVisitSegments(visit) {
+        const newUrlTree = this.urlSerializer.parse(this.url);
+        // Ugly, but it works for now.
+        const segments = [...extractPrimarySegments(newUrlTree)];
+        const visitSegments = this.getSegmentsFor(visit);
+        const replaceAt = segments.findIndex(segment => segment.path === visitSegments[0].path);
+        // do not use the return value, it's the items that were removed!
+        segments.splice(replaceAt, visitSegments.length, ...visitSegments);
+        newUrlTree.root.children.primary.segments = segments;
+        return new UrlSnapshot(this.urlSerializer, newUrlTree.toString());
+    }
+    getPrimarySegments() {
+        return extractPrimarySegments(this.urlTree);
+    }
+    /**
+     * Converts the visit into segments.  Please not that these segments are not e
+     * @param visit
+     */
+    getSegmentsFor(visit) {
+        return visit.placeDefinition.hasRouteId() ?
+            [
+                // NOTE:
+                // It's important to attach the params to the root path and not the id.  If we attach them
+                // to an empty id then the angular router won't match the pattern.
+                new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit)),
+                new UrlSegment(visit.placeDefinition.getFormattedRouteId(visit), {})
+            ]
+            :
+                [
+                    new UrlSegment(visit.placeDefinition.path, visit.placeDefinition.getFormattedRouteParameters(visit))
+                ];
+    }
+    includesPathOf(placeDef) {
+        return this.getPrimarySegments().find(s => s.path === placeDef.path);
+    }
+    createVisitFor(placeDef) {
+        return new Visit(placeDef, new ConsolidatedParameterMap(this.getPrimarySegments()));
+    }
+    getInteractionIds() {
+        const queryParam = this.urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM];
+        if (queryParam) {
+            return UrlSnapshot.parseInteractionIds(queryParam);
+        }
+        else {
+            return [];
+        }
+    }
+    hasInteractions() {
+        return this.getInteractionIds().length > 0;
+    }
+    hasInteractionIds(ids) {
+        return ___default.isEqual(this.getInteractionIds(), ids);
+    }
+    // @Trace()
+    updateInteractionIds(ids) {
+        if (ids.length === 0) {
+            return this.removeInteractionIds();
+        }
+        else {
+            const urlTree = this.urlSerializer.parse(this.url);
+            urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM] = UrlSnapshot.createPathIdFor(ids);
+            return new UrlSnapshot(this.urlSerializer, urlTree.toString());
+        }
+    }
+    // @Trace()
+    removeInteractionIds() {
+        const urlTree = this.urlSerializer.parse(this.url);
+        if (urlTree.queryParams && urlTree.queryParams[UrlSnapshot.INTERACTION_QUERY_PARAM]) {
+            urlTree.queryParams = {}; //[UrlSnapshot.INTERACTION_ROUTER_OUTLET]
+        }
+        return new UrlSnapshot(this.urlSerializer, urlTree.toString());
+    }
+    toString() {
+        return `UrlSnapshot(${this.url})`;
+    }
+}
+__decorate([
+    Trace(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Visit]),
+    __metadata("design:returntype", UrlSnapshot)
+], UrlSnapshot.prototype, "updateVisitSegments", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], UrlSnapshot.prototype, "getPrimarySegments", null);
+(function (UrlSnapshot) {
+    UrlSnapshot.INTERACTION_QUERY_PARAM = 'aup-interactions';
+    UrlSnapshot.INTERACTION_ID_SEPARATOR = '--';
+    function parseInteractionIds(path) {
+        return path.split(UrlSnapshot.INTERACTION_ID_SEPARATOR);
+    }
+    UrlSnapshot.parseInteractionIds = parseInteractionIds;
+    function createPathIdFor(interactionIds) {
+        return interactionIds.join(UrlSnapshot.INTERACTION_ID_SEPARATOR);
+    }
+    UrlSnapshot.createPathIdFor = createPathIdFor;
+})(UrlSnapshot || (UrlSnapshot = {}));
+
 class UrlService {
     constructor(angularRouter, angularLocation, urlSerializer) {
         this.angularRouter = angularRouter;