@coolon/angular-ui-powerups 0.0.67 → 0.0.68

package/esm2015/lib/place/place-router.js

@@ -2,94 +2,100 @@
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+import * as tslib_1 from "tslib";
 import { Location } from '@angular/common';
 import { Injectable } from '@angular/core';
-import { NavigationEnd, NavigationError, NavigationStart, Router } from '@angular/router';
-import { MutableValueModel } from '@coolon/pectin';
+import { ActivatedRoute, NavigationEnd, NavigationError, NavigationStart, Router } from '@angular/router';
+import { Dsl, GarbageCollector, MutableListModel, MutableValueModel, Trace } from '@coolon/pectin';
 import _ from 'lodash';
+import { NavigationSession } from './navigation-session';
+import { PlaceHistory } from './place-history';
+import { Visit } from './visit';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
 import * as i2 from "@angular/common";
-class NavigationSession {
-    /**
-     * @param {?} isPopState
-     * @param {?} initialUrl
-     */
-    constructor(isPopState, initialUrl) {
-        this.isPopState = isPopState;
-        this.initialUrl = initialUrl;
-        this._alreadyAccepted = [];
-        console.log('NavigationSession', { isPopState, initialUrl });
-    }
-    /**
-     * @param {?} placeComponent
-     * @return {?}
-     */
-    alreadyAccepted(placeComponent) {
-        return this._alreadyAccepted.includes(placeComponent);
-    }
-    /**
-     * @param {?} component
-     * @return {?}
-     */
-    rememberAcceptanceOf(component) {
-        this._alreadyAccepted.push(component);
-    }
-}
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    NavigationSession.prototype._alreadyAccepted;
-    /** @type {?} */
-    NavigationSession.prototype.isPopState;
-    /** @type {?} */
-    NavigationSession.prototype.initialUrl;
-}
-export class PlaceRouter {
+import * as i3 from "./place-history";
+export class PlaceRouter extends GarbageCollector {
     /**
      * @param {?} router
      * @param {?} angularLocation
+     * @param {?} placeHistory
      */
-    constructor(router, angularLocation) {
+    constructor(router, angularLocation, placeHistory) {
+        super();
         this.router = router;
         this.angularLocation = angularLocation;
-        this._navigationSession = new MutableValueModel();
+        this.placeHistory = placeHistory;
+        this.firstRoute = true;
+        this._navigationSessionModel = new MutableValueModel();
+        this._activeVisits = new MutableListModel();
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        this.activeVisitIndex = chain(this._activeVisits).indexBy('placeDefinition');
         angularLocation.onUrlChange((/**
          * @param {?} url
          * @return {?}
          */
         url => {
-            console.log(`### ${url}`);
+            console.log(`location.onUrlChange -> ${url}`);
         }));
+        // TODO: make setup the callbacks in during module initiation to make this testable.
         this.router.events.subscribe((/**
          * @param {?} event
          * @return {?}
          */
         event => {
-            // console.log(`${event.constructor.name}`, location.pathname, angularLocation.getState());
-            // NavigationStart -> .... -> NavigationCancel === redirect (so don't ask again)
-            // NavigationStart -> .... -> NavigationEnd === navigated (so ask next time)
-            // NavigationStart -> .... -> NavigationError === canceled (guard cancelled so ask next time)
-            if (event instanceof NavigationStart && !this.navigationSession) {
-                this._navigationSession.value = new NavigationSession(event.navigationTrigger === 'popstate', this.router.routerState.snapshot.url);
+            // Routing event sequence
+            // ======================
+            // NavigationStart -> .... -> NavigationCancel --> redirect, go around again in the same session
+            // NavigationStart -> .... -> NavigationEnd --> navigation complete, end session.
+            // NavigationStart -> .... -> NavigationError --> navigation canceled, end session.
+            // =======================
+            if (event instanceof NavigationStart) {
+                this.onAngularRouterStarted(event);
             }
-            if (event instanceof NavigationEnd) {
-                console.log('navigation ended');
-                this._navigationSession.value = null;
-            }
-            if (event instanceof NavigationError) {
-                console.log('navigation errored');
-                this._navigationSession.value = null;
+            if (event instanceof NavigationEnd || event instanceof NavigationError) {
+                this.onAngularRouterFinished();
             }
         }));
+        this.navigationSessionActive = chain(this.navigationSessionModel).isNotNil();
+        this.navigationSessionActive.subscribe((/**
+         * @param {?} active
+         * @return {?}
+         */
+        active => {
+            console.log('navigationSessionActive', active);
+        }));
+        // const txo = new TransactionObserver().onEvent(e => console.log(e.toString()));
+        // txo.observe('this.navigationSessionModel', this.navigationSessionModel);
     }
     /**
      * @return {?}
      */
     get navigationSession() {
-        return this._navigationSession.value;
+        return this._navigationSessionModel.value;
+    }
+    /**
+     * @return {?}
+     */
+    get navigationSessionModel() {
+        return this._navigationSessionModel.readonly;
+    }
+    /**
+     * @return {?}
+     */
+    get activeVisits() {
+        return this._activeVisits.readonly;
+    }
+    /**
+     *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));
+     * @param {?} visit
+     * @return {?}
+     */
+    // @Trace()
+    navigate(visit) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.doNavigation(visit);
+        });
     }
     /**
      * @param {?} activatedRoute
@@ -97,32 +103,109 @@ export class PlaceRouter {
      * @param {?} next
      * @return {?}
      */
-    pushParameterChangesToRoute(activatedRoute, previous, next) {
-        /** @type {?} */
-        const relativePath = !!previous.hasRouteId() ? '..' : '.';
-        this.router.navigate([relativePath].concat(this.createRouteParameters(next), this.getChildPath(activatedRoute.snapshot)), {
-            relativeTo: activatedRoute
+    pushVisitChangesToRoute(activatedRoute, previous, next) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // FIXME: no route id -> route id duplicates route parameters
+            if (next.hasRoutingChangedFrom(previous)) {
+                return this.doNavigation(next, (/**
+                 * @param {?} router
+                 * @return {?}
+                 */
+                router => {
+                    /** @type {?} */
+                    const relativePath = !!previous.placeDefinition.hasRouteId() ? '..' : '.';
+                    /** @type {?} */
+                    const def = next.placeDefinition;
+                    /** @type {?} */
+                    const params = next.hasRouteId() ?
+                        [def.getFormattedRouteId(next), def.getFormattedRouteParameters(next)] :
+                        [def.getFormattedRouteParameters(next)];
+                    /** @type {?} */
+                    const commands = [relativePath].concat(params, this.getChildPath(activatedRoute.snapshot));
+                    console.log('### Redirect', commands);
+                    return router.navigate(commands, {
+                        relativeTo: activatedRoute
+                    });
+                }));
+            }
+            else {
+                this.placeHistory.add(next);
+            }
+        });
+    }
+    /**
+     * @param {?} visit
+     * @param {?=} customNavigation
+     * @return {?}
+     */
+    doNavigation(visit, customNavigation) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this._navigationSessionModel.value = NavigationSession.createInternal(visit);
+            try {
+                if (customNavigation) {
+                    yield customNavigation(this.router);
+                }
+                else {
+                    /** @type {?} */
+                    const def = visit.placeDefinition;
+                    /** @type {?} */
+                    const parameterCommands = visit.hasRouteId() ?
+                        [def.getFormattedRouteId(visit), def.getFormattedRouteParameters(visit)] :
+                        [def.getFormattedRouteParameters(visit)];
+                    /** @type {?} */
+                    const commands = [def.path].concat(parameterCommands);
+                    console.log('_doNavigation', visit, commands);
+                    yield this.router.navigate(commands);
+                }
+            }
+            finally {
+                if (this.navigationSession && !this.router.getCurrentNavigation()) {
+                    this.onAngularRouterFinished();
+                }
+            }
         });
     }
     // @Trace()
     /**
-     * @param {?} activatedRoute
-     * @param {?} sanitised
+     * @private
+     * @param {?} event
      * @return {?}
      */
-    getRedirectUrlTree(activatedRoute, sanitised) {
-        /** @type {?} */
-        const urlSegments = activatedRoute.url;
+    onAngularRouterStarted(event) {
+        if (!this.navigationSession) { // We been activated by an external route rather than placeRouter.go(visit)
+            console.log('navigation started', { firstTime: this.firstRoute });
+            /** @type {?} */
+            const session = NavigationSession.createExternal(this.firstRoute);
+            if (event.navigationTrigger === 'popstate') {
+                session.setPopstateReturn(this.router.routerState.snapshot.url);
+            }
+            this._navigationSessionModel.value = session;
+        }
+        this.firstRoute = false;
+    }
+    // @Trace()
+    /**
+     * @private
+     * @return {?}
+     */
+    onAngularRouterFinished() {
         /** @type {?} */
-        const weHaveARouteId = sanitised.hasRouteId() && sanitised.getFormattedRouteId();
+        const session = this._navigationSessionModel.value;
+        // Update visits before we end the navigation session.  This allows the place out let to
+        // gate ignore changes that occur while the visit is active
         /** @type {?} */
-        const commands = (weHaveARouteId) ?
-            [urlSegments[0].path, sanitised.getFormattedRouteId(), sanitised.getFormattedParameters()] :
-            [urlSegments[0].path, sanitised.getFormattedParameters()];
-        return this.router.createUrlTree(commands);
+        const visits = session.getVisits();
+        visits.forEach((/**
+         * @param {?} v
+         * @return {?}
+         */
+        v => {
+            this.placeHistory.add(v);
+        }));
+        this._activeVisits.value = visits;
+        this._navigationSessionModel.value = null;
     }
     /**
-     * @protected
      * @param {?} activatedRoute
      * @return {?}
      */
@@ -133,18 +216,6 @@ export class PlaceRouter {
          */
         child => child.url)));
     }
-    /**
-     * @protected
-     * @param {?} parameters
-     * @return {?}
-     */
-    createRouteParameters(parameters) {
-        /** @type {?} */
-        const routeId = parameters.getFormattedRouteId();
-        return routeId ?
-            [routeId, parameters.getFormattedParameters()] :
-            [parameters.getFormattedParameters()];
-    }
 }
 PlaceRouter.decorators = [
     { type: Injectable, args: [{
@@ -154,15 +225,36 @@ PlaceRouter.decorators = [
 /** @nocollapse */
 PlaceRouter.ctorParameters = () => [
     { type: Router },
-    { type: Location }
+    { type: Location },
+    { type: PlaceHistory }
 ];
-/** @nocollapse */ PlaceRouter.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.Location)); }, token: PlaceRouter, providedIn: "root" });
+/** @nocollapse */ PlaceRouter.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function PlaceRouter_Factory() { return new PlaceRouter(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.Location), i0.ɵɵinject(i3.PlaceHistory)); }, token: PlaceRouter, providedIn: "root" });
+tslib_1.__decorate([
+    Trace(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [ActivatedRoute, Visit, Visit]),
+    tslib_1.__metadata("design:returntype", Promise)
+], PlaceRouter.prototype, "pushVisitChangesToRoute", null);
 if (false) {
     /**
      * @type {?}
      * @private
      */
-    PlaceRouter.prototype._navigationSession;
+    PlaceRouter.prototype.firstRoute;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype._navigationSessionModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    PlaceRouter.prototype._activeVisits;
+    /** @type {?} */
+    PlaceRouter.prototype.navigationSessionActive;
+    /** @type {?} */
+    PlaceRouter.prototype.activeVisitIndex;
     /**
      * @type {?}
      * @private
@@ -170,5 +262,7 @@ if (false) {
     PlaceRouter.prototype.router;
     /** @type {?} */
     PlaceRouter.prototype.angularLocation;
+    /** @type {?} */
+    PlaceRouter.prototype.placeHistory;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-router.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/place-router.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport {\n  ActivatedRoute,\n  ActivatedRouteSnapshot,\n  NavigationEnd,\n  NavigationError,\n  NavigationStart,\n  Router,\n  UrlTree\n} from '@angular/router';\nimport { MutableValueModel, Trace } from '@coolon/pectin';\nimport _ from 'lodash';\nimport { PlaceComponent } from './place-component';\nimport { ParameterSnapshot } from './route/parameter-snapshot';\n\nclass NavigationSession {\n  private _alreadyAccepted: PlaceComponent[] = [];\n\n  constructor(readonly isPopState: boolean, readonly initialUrl: string) {\n    console.log('NavigationSession', { isPopState, initialUrl });\n  }\n\n  alreadyAccepted(placeComponent: PlaceComponent): boolean {\n    return this._alreadyAccepted.includes(placeComponent);\n  }\n\n  rememberAcceptanceOf(component: PlaceComponent) {\n    this._alreadyAccepted.push(component);\n  }\n}\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PlaceRouter {\n\n  private readonly _navigationSession = new MutableValueModel<NavigationSession>();\n\n  constructor(private readonly router: Router, readonly angularLocation: Location) {\n    angularLocation.onUrlChange(url => {\n      console.log(`### ${url}`);\n    });\n    this.router.events.subscribe(event => {\n      // console.log(`${event.constructor.name}`, location.pathname, angularLocation.getState());\n      // NavigationStart -> .... -> NavigationCancel === redirect (so don't ask again)\n      // NavigationStart -> .... -> NavigationEnd === navigated (so ask next time)\n      // NavigationStart -> .... -> NavigationError === canceled (guard cancelled so ask next time)\n      if (event instanceof NavigationStart && !this.navigationSession) {\n        this._navigationSession.value = new NavigationSession(event.navigationTrigger === 'popstate', this.router.routerState.snapshot.url);\n      }\n      if (event instanceof NavigationEnd) {\n        console.log('navigation ended');\n        this._navigationSession.value = null;\n      }\n      if (event instanceof NavigationError) {\n        console.log('navigation errored');\n        this._navigationSession.value = null;\n      }\n    });\n  }\n\n  get navigationSession(): NavigationSession {\n    return this._navigationSession.value;\n  }\n\n  pushParameterChangesToRoute(activatedRoute: ActivatedRoute, previous: ParameterSnapshot, next: ParameterSnapshot) {\n    const relativePath = !!previous.hasRouteId() ? '..' : '.';\n    this.router.navigate([relativePath].concat(this.createRouteParameters(next), this.getChildPath(activatedRoute.snapshot)), {\n      relativeTo: activatedRoute\n    });\n  }\n\n  // @Trace()\n  getRedirectUrlTree(activatedRoute: ActivatedRouteSnapshot, sanitised: ParameterSnapshot): UrlTree {\n    const urlSegments = activatedRoute.url;\n    const weHaveARouteId = sanitised.hasRouteId() && sanitised.getFormattedRouteId();\n    const commands = (weHaveARouteId) ?\n      [urlSegments[0].path, sanitised.getFormattedRouteId(), sanitised.getFormattedParameters()] :\n      [urlSegments[0].path, sanitised.getFormattedParameters()];\n    return this.router.createUrlTree(commands);\n  }\n\n  protected getChildPath(activatedRoute: ActivatedRouteSnapshot): any[] {\n    return _.flatten(activatedRoute.children.map(child => child.url));\n  }\n\n  protected createRouteParameters(parameters: ParameterSnapshot): any[] {\n    const routeId = parameters.getFormattedRouteId();\n    return routeId ?\n      [routeId, parameters.getFormattedParameters()] :\n      [parameters.getFormattedParameters()];\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"place-router.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/place/place-router.ts"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Injectable } from '@angular/core';\nimport {\n  ActivatedRoute,\n  ActivatedRouteSnapshot,\n  NavigationEnd,\n  NavigationError,\n  NavigationStart,\n  Router\n} from '@angular/router';\nimport {\n  BooleanValueModelChain,\n  Dsl,\n  GarbageCollector,\n  HasOneIndexChain,\n  ListModel,\n  MutableListModel,\n  MutableValueModel,\n  Trace,\n  ValueModel\n} from '@coolon/pectin';\nimport _ from 'lodash';\nimport { NavigationSession } from './navigation-session';\nimport { PlaceHistory } from './place-history';\nimport { Visit } from './visit';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PlaceRouter extends GarbageCollector {\n\n  private firstRoute = true;\n\n  private readonly _navigationSessionModel = new MutableValueModel<NavigationSession>();\n  private readonly _activeVisits = new MutableListModel<Visit>();\n\n  readonly navigationSessionActive: BooleanValueModelChain;\n  readonly activeVisitIndex: HasOneIndexChain<'placeDefinition', Visit>;\n\n  constructor(private readonly router: Router, readonly angularLocation: Location, readonly placeHistory: PlaceHistory) {\n    super();\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n    this.activeVisitIndex = chain(this._activeVisits).indexBy('placeDefinition');\n\n    angularLocation.onUrlChange(url => {\n      console.log(`location.onUrlChange -> ${url}`);\n    });\n\n    // TODO: make setup the callbacks in during module initiation to make this testable.\n    this.router.events.subscribe(event => {\n      // Routing event sequence\n      // ======================\n      // NavigationStart -> .... -> NavigationCancel --> redirect, go around again in the same session\n      // NavigationStart -> .... -> NavigationEnd --> navigation complete, end session.\n      // NavigationStart -> .... -> NavigationError --> navigation canceled, end session.\n      // =======================\n      if (event instanceof NavigationStart) {\n        this.onAngularRouterStarted(event);\n      }\n      if (event instanceof NavigationEnd || event instanceof NavigationError) {\n        this.onAngularRouterFinished();\n      }\n    });\n\n    this.navigationSessionActive = chain(this.navigationSessionModel).isNotNil();\n    this.navigationSessionActive.subscribe(active => {\n      console.log('navigationSessionActive', active);\n    });\n    // const txo = new TransactionObserver().onEvent(e => console.log(e.toString()));\n    // txo.observe('this.navigationSessionModel', this.navigationSessionModel);\n  }\n\n  get navigationSession(): NavigationSession {\n    return this._navigationSessionModel.value;\n  }\n\n  get navigationSessionModel(): ValueModel<NavigationSession> {\n    return this._navigationSessionModel.readonly;\n  }\n\n  get activeVisits(): ListModel<Visit> {\n    return this._activeVisits.readonly;\n  }\n\n  /**\n   *  placeRouter.navigate(placeDestinations.somePlace.createVisit(routeId, ...visitParams));\n   * @param visit\n   */\n  // @Trace()\n  async navigate(visit: Visit) {\n    this.doNavigation(visit);\n  }\n\n  @Trace()\n  async pushVisitChangesToRoute(activatedRoute: ActivatedRoute, previous: Visit, next: Visit) {\n    // FIXME: no route id -> route id duplicates route parameters\n    if (next.hasRoutingChangedFrom(previous)) {\n      return this.doNavigation(next, router => {\n        const relativePath = !!previous.placeDefinition.hasRouteId() ? '..' : '.';\n        const def = next.placeDefinition;\n        const params = next.hasRouteId() ?\n          [def.getFormattedRouteId(next), def.getFormattedRouteParameters(next)] :\n          [def.getFormattedRouteParameters(next)];\n        const commands = [relativePath].concat(params, this.getChildPath(activatedRoute.snapshot));\n        console.log('### Redirect', commands);\n        return router.navigate(commands, {\n          relativeTo: activatedRoute\n        });\n      });\n    } else {\n      this.placeHistory.add(next);\n    }\n  }\n\n  async doNavigation(visit: Visit, customNavigation?: (router: Router) => any) {\n    this._navigationSessionModel.value = NavigationSession.createInternal(visit);\n    try {\n      if (customNavigation) {\n        await customNavigation(this.router);\n      } else {\n        const def = visit.placeDefinition;\n        const parameterCommands = visit.hasRouteId() ?\n          [def.getFormattedRouteId(visit), def.getFormattedRouteParameters(visit)] :\n          [def.getFormattedRouteParameters(visit)];\n        const commands = [def.path].concat(parameterCommands);\n        console.log('_doNavigation', visit, commands);\n        await this.router.navigate(commands);\n      }\n    } finally {\n      if (this.navigationSession && !this.router.getCurrentNavigation()) {\n        this.onAngularRouterFinished();\n      }\n    }\n  }\n\n  // @Trace()\n  private onAngularRouterStarted(event: NavigationStart) {\n    if (!this.navigationSession) { // We been activated by an external route rather than placeRouter.go(visit)\n      console.log('navigation started', { firstTime: this.firstRoute });\n      const session = NavigationSession.createExternal(this.firstRoute);\n      if (event.navigationTrigger === 'popstate') {\n        session.setPopstateReturn(this.router.routerState.snapshot.url);\n      }\n      this._navigationSessionModel.value = session;\n    }\n    this.firstRoute = false;\n  }\n\n  // @Trace()\n  private onAngularRouterFinished() {\n    const session = this._navigationSessionModel.value;\n    // Update visits before we end the navigation session.  This allows the place out let to\n    // gate ignore changes that occur while the visit is active\n    const visits = session.getVisits();\n    visits.forEach(v => {\n      this.placeHistory.add(v);\n    });\n    this._activeVisits.value = visits;\n\n    this._navigationSessionModel.value = null;\n  }\n\n  getChildPath(activatedRoute: ActivatedRouteSnapshot): any[] {\n    return _.flatten(activatedRoute.children.map(child => child.url));\n  }\n}\n"]}

package/esm2015/lib/place/route/formatter.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import _ from 'lodash';
+// WARNING: interface has both a type and a value, skipping emit
+export var Formatter;
+(function (Formatter) {
+    class StringType {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        format(value) {
+            return value;
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        parse(value) {
+            return value;
+        }
+    }
+    class NumberType {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        format(value) {
+            return _.isNumber(value) && !_.isNaN(value) ? `${value}` : null;
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        parse(value) {
+            /** @type {?} */
+            const parsed = Number.parseFloat(value);
+            return _.isNaN(parsed) ? null : parsed;
+        }
+    }
+    class BooleanType {
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        format(value) {
+            return value ? 'true' : 'false';
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        parse(value) {
+            return value === 'true';
+        }
+    }
+    Formatter.STRING = new StringType();
+    Formatter.NUMBER = new NumberType();
+    Formatter.BOOLEAN = new BooleanType();
+})(Formatter || (Formatter = {}));
+//# sourceMappingURL=data:application/json;base64,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