@nativescript/core 8.9.0-napi-es5.0 → 8.9.0-napi.1

package/application/application-common.js

@@ -8,23 +8,22 @@ import { Trace } from '../trace';
 import { Builder } from '../ui/builder';
 import * as bindableResources from '../ui/core/bindable/bindable-resources';
 // prettier-ignore
-var ORIENTATION_CSS_CLASSES = [
-    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.portrait),
-    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.landscape),
-    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.DeviceOrientation.unknown),
+const ORIENTATION_CSS_CLASSES = [
+    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.portrait}`,
+    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.landscape}`,
+    `${CSSUtils.CLASS_PREFIX}${CoreTypes.DeviceOrientation.unknown}`,
 ];
 // prettier-ignore
-var SYSTEM_APPEARANCE_CSS_CLASSES = [
-    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.SystemAppearance.light),
-    "".concat(CSSUtils.CLASS_PREFIX).concat(CoreTypes.SystemAppearance.dark),
+const SYSTEM_APPEARANCE_CSS_CLASSES = [
+    `${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.light}`,
+    `${CSSUtils.CLASS_PREFIX}${CoreTypes.SystemAppearance.dark}`,
 ];
-var globalEvents = global.NativeScriptGlobals.events;
-var ApplicationCommon = /** @class */ (function () {
+const globalEvents = global.NativeScriptGlobals.events;
+export class ApplicationCommon {
     /**
      * @internal - should not be constructed by the user.
      */
-    function ApplicationCommon() {
-        var _this = this;
+    constructor() {
         this.launchEvent = 'launch';
         this.suspendEvent = 'suspend';
         this.displayedEvent = 'displayed';
@@ -57,43 +56,43 @@ var ApplicationCommon = /** @class */ (function () {
         this._suspended = false;
         this.started = false;
         global.NativeScriptGlobals.appInstanceReady = true;
-        global.__onUncaughtError = function (error) {
-            _this.notify({
-                eventName: _this.uncaughtErrorEvent,
-                object: _this,
+        global.__onUncaughtError = (error) => {
+            this.notify({
+                eventName: this.uncaughtErrorEvent,
+                object: this,
                 android: error,
                 ios: error,
                 error: error,
             });
         };
-        global.__onDiscardedError = function (error) {
-            _this.notify({
-                eventName: _this.discardedErrorEvent,
-                object: _this,
+        global.__onDiscardedError = (error) => {
+            this.notify({
+                eventName: this.discardedErrorEvent,
+                object: this,
                 error: error,
             });
         };
-        global.__onLiveSync = function (context) {
-            if (_this.suspended) {
+        global.__onLiveSync = (context) => {
+            if (this.suspended) {
                 return;
             }
-            var rootView = _this.getRootView();
-            _this.livesync(rootView, context);
+            const rootView = this.getRootView();
+            this.livesync(rootView, context);
         };
     }
     /**
      * @internal
      */
-    ApplicationCommon.prototype.livesync = function (rootView, context) {
+    livesync(rootView, context) {
         this.notify({ eventName: this.livesyncEvent, object: this });
-        var liveSyncCore = global.__onLiveSyncCore;
-        var reapplyAppStyles = false;
+        const liveSyncCore = global.__onLiveSyncCore;
+        let reapplyAppStyles = false;
         // ModuleContext is available only for Hot Module Replacement
         if (context && context.path) {
-            var styleExtensions = ['css', 'scss'];
-            var appStylesFullFileName = this.getCssFileName();
-            var appStylesFileName_1 = appStylesFullFileName.substring(0, appStylesFullFileName.lastIndexOf('.') + 1);
-            reapplyAppStyles = styleExtensions.some(function (ext) { return context.path === appStylesFileName_1.concat(ext); });
+            const styleExtensions = ['css', 'scss'];
+            const appStylesFullFileName = this.getCssFileName();
+            const appStylesFileName = appStylesFullFileName.substring(0, appStylesFullFileName.lastIndexOf('.') + 1);
+            reapplyAppStyles = styleExtensions.some((ext) => context.path === appStylesFileName.concat(ext));
         }
         // Handle application styles
         if (rootView && reapplyAppStyles) {
@@ -102,7 +101,7 @@ var ApplicationCommon = /** @class */ (function () {
         else if (liveSyncCore) {
             liveSyncCore(context);
         }
-    };
+    }
     /**
      * Applies the the `newCssClass` to the `rootView` and removes all other css classes from `cssClasses`
      * previously applied to the `rootView`.
@@ -111,64 +110,61 @@ var ApplicationCommon = /** @class */ (function () {
      * @param newCssClass
      * @param skipCssUpdate
      */
-    ApplicationCommon.prototype.applyCssClass = function (rootView, cssClasses, newCssClass, skipCssUpdate) {
-        var _this = this;
-        if (skipCssUpdate === void 0) { skipCssUpdate = false; }
+    applyCssClass(rootView, cssClasses, newCssClass, skipCssUpdate = false) {
         if (!rootView.cssClasses.has(newCssClass)) {
-            cssClasses.forEach(function (cssClass) { return _this.removeCssClass(rootView, cssClass); });
+            cssClasses.forEach((cssClass) => this.removeCssClass(rootView, cssClass));
             this.addCssClass(rootView, newCssClass);
             this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
             if (!skipCssUpdate) {
                 rootView._onCssStateChange();
             }
             if (Trace.isEnabled()) {
-                var rootCssClasses = Array.from(rootView.cssClasses);
-                Trace.write("Applying root css class: ".concat(newCssClass, ". rootView css classes: ").concat(rootCssClasses.join(' ')), Trace.categories.Style);
+                const rootCssClasses = Array.from(rootView.cssClasses);
+                Trace.write(`Applying root css class: ${newCssClass}. rootView css classes: ${rootCssClasses.join(' ')}`, Trace.categories.Style);
             }
         }
-    };
-    ApplicationCommon.prototype.addCssClass = function (rootView, cssClass) {
+    }
+    addCssClass(rootView, cssClass) {
         CSSUtils.pushToSystemCssClasses(cssClass);
         rootView.cssClasses.add(cssClass);
-    };
-    ApplicationCommon.prototype.removeCssClass = function (rootView, cssClass) {
+    }
+    removeCssClass(rootView, cssClass) {
         CSSUtils.removeSystemCssClass(cssClass);
         rootView.cssClasses.delete(cssClass);
-    };
-    ApplicationCommon.prototype.increaseStyleScopeApplicationCssSelectorVersion = function (rootView) {
-        var _a, _b;
-        var styleScope = (_a = rootView._styleScope) !== null && _a !== void 0 ? _a : (_b = rootView === null || rootView === void 0 ? void 0 : rootView.currentPage) === null || _b === void 0 ? void 0 : _b._styleScope;
+    }
+    increaseStyleScopeApplicationCssSelectorVersion(rootView) {
+        const styleScope = rootView._styleScope ?? rootView?.currentPage?._styleScope;
         if (styleScope) {
             styleScope._increaseApplicationCssSelectorVersion();
         }
-    };
-    ApplicationCommon.prototype.setRootViewCSSClasses = function (rootView) {
-        var platform = Device.os.toLowerCase();
-        var deviceType = Device.deviceType.toLowerCase();
-        var orientation = this.orientation();
-        var systemAppearance = this.systemAppearance();
+    }
+    setRootViewCSSClasses(rootView) {
+        const platform = Device.os.toLowerCase();
+        const deviceType = Device.deviceType.toLowerCase();
+        const orientation = this.orientation();
+        const systemAppearance = this.systemAppearance();
         if (platform) {
-            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(platform));
+            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${platform}`);
         }
         if (deviceType) {
-            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(deviceType));
+            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${deviceType}`);
         }
         if (orientation) {
-            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(orientation));
+            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${orientation}`);
         }
         if (systemAppearance) {
-            CSSUtils.pushToSystemCssClasses("".concat(CSSUtils.CLASS_PREFIX).concat(systemAppearance));
+            CSSUtils.pushToSystemCssClasses(`${CSSUtils.CLASS_PREFIX}${systemAppearance}`);
         }
         rootView.cssClasses.add(CSSUtils.ROOT_VIEW_CSS_CLASS);
-        var rootViewCssClasses = CSSUtils.getSystemCssClasses();
-        rootViewCssClasses.forEach(function (c) { return rootView.cssClasses.add(c); });
+        const rootViewCssClasses = CSSUtils.getSystemCssClasses();
+        rootViewCssClasses.forEach((c) => rootView.cssClasses.add(c));
         this.increaseStyleScopeApplicationCssSelectorVersion(rootView);
         rootView._onCssStateChange();
         if (Trace.isEnabled()) {
-            var rootCssClasses = Array.from(rootView.cssClasses);
-            Trace.write("Setting root css classes: ".concat(rootCssClasses.join(' ')), Trace.categories.Style);
+            const rootCssClasses = Array.from(rootView.cssClasses);
+            Trace.write(`Setting root css classes: ${rootCssClasses.join(' ')}`, Trace.categories.Style);
         }
-    };
+    }
     /**
      * iOS Only
      * Dynamically change the preferred frame rate
@@ -182,24 +178,29 @@ var ApplicationCommon = /** @class */ (function () {
      * ```
      * @param options { min?: number; max?: number; preferred?: number }
      */
-    ApplicationCommon.prototype.setMaxRefreshRate = function (options) {
+    setMaxRefreshRate(options) {
         // implement in platform specific files (iOS only for now)
-    };
+    }
     /**
      * @returns The main entry of the application
      */
-    ApplicationCommon.prototype.getMainEntry = function () {
+    getMainEntry() {
         return this.mainEntry;
-    };
-    ApplicationCommon.prototype.notifyLaunch = function (additionalLanchEventData) {
-        var launchArgs = __assign({ eventName: this.launchEvent, object: this, ios: this.ios, android: this.android }, additionalLanchEventData);
+    }
+    notifyLaunch(additionalLanchEventData) {
+        const launchArgs = {
+            eventName: this.launchEvent,
+            object: this,
+            ios: this.ios,
+            android: this.android,
+            ...additionalLanchEventData,
+        };
         this.notify(launchArgs);
         this.loadAppCss();
         return launchArgs.root;
-    };
-    ApplicationCommon.prototype.createRootView = function (view, fireLaunchEvent, additionalLanchEventData) {
-        if (fireLaunchEvent === void 0) { fireLaunchEvent = false; }
-        var rootView = view;
+    }
+    createRootView(view, fireLaunchEvent = false, additionalLanchEventData) {
+        let rootView = view;
         if (!rootView) {
             if (fireLaunchEvent) {
                 rootView = this.notifyLaunch(additionalLanchEventData);
@@ -217,56 +218,56 @@ var ApplicationCommon = /** @class */ (function () {
             }
         }
         return rootView;
-    };
-    ApplicationCommon.prototype.getRootView = function () {
+    }
+    getRootView() {
         throw new Error('getRootView() Not implemented.');
-    };
-    ApplicationCommon.prototype.resetRootView = function (entry) {
+    }
+    resetRootView(entry) {
         this.mainEntry = typeof entry === 'string' ? { moduleName: entry } : entry;
         // rest of implementation is platform specific
-    };
-    ApplicationCommon.prototype.initRootView = function (rootView) {
+    }
+    initRootView(rootView) {
         this.setRootViewCSSClasses(rootView);
         initAccessibilityCssHelper();
         initAccessibilityFontScale();
-        this.notify({ eventName: this.initRootViewEvent, rootView: rootView });
-    };
+        this.notify({ eventName: this.initRootViewEvent, rootView });
+    }
     /**
      * Get application level static resources.
      */
-    ApplicationCommon.prototype.getResources = function () {
+    getResources() {
         return bindableResources.get();
-    };
+    }
     /**
      * Set application level static resources.
      */
-    ApplicationCommon.prototype.setResources = function (res) {
+    setResources(res) {
         bindableResources.set(res);
-    };
+    }
     /**
      * Sets css file name for the application.
      */
-    ApplicationCommon.prototype.setCssFileName = function (cssFileName) {
+    setCssFileName(cssFileName) {
         this.cssFile = cssFileName;
         this.notify({
             eventName: this.cssChangedEvent,
             object: this,
             cssFile: cssFileName,
         });
-    };
+    }
     /**
      * Gets css file name for the application.
      */
-    ApplicationCommon.prototype.getCssFileName = function () {
+    getCssFileName() {
         return this.cssFile;
-    };
+    }
     /**
      * Loads immediately the app.css.
      * By default the app.css file is loaded shortly after "loaded".
      * For the Android snapshot the CSS can be parsed during the snapshot generation,
      * as the CSS does not depend on runtime APIs, and loadAppCss will be called explicitly.
      */
-    ApplicationCommon.prototype.loadAppCss = function () {
+    loadAppCss() {
         try {
             this.notify({
                 eventName: this.loadAppCssEvent,
@@ -278,31 +279,31 @@ var ApplicationCommon = /** @class */ (function () {
         }
         catch (e) {
             if (Trace.isEnabled()) {
-                Trace.write("The app CSS file ".concat(this.getCssFileName(), " couldn't be loaded!"), Trace.categories.Style, Trace.messageType.warn);
+                Trace.write(`The app CSS file ${this.getCssFileName()} couldn't be loaded!`, Trace.categories.Style, Trace.messageType.warn);
             }
         }
-    };
-    ApplicationCommon.prototype.addCss = function (cssText, attributeScoped) {
+    }
+    addCss(cssText, attributeScoped) {
         this.notify({
             eventName: this.cssChangedEvent,
             object: this,
             cssText: cssText,
         });
         if (!attributeScoped) {
-            var rootView = this.getRootView();
+            const rootView = this.getRootView();
             if (rootView) {
                 rootView._onCssStateChange();
             }
         }
-    };
-    ApplicationCommon.prototype.run = function (entry) {
+    }
+    run(entry) {
         throw new Error('run() Not implemented.');
-    };
-    ApplicationCommon.prototype.getOrientation = function () {
+    }
+    getOrientation() {
         // override in platform specific Application class
         throw new Error('getOrientation() not implemented');
-    };
-    ApplicationCommon.prototype.setOrientation = function (value) {
+    }
+    setOrientation(value) {
         if (this._orientation === value) {
             return;
         }
@@ -318,39 +319,37 @@ var ApplicationCommon = /** @class */ (function () {
             newValue: value,
             object: this,
         });
-    };
-    ApplicationCommon.prototype.orientation = function () {
-        var _a;
-        return ((_a = this._orientation) !== null && _a !== void 0 ? _a : (this._orientation = this.getOrientation()));
-    };
-    ApplicationCommon.prototype.orientationChanged = function (rootView, newOrientation) {
-        var _this = this;
+    }
+    orientation() {
+        return (this._orientation ?? (this._orientation = this.getOrientation()));
+    }
+    orientationChanged(rootView, newOrientation) {
         if (!rootView) {
             return;
         }
-        var newOrientationCssClass = "".concat(CSSUtils.CLASS_PREFIX).concat(newOrientation);
+        const newOrientationCssClass = `${CSSUtils.CLASS_PREFIX}${newOrientation}`;
         this.applyCssClass(rootView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
-        var rootModalViews = rootView._getRootModalViews();
-        rootModalViews.forEach(function (rootModalView) {
-            _this.applyCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
+        const rootModalViews = rootView._getRootModalViews();
+        rootModalViews.forEach((rootModalView) => {
+            this.applyCssClass(rootModalView, ORIENTATION_CSS_CLASSES, newOrientationCssClass, true);
             // Trigger state change for root modal view classes and media queries
             rootModalView._onCssStateChange();
         });
         // Trigger state change for root view classes and media queries
         rootView._onCssStateChange();
-    };
-    ApplicationCommon.prototype.getNativeApplication = function () {
+    }
+    getNativeApplication() {
         // override in platform specific Application class
         throw new Error('getNativeApplication() not implemented');
-    };
-    ApplicationCommon.prototype.hasLaunched = function () {
+    }
+    hasLaunched() {
         return global.NativeScriptGlobals && global.NativeScriptGlobals.launched;
-    };
-    ApplicationCommon.prototype.getSystemAppearance = function () {
+    }
+    getSystemAppearance() {
         // override in platform specific Application class
         throw new Error('getSystemAppearance() not implemented');
-    };
-    ApplicationCommon.prototype.setSystemAppearance = function (value) {
+    }
+    setSystemAppearance(value) {
         if (this._systemAppearance === value) {
             return;
         }
@@ -363,123 +362,106 @@ var ApplicationCommon = /** @class */ (function () {
             newValue: value,
             object: this,
         });
-    };
-    ApplicationCommon.prototype.systemAppearance = function () {
-        var _a;
+    }
+    systemAppearance() {
         // return cached value, or get it from the platform specific override
-        return ((_a = this._systemAppearance) !== null && _a !== void 0 ? _a : (this._systemAppearance = this.getSystemAppearance()));
-    };
+        return (this._systemAppearance ?? (this._systemAppearance = this.getSystemAppearance()));
+    }
     /**
      * enable/disable systemAppearanceChanged
      */
-    ApplicationCommon.prototype.setAutoSystemAppearanceChanged = function (value) {
+    setAutoSystemAppearanceChanged(value) {
         this.autoSystemAppearanceChanged = value;
-    };
+    }
     /**
      * Updates root view classes including those of modals
      * @param rootView the root view
      * @param newSystemAppearance the new appearance change
      */
-    ApplicationCommon.prototype.systemAppearanceChanged = function (rootView, newSystemAppearance) {
-        var _this = this;
+    systemAppearanceChanged(rootView, newSystemAppearance) {
         if (!rootView || !this.autoSystemAppearanceChanged) {
             return;
         }
-        var newSystemAppearanceCssClass = "".concat(CSSUtils.CLASS_PREFIX).concat(newSystemAppearance);
+        const newSystemAppearanceCssClass = `${CSSUtils.CLASS_PREFIX}${newSystemAppearance}`;
         this.applyCssClass(rootView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
-        var rootModalViews = rootView._getRootModalViews();
-        rootModalViews.forEach(function (rootModalView) {
-            _this.applyCssClass(rootModalView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
+        const rootModalViews = rootView._getRootModalViews();
+        rootModalViews.forEach((rootModalView) => {
+            this.applyCssClass(rootModalView, SYSTEM_APPEARANCE_CSS_CLASSES, newSystemAppearanceCssClass, true);
             // Trigger state change for root modal view classes and media queries
             rootModalView._onCssStateChange();
         });
         // Trigger state change for root view classes and media queries
         rootView._onCssStateChange();
-    };
-    Object.defineProperty(ApplicationCommon.prototype, "inBackground", {
-        get: function () {
-            return this._inBackground;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ApplicationCommon.prototype.setInBackground = function (value, additonalData) {
+    }
+    get inBackground() {
+        return this._inBackground;
+    }
+    setInBackground(value, additonalData) {
         this._inBackground = value;
-        this.notify(__assign({ eventName: value ? this.backgroundEvent : this.foregroundEvent, object: this, ios: this.ios }, additonalData));
-    };
-    Object.defineProperty(ApplicationCommon.prototype, "suspended", {
-        get: function () {
-            return this._suspended;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ApplicationCommon.prototype.setSuspended = function (value, additonalData) {
+        this.notify({
+            eventName: value ? this.backgroundEvent : this.foregroundEvent,
+            object: this,
+            ios: this.ios,
+            ...additonalData,
+        });
+    }
+    get suspended() {
+        return this._suspended;
+    }
+    setSuspended(value, additonalData) {
         this._suspended = value;
-        this.notify(__assign({ eventName: value ? this.suspendEvent : this.resumeEvent, object: this, ios: this.ios, android: this.android }, additonalData));
-    };
-    Object.defineProperty(ApplicationCommon.prototype, "android", {
-        get: function () {
-            return undefined;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ApplicationCommon.prototype, "ios", {
-        get: function () {
-            return undefined;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ApplicationCommon.prototype, "AndroidApplication", {
-        get: function () {
-            return this.android;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ApplicationCommon.prototype, "iOSApplication", {
-        get: function () {
-            return this.ios;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    // Expose statically for backwards compat on AndroidApplication.on etc.
-    /**
-     * @deprecated Use `Application.android.on()` instead.
-     */
-    ApplicationCommon.on = globalEvents.on.bind(globalEvents);
-    /**
-     * @deprecated Use `Application.android.once()` instead.
-     */
-    ApplicationCommon.once = globalEvents.once.bind(globalEvents);
-    /**
-     * @deprecated Use `Application.android.off()` instead.
-     */
-    ApplicationCommon.off = globalEvents.off.bind(globalEvents);
-    /**
-     * @deprecated Use `Application.android.notify()` instead.
-     */
-    ApplicationCommon.notify = globalEvents.notify.bind(globalEvents);
-    /**
-     * @deprecated Use `Application.android.hasListeners()` instead.
-     */
-    ApplicationCommon.hasListeners = globalEvents.hasListeners.bind(globalEvents);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", Function)
-    ], ApplicationCommon.prototype, "notifyLaunch", null);
-    __decorate([
-        profile,
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Function, Object, Object]),
-        __metadata("design:returntype", void 0)
-    ], ApplicationCommon.prototype, "createRootView", null);
-    return ApplicationCommon;
-}());
-export { ApplicationCommon };
+        this.notify({
+            eventName: value ? this.suspendEvent : this.resumeEvent,
+            object: this,
+            ios: this.ios,
+            android: this.android,
+            ...additonalData,
+        });
+    }
+    get android() {
+        return undefined;
+    }
+    get ios() {
+        return undefined;
+    }
+    get AndroidApplication() {
+        return this.android;
+    }
+    get iOSApplication() {
+        return this.ios;
+    }
+}
+// Expose statically for backwards compat on AndroidApplication.on etc.
+/**
+ * @deprecated Use `Application.android.on()` instead.
+ */
+ApplicationCommon.on = globalEvents.on.bind(globalEvents);
+/**
+ * @deprecated Use `Application.android.once()` instead.
+ */
+ApplicationCommon.once = globalEvents.once.bind(globalEvents);
+/**
+ * @deprecated Use `Application.android.off()` instead.
+ */
+ApplicationCommon.off = globalEvents.off.bind(globalEvents);
+/**
+ * @deprecated Use `Application.android.notify()` instead.
+ */
+ApplicationCommon.notify = globalEvents.notify.bind(globalEvents);
+/**
+ * @deprecated Use `Application.android.hasListeners()` instead.
+ */
+ApplicationCommon.hasListeners = globalEvents.hasListeners.bind(globalEvents);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Function)
+], ApplicationCommon.prototype, "notifyLaunch", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function, Object, Object]),
+    __metadata("design:returntype", void 0)
+], ApplicationCommon.prototype, "createRootView", null);
 //# sourceMappingURL=application-common.js.map