@coolon/angular-ui-powerups 0.0.37 → 0.0.41

package/esm2015/lib/place/route/parameter-snapshot.js

@@ -0,0 +1,382 @@
+import * as tslib_1 from "tslib";
+var _a;
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { assert, Trace } from '@coolon/pectin';
+import { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';
+import * as _ from 'lodash';
+// TODO: there are really two types of snapshot, ones with id's and ones without.
+// Id snapshot are repesented by 2 url segments
+// ID => [{'/basePath', params}, {'id', params}]
+// NO ID => [{'/basePath', params}]
+export class ParameterSnapshot {
+    /**
+     * @param {?} placeDefinition
+     * @param {?} resolved
+     */
+    constructor(placeDefinition, resolved) {
+        this.placeDefinition = placeDefinition;
+        this.resolved = resolved;
+    }
+    /**
+     * @param {?} other
+     * @return {?}
+     */
+    hasChanged(other) {
+        /** @type {?} */
+        const changed = this.resolved.find((/**
+         * @param {?} r
+         * @return {?}
+         */
+        (r) => {
+            return !r.isSame(other.getResolvedParameterValue(r.parameterDef));
+        }));
+        if (changed) {
+            console.log({ mine: changed, theirs: other.getResolvedParameter(changed.parameterDef) });
+        }
+        return !!changed;
+    }
+    /**
+     * @param {?} other
+     * @return {?}
+     */
+    asUrlSegment(other) {
+        assert.isTruthy(this.hasChanged(other));
+        /** @type {?} */
+        const routeParts = [];
+        /** @type {?} */
+        const gainedId = this.getFormattedRouteId() && !other.getFormattedRouteId();
+        /** @type {?} */
+        const sameId = this.getFormattedRouteId() === other.getFormattedRouteId();
+        /** @type {?} */
+        const lostId = (!this.getFormattedRouteId() && other.getFormattedRouteId());
+        /** @type {?} */
+        const changedId = (this.getFormattedRouteId() !== other.getFormattedRouteId());
+        if (lostId || changedId) {
+            routeParts.push('..');
+            if (changedId) {
+                routeParts.push(this.getFormattedRouteId());
+            }
+        }
+        else {
+            routeParts.push('.');
+        }
+        routeParts.push(this.getFormattedParameters());
+        return routeParts;
+    }
+    /**
+     * @template T, S
+     * @param {?} parameterDef
+     * @return {?}
+     */
+    getResolvedParameter(parameterDef) {
+        return this.resolved.find((/**
+         * @param {?} r
+         * @return {?}
+         */
+        r => r.parameterDef === parameterDef));
+    }
+    /**
+     * @template T, S
+     * @param {?} parameterDef
+     * @return {?}
+     */
+    getResolvedParameterValue(parameterDef) {
+        /** @type {?} */
+        const resolvedParameter = this.getResolvedParameter(parameterDef);
+        return resolvedParameter ? resolvedParameter.value : null;
+    }
+    /**
+     * @return {?}
+     */
+    getRouteId() {
+        return this.getResolvedRouteId() ? this.getResolvedRouteId().value : null;
+    }
+    /**
+     * @param {?} name
+     * @return {?}
+     */
+    getRouteParameter(name) {
+        /** @type {?} */
+        const resolvedParameter = this.resolved.find((/**
+         * @param {?} r
+         * @return {?}
+         */
+        r => r.parameterDef.name === name));
+        return resolvedParameter ? resolvedParameter.value : null;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getResolvedRouteId() {
+        // RouteId's are never arrays: see parameter-decorators.ts createDefinition methods. It would be nice to
+        // capture this in the type system though
+        return (/** @type {?} */ (this.resolved.find((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => p.parameterDef.isRouteId))));
+    }
+    /**
+     * @return {?}
+     */
+    hasRouteId() {
+        return !!this.getResolvedRouteId();
+    }
+    /**
+     * @return {?}
+     */
+    getFormattedRouteId() {
+        /** @type {?} */
+        const routeIdParam = this.getResolvedRouteId();
+        return routeIdParam ? routeIdParam.formattedValue() : null;
+    }
+    /**
+     * @return {?}
+     */
+    getFormattedParameters() {
+        /** @type {?} */
+        const params = {};
+        /** @type {?} */
+        const routeIdParam = this.resolved.filter((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => !p.parameterDef.isRouteId)).forEach((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => {
+            params[p.parameterDef.name] = p.formattedValue();
+        }));
+        return params;
+    }
+    /**
+     * @template T, S
+     * @param {?} parameter
+     * @param {?} value
+     * @return {?}
+     */
+    replace(parameter, value) {
+        return new ParameterSnapshot(this.placeDefinition, this.resolved.map((/**
+         * @param {?} p
+         * @return {?}
+         */
+        p => {
+            return p.parameterDef === parameter ? p.replace(value) : p;
+        })));
+    }
+    /**
+     * @param {?} url
+     * @return {?}
+     */
+    updateUrl(url) {
+        return url;
+    }
+}
+tslib_1.__decorate([
+    Memoize(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", ParameterSnapshot.ResolvedParameter)
+], ParameterSnapshot.prototype, "getResolvedParameter", null);
+tslib_1.__decorate([
+    Memoize(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object]),
+    tslib_1.__metadata("design:returntype", typeof (_a = typeof S !== "undefined" && S) === "function" ? _a : Object)
+], ParameterSnapshot.prototype, "getResolvedParameterValue", null);
+tslib_1.__decorate([
+    Memoize(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Object)
+], ParameterSnapshot.prototype, "getRouteParameter", null);
+tslib_1.__decorate([
+    Memoize(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", ParameterSnapshot.ResolvedValueParameter)
+], ParameterSnapshot.prototype, "getResolvedRouteId", null);
+if (false) {
+    /** @type {?} */
+    ParameterSnapshot.prototype.placeDefinition;
+    /**
+     * @type {?}
+     * @private
+     */
+    ParameterSnapshot.prototype.resolved;
+}
+(function (ParameterSnapshot) {
+    /**
+     * @param {?} placeDef
+     * @param {?} paramMap
+     * @return {?}
+     */
+    function create(placeDef, paramMap) {
+        /** @type {?} */
+        const resolvedParameters = placeDef.getRouteParameters()
+            .map((/**
+         * @param {?} def
+         * @return {?}
+         */
+        def => {
+            if (def.isArray) {
+                /** @type {?} */
+                const value = paramMap.has(def.name) ? paramMap.getAll(def.name).map((/**
+                 * @param {?} raw
+                 * @return {?}
+                 */
+                raw => def.type.parse(raw))) : null;
+                return new ResolvedArrayParameter(def, value);
+            }
+            else {
+                /** @type {?} */
+                const value = paramMap.has(def.name) ? def.type.parse(paramMap.get(def.name)) : null;
+                return new ResolvedValueParameter(def, value);
+            }
+        }));
+        return new ParameterSnapshot(placeDef, resolvedParameters);
+    }
+    ParameterSnapshot.create = create;
+    /**
+     * @abstract
+     * @template T, S
+     */
+    class ResolvedParameter {
+        /**
+         * @param {?} parameterDef
+         * @param {?} value
+         */
+        constructor(parameterDef, value) {
+            this.parameterDef = parameterDef;
+            this.value = value;
+        }
+        /**
+         * @return {?}
+         */
+        isRouteId() {
+            return this.parameterDef.isRouteId;
+        }
+    }
+    ParameterSnapshot.ResolvedParameter = ResolvedParameter;
+    if (false) {
+        /** @type {?} */
+        ResolvedParameter.prototype.parameterDef;
+        /** @type {?} */
+        ResolvedParameter.prototype.value;
+        /**
+         * @abstract
+         * @param {?} dest
+         * @return {?}
+         */
+        ResolvedParameter.prototype.injectRouteParam = function (dest) { };
+        /**
+         * @abstract
+         * @param {?} otherValue
+         * @return {?}
+         */
+        ResolvedParameter.prototype.isSame = function (otherValue) { };
+        /**
+         * @abstract
+         * @return {?}
+         */
+        ResolvedParameter.prototype.formattedValue = function () { };
+        /**
+         * @abstract
+         * @param {?} value
+         * @return {?}
+         */
+        ResolvedParameter.prototype.replace = function (value) { };
+    }
+    /**
+     * @template T
+     */
+    class ResolvedValueParameter extends ResolvedParameter {
+        /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        isSame(otherValue) {
+            return this.value === otherValue;
+        }
+        /**
+         * @param {?} dest
+         * @return {?}
+         */
+        injectRouteParam(dest) {
+            dest[this.parameterDef.name] = this.parameterDef.type.format(this.value);
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        replace(value) {
+            return new ResolvedValueParameter(this.parameterDef, value);
+        }
+        /**
+         * @return {?}
+         */
+        formattedValue() {
+            return !_.isNil(this.value) ? this.parameterDef.type.format(this.value) : null;
+        }
+    }
+    tslib_1.__decorate([
+        Trace(),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [Object]),
+        tslib_1.__metadata("design:returntype", Boolean)
+    ], ResolvedValueParameter.prototype, "isSame", null);
+    ParameterSnapshot.ResolvedValueParameter = ResolvedValueParameter;
+    /**
+     * @template T
+     */
+    class ResolvedArrayParameter extends ResolvedParameter {
+        /**
+         * @param {?} otherValue
+         * @return {?}
+         */
+        isSame(otherValue) {
+            return _.isEqual(this.value, otherValue);
+        }
+        /**
+         * @param {?} dest
+         * @return {?}
+         */
+        injectRouteParam(dest) {
+            dest[this.parameterDef.name] = this.value.map((/**
+             * @param {?} v
+             * @return {?}
+             */
+            v => this.parameterDef.type.format(v)));
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        replace(value) {
+            return new ResolvedArrayParameter(this.parameterDef, value);
+        }
+        /**
+         * @return {?}
+         */
+        formattedValue() {
+            return this.value ? this.value.map((/**
+             * @param {?} v
+             * @return {?}
+             */
+            v => this.parameterDef.type.format(v))) : [];
+        }
+    }
+    tslib_1.__decorate([
+        Trace(),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", [Array]),
+        tslib_1.__metadata("design:returntype", Boolean)
+    ], ResolvedArrayParameter.prototype, "isSame", null);
+    ParameterSnapshot.ResolvedArrayParameter = ResolvedArrayParameter;
+})(ParameterSnapshot || (ParameterSnapshot = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-snapshot.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/route/parameter-snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["import { ParamMap, UrlSegment } from '@angular/router';\nimport { assert, Trace } from '@coolon/pectin';\nimport { Memoize } from '@typescript-plus/fast-memoize-decorator/dist/src';\nimport * as _ from 'lodash';\nimport { PlaceComponent } from '../place-component';\nimport { Visit } from '../visit';\nimport { ParameterDefinition } from './parameter-definition.class';\n\n// TODO: there are really two types of snapshot, ones with id's and ones without.\n// Id snapshot are repesented by 2 url segments\n// ID => [{'/basePath', params}, {'id', params}]\n// NO ID => [{'/basePath', params}]\nexport class ParameterSnapshot implements Visit {\n\n  constructor(readonly placeDefinition: PlaceComponent.Definition, private readonly resolved: ParameterSnapshot.ResolvedParameter<any, any>[]) {\n  }\n\n  hasChanged(other: ParameterSnapshot): boolean {\n    const changed = this.resolved.find((r) => {\n      return !r.isSame(other.getResolvedParameterValue(r.parameterDef));\n    });\n    if (changed) {\n      console.log({ mine: changed, theirs: other.getResolvedParameter(changed.parameterDef) });\n    }\n    return !!changed;\n  }\n\n  asUrlSegment(other: ParameterSnapshot): any[] {\n    assert.isTruthy(this.hasChanged(other));\n    const routeParts = [];\n    const gainedId = this.getFormattedRouteId() && !other.getFormattedRouteId();\n    const sameId = this.getFormattedRouteId() === other.getFormattedRouteId();\n    const lostId = (!this.getFormattedRouteId() && other.getFormattedRouteId());\n    const changedId = (this.getFormattedRouteId() !== other.getFormattedRouteId());\n    if (lostId || changedId) {\n      routeParts.push('..');\n      if (changedId) {\n        routeParts.push(this.getFormattedRouteId());\n      }\n    } else {\n      routeParts.push('.');\n    }\n    routeParts.push(this.getFormattedParameters());\n    return routeParts;\n  }\n\n  @Memoize()\n  getResolvedParameter<T, S>(parameterDef: ParameterDefinition<T, S>): ParameterSnapshot.ResolvedParameter<T, S> {\n    return this.resolved.find(r => r.parameterDef === parameterDef);\n  }\n\n  @Memoize()\n  getResolvedParameterValue<T, S>(parameterDef: ParameterDefinition<T, S>): S {\n    const resolvedParameter = this.getResolvedParameter(parameterDef);\n    return resolvedParameter ? resolvedParameter.value : null;\n  }\n\n  getRouteId(): any {\n    return this.getResolvedRouteId() ? this.getResolvedRouteId().value : null;\n  }\n\n  @Memoize()\n  getRouteParameter(name: string): any {\n    const resolvedParameter = this.resolved.find(r => r.parameterDef.name === name);\n    return resolvedParameter ? resolvedParameter.value : null;\n  }\n\n  @Memoize()\n  private getResolvedRouteId(): ParameterSnapshot.ResolvedValueParameter<any> {\n    // RouteId's are never arrays: see parameter-decorators.ts createDefinition methods. It would be nice to\n    // capture this in the type system though\n    return this.resolved.find(p => p.parameterDef.isRouteId) as ParameterSnapshot.ResolvedValueParameter<any>;\n  }\n\n  hasRouteId() {\n    return !!this.getResolvedRouteId();\n  }\n\n  getFormattedRouteId(): string {\n    const routeIdParam = this.getResolvedRouteId();\n    return routeIdParam ? routeIdParam.formattedValue() : null;\n  }\n\n  getFormattedParameters() {\n    const params = {};\n    const routeIdParam = this.resolved.filter(p => !p.parameterDef.isRouteId).forEach(p => {\n      params[p.parameterDef.name] = p.formattedValue();\n    });\n    return params;\n  }\n\n  replace<T, S>(parameter: ParameterDefinition<T, S>, value: S): ParameterSnapshot {\n    return new ParameterSnapshot(this.placeDefinition, this.resolved.map(p => {\n      return p.parameterDef === parameter ? p.replace(value) : p;\n    }));\n  }\n\n  updateUrl(url: UrlSegment[]) {\n    return url;\n  }\n}\n\nexport namespace ParameterSnapshot {\n\n  export function create(placeDef: PlaceComponent.Definition, paramMap: ParamMap): ParameterSnapshot {\n    const resolvedParameters: ResolvedParameter<any, any>[] = placeDef.getRouteParameters()\n      .map(def => {\n      if (def.isArray) {\n        const value = paramMap.has(def.name) ? paramMap.getAll(def.name).map(raw => def.type.parse(raw)) : null;\n        return new ResolvedArrayParameter(def, value);\n      } else {\n        const value = paramMap.has(def.name) ? def.type.parse(paramMap.get(def.name)) : null;\n        return new ResolvedValueParameter(def, value);\n      }\n    });\n    return new ParameterSnapshot(placeDef, resolvedParameters);\n  }\n\n\n  export abstract class ResolvedParameter<T, S = T> {\n    constructor(readonly parameterDef: ParameterDefinition<T, S>, readonly value: S) {\n    }\n\n    abstract injectRouteParam(dest: {}): void;\n\n    abstract isSame(otherValue: S): boolean;\n\n    isRouteId(): boolean {\n      return this.parameterDef.isRouteId;\n    }\n\n    abstract formattedValue(): string | string[];\n\n    abstract replace(value: S): ResolvedParameter<T, S>;\n  }\n\n  export class ResolvedValueParameter<T> extends ResolvedParameter<T, T> {\n    @Trace()\n    isSame(otherValue: T): boolean {\n      return this.value === otherValue;\n    }\n\n    injectRouteParam(dest: {}): void {\n      dest[this.parameterDef.name] = this.parameterDef.type.format(this.value);\n    }\n\n    replace(value: T): ParameterSnapshot.ResolvedParameter<T, T> {\n      return new ResolvedValueParameter<T>(this.parameterDef, value);\n    }\n\n    formattedValue(): string {\n      return !_.isNil(this.value) ? this.parameterDef.type.format(this.value) : null;\n    }\n  }\n\n  export class ResolvedArrayParameter<T> extends ResolvedParameter<T, T[]> {\n    @Trace()\n    isSame(otherValue: T[]): boolean {\n      return _.isEqual(this.value, otherValue);\n    }\n\n    injectRouteParam(dest: {}): void {\n      dest[this.parameterDef.name] = this.value.map(v => this.parameterDef.type.format(v));\n    }\n\n    replace(value: T[]): ParameterSnapshot.ResolvedParameter<T, T[]> {\n      return new ResolvedArrayParameter<T>(this.parameterDef, value);\n    }\n\n    formattedValue(): string[] {\n      return this.value ? this.value.map(v => this.parameterDef.type.format(v)) : [];\n    }\n\n  }\n\n\n}\n"]}

package/esm2015/lib/place/route/parameter-type.js

@@ -2,6 +2,7 @@
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+import * as _ from 'lodash';
 // WARNING: interface has both a type and a value, skipping emit
 export var ParameterType;
 (function (ParameterType) {
@@ -34,7 +35,7 @@ export var ParameterType;
          * @return {?}
          */
         parse(value) {
-            return +value;
+            return _.isNil(value) || _.isEmpty(value) ? null : +value;
         }
     }
     class BooleanType {
@@ -57,4 +58,4 @@ export var ParameterType;
     ParameterType.NUMBER = new NumberType();
     ParameterType.BOOLEAN = new BooleanType();
 })(ParameterType || (ParameterType = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW1ldGVyLXR5cGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvcGxhY2Uvcm91dGUvcGFyYW1ldGVyLXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sUUFBUSxDQUFDOztBQVE1QixNQUFNLEtBQVcsYUFBYSxDQW1DN0I7QUFuQ0QsV0FBaUIsYUFBYTtJQUU1QixNQUFNLFVBQVU7Ozs7O1FBQ2QsTUFBTSxDQUFDLEtBQWE7WUFDbEIsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDOzs7OztRQUVELEtBQUssQ0FBQyxLQUFhO1lBQ2pCLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztLQUNGO0lBRUQsTUFBTSxVQUFVOzs7OztRQUNkLE1BQU0sQ0FBQyxLQUFhO1lBQ2xCLE9BQU8sR0FBRyxLQUFLLEVBQUUsQ0FBQztRQUNwQixDQUFDOzs7OztRQUVELEtBQUssQ0FBQyxLQUFhO1lBQ2pCLE9BQU8sQ0FBQyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDO1FBQzVELENBQUM7S0FDRjtJQUVELE1BQU0sV0FBVzs7Ozs7UUFDZixNQUFNLENBQUMsS0FBYztZQUNuQixPQUFPLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUM7UUFDbEMsQ0FBQzs7Ozs7UUFFRCxLQUFLLENBQUMsS0FBYTtZQUNqQixPQUFPLEtBQUssS0FBSyxNQUFNLENBQUM7UUFDMUIsQ0FBQztLQUNGO0lBRVksb0JBQU0sR0FBRyxJQUFJLFVBQVUsRUFBRTtJQUN6QixvQkFBTSxHQUFHLElBQUksVUFBVSxFQUFFO0lBQ3pCLHFCQUFPLEdBQUcsSUFBSSxXQUFXLEVBQUU7QUFDMUMsQ0FBQyxFQW5DZ0IsYUFBYSxLQUFiLGFBQWEsUUFtQzdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgXyBmcm9tICdsb2Rhc2gnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBhcmFtZXRlclR5cGU8VD4ge1xuICBmb3JtYXQodmFsdWU6IFQpOiBzdHJpbmc7XG5cbiAgcGFyc2UodmFsdWU6IHN0cmluZyk6IFQ7XG59XG5cbmV4cG9ydCBuYW1lc3BhY2UgUGFyYW1ldGVyVHlwZSB7XG5cbiAgY2xhc3MgU3RyaW5nVHlwZSBpbXBsZW1lbnRzIFBhcmFtZXRlclR5cGU8c3RyaW5nPiB7XG4gICAgZm9ybWF0KHZhbHVlOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgcmV0dXJuIHZhbHVlO1xuICAgIH1cblxuICAgIHBhcnNlKHZhbHVlOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgcmV0dXJuIHZhbHVlO1xuICAgIH1cbiAgfVxuXG4gIGNsYXNzIE51bWJlclR5cGUgaW1wbGVtZW50cyBQYXJhbWV0ZXJUeXBlPG51bWJlcj4ge1xuICAgIGZvcm1hdCh2YWx1ZTogbnVtYmVyKTogc3RyaW5nIHtcbiAgICAgIHJldHVybiBgJHt2YWx1ZX1gO1xuICAgIH1cblxuICAgIHBhcnNlKHZhbHVlOiBzdHJpbmcpOiBudW1iZXIge1xuICAgICAgcmV0dXJuIF8uaXNOaWwodmFsdWUpIHx8IF8uaXNFbXB0eSh2YWx1ZSkgPyBudWxsIDogK3ZhbHVlO1xuICAgIH1cbiAgfVxuXG4gIGNsYXNzIEJvb2xlYW5UeXBlIGltcGxlbWVudHMgUGFyYW1ldGVyVHlwZTxib29sZWFuPiB7XG4gICAgZm9ybWF0KHZhbHVlOiBib29sZWFuKTogc3RyaW5nIHtcbiAgICAgIHJldHVybiB2YWx1ZSA/ICd0cnVlJyA6ICdmYWxzZSc7XG4gICAgfVxuXG4gICAgcGFyc2UodmFsdWU6IHN0cmluZyk6IGJvb2xlYW4ge1xuICAgICAgcmV0dXJuIHZhbHVlID09PSAndHJ1ZSc7XG4gICAgfVxuICB9XG5cbiAgZXhwb3J0IGNvbnN0IFNUUklORyA9IG5ldyBTdHJpbmdUeXBlKCk7XG4gIGV4cG9ydCBjb25zdCBOVU1CRVIgPSBuZXcgTnVtYmVyVHlwZSgpO1xuICBleHBvcnQgY29uc3QgQk9PTEVBTiA9IG5ldyBCb29sZWFuVHlwZSgpO1xufVxuIl19