@nativescript/angular 21.0.1-alpha.1 → 21.0.1-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/angular",
-  "version": "21.0.1-alpha.1",
+  "version": "21.0.1-alpha.3",
   "homepage": "https://nativescript.org/",
   "repository": {
     "type": "git",

package/types/nativescript-angular.d.ts

@@ -4,7 +4,7 @@ import * as i0 from '@angular/core';
 import { InjectionToken, EmbeddedViewRef, ComponentRef, NgModuleRef, ApplicationRef, Provider, EnvironmentProviders, PlatformRef, ɵNgModuleFactory as _NgModuleFactory, Type, CompilerOptions, NgZone, Injector, NgModuleFactory, StaticProvider, Sanitizer, ApplicationConfig as ApplicationConfig$1, ViewContainerRef, ComponentFactoryResolver, TemplateRef, ElementRef, OnInit, OnDestroy, Renderer2, EventEmitter, ChangeDetectorRef, ComponentFactory, AfterViewInit, OnChanges, SimpleChanges, DoCheck, AfterContentInit, IterableDiffer, IterableDiffers, ErrorHandler, RendererStyleFlags2, RendererType2, RendererFactory2, QueryList, EnvironmentInjector, ModuleWithProviders, NgZoneOptions } from '@angular/core';
 import * as _nativescript_angular from '@nativescript/angular';
 import * as rxjs from 'rxjs';
-import { Observable, Subject, BehaviorSubject } from 'rxjs';
+import { Observable, ReplaySubject, Subject, BehaviorSubject } from 'rxjs';
 import * as i1 from '@angular/common';
 import { LocationStrategy, XhrFactory } from '@angular/common';
 import * as i1$2 from '@angular/router';
@@ -170,7 +170,17 @@ type NgModuleEvent = {
     reason: NgModuleReason | string;
 };
 declare const preAngularDisposal$: Subject<NgModuleEvent>;
-declare const postAngularBootstrap$: Subject<NgModuleEvent>;
+/**
+ * Stream that emits when an Angular module finishes bootstrapping. Modeled
+ * as a `ReplaySubject(1)` so consumers (e.g. `NativeDialog`) instantiated
+ * lazily — *after* the bootstrap event has already fired — still receive
+ * the latest event and can react. Without buffering, a service that the
+ * user app injects on first need (after bootstrap) would silently miss the
+ * `hotreload` notification and skip HMR-only work like restoring captured
+ * modal state. The buffer size of 1 means each new HMR cycle replaces the
+ * cached event so cycle N's late subscribers don't see cycle N-1's event.
+ */
+declare const postAngularBootstrap$: ReplaySubject<NgModuleEvent>;
 /**
  * @deprecated
  */
@@ -1084,6 +1094,22 @@ declare class NativeDialogConfig<D = any> {
     /** Alternate `ComponentFactoryResolver` to use when resolving the associated component. */
     componentFactoryResolver?: ComponentFactoryResolver;
     nativeOptions?: NativeShowModalOptions;
+    /**
+     * When true, this dialog will be re-opened automatically on Angular HMR
+     * reboots so the user does not lose context every time a related file
+     * changes. The new dialog reuses the same component class and `data` payload
+     * (provided via `data`); other config such as `nativeOptions` is preserved
+     * verbatim.
+     *
+     * The original `dialogRef.afterClosed()` subject is wired to the restored
+     * dialog so consumers `await openModal(...)` resolve normally when the user
+     * eventually closes the restored modal.
+     *
+     * Only opens via component class are restorable — `TemplateRef` openings
+     * carry references that don't survive an HMR reboot and are silently
+     * skipped. Has no effect outside of HMR.
+     */
+    preserveOnHmr?: boolean;
 }
 
 declare class FrameService {
@@ -1283,9 +1309,24 @@ declare const NATIVE_DIALOG_DEFAULT_OPTIONS: InjectionToken<NativeDialogConfig<a
  * for arbitrary dialog refs and dialog container components.
  */
 declare class NativeDialog implements OnDestroy {
+    /**
+     * Diagnostic instance id. We tag each constructor with a number so
+     * the logs make it obvious when a stale `NativeDialog` keeps
+     * receiving events after a reboot (e.g. due to a leaked subscription
+     * or a service from a previous realm being kept alive).
+     */
+    private readonly _diagInstanceId;
     private _openDialogsAtThisLevel;
     private readonly _afterAllClosedAtThisLevel;
     private readonly _afterOpenedAtThisLevel;
+    /**
+     * Maps each open dialog ref back to the `(componentClass, config)` pair it
+     * was opened with so the HMR snapshot can replay the call later. Dialogs
+     * opened with a `TemplateRef` are tracked with `componentClass: undefined`
+     * — the HMR layer skips them automatically.
+     */
+    private readonly _openDialogMetadata;
+    private _hmrSubscriptions;
     /**
      * Stream that emits when all open dialog have finished closing.
      * Will emit on subscribe if there are no open dialogs to begin with.
@@ -1303,6 +1344,8 @@ declare class NativeDialog implements OnDestroy {
     private _nativeModalType;
     private _dialogDataToken;
     private locationStrategy;
+    private _diagInstanceIdAssign;
+    private _hmrInitMarker;
     /**
      * Opens a modal dialog containing the given component.
      * @param component Type of the component to load into the dialog.
@@ -1328,6 +1371,128 @@ declare class NativeDialog implements OnDestroy {
      */
     getDialogById(id: string): NativeDialogRef<any> | undefined;
     ngOnDestroy(): void;
+    /**
+     * Tracks whether a restore has already been scheduled for this
+     * `NativeDialog` instance's lifetime. We only need to restore once
+     * per HMR cycle — the rxjs `ReplaySubject(1)` for
+     * `postAngularBootstrap$` delivers both the *previous* cycle's
+     * cached event (replay on subscribe) **and** the *current* cycle's
+     * fresh event, and the constructor stash peek can independently
+     * notice pending work. Without this guard each of those triggers
+     * would queue its own `setTimeout` and the logs would show two or
+     * three "scheduling restore" lines per save.
+     *
+     * The guard is per-instance and the stash itself is the source of
+     * truth: `_restorePendingDialogs` calls `consumePendingHmrDialogs()`
+     * which atomically clears the stash, so even if the guard somehow
+     * fired twice, only the first call would do real work.
+     */
+    private _restoreScheduledForThisInstance;
+    /**
+     * Wires up HMR capture/restore. Only the root-level dialog manages the
+     * stash so a stack of `NativeDialog` instances inside a child injector
+     * doesn't fight for it.
+     *
+     * Production short-circuit: `isAngularHmrEnabled()` returns `false` in
+     * release builds and when no NS Vite / webpack HMR runtime is present,
+     * so the long-lived subscriptions below never attach in shipping apps.
+     *
+     * `postAngularBootstrap$` is a `ReplaySubject(1)` (see `application.ts`)
+     * which means a `NativeDialog` instantiated *after* the bootstrap event
+     * has already fired (typical when the user app injects `NativeDialog`
+     * lazily via a service like `view.service.ts`) still receives the
+     * buffered event and runs the restore path.
+     */
+    private _initHmrLifecycle;
+    /**
+     * Schedule a restore exactly once per `NativeDialog` instance.
+     *
+     * The work is deferred to the next macrotask for two reasons:
+     *
+     *  1. `postAngularBootstrap$.next(...)` is fired from inside
+     *     `emitModuleBootstrapEvent`, which itself runs inside the
+     *     `bootstrapApplication` callback — so the call stack still
+     *     contains Angular's ApplicationRef bootstrap pipeline. Doing
+     *     `this.open(...)` synchronously re-entered Angular DI while a
+     *     `providedIn: 'root'` factory could still be on the resolution
+     *     stack, which surfaced as `NG0200: Circular dependency detected
+     *     for NativeDialog`. Yielding to a macrotask lets the bootstrap
+     *     stack fully unwind first.
+     *  2. The eventual `parent.showModal(...)` cannot present onto a
+     *     view controller whose view is not yet in the iOS window
+     *     hierarchy (see `_scheduleRestoreOpenWhenReady` for the second
+     *     wait stage); a synchronous attempt would silently no-op
+     *     because iOS rejects the present without throwing.
+     */
+    private _maybeScheduleRestore;
+    private _captureOpenDialogsForHmr;
+    /**
+     * Per-cycle guard to keep `_restorePendingDialogs` idempotent if more
+     * than one subscriber fires for the same bootstrap event. The
+     * regression we have seen (`postAngularBootstrap$ → restore` logged
+     * twice in the same hot reload) was caused by the `NativeDialogModule`
+     * also listing `NativeDialog` in its `providers` array. That has been
+     * removed, but we keep this flag as a defensive net so a future stray
+     * subscription does not consume the stash twice. The flag is reset
+     * after the consume so subsequent HMR cycles can run their own
+     * restore.
+     */
+    private _restoreInFlight;
+    private _restorePendingDialogs;
+    /**
+     * Resolve the freshest known class object for the captured component
+     * name and re-open the dialog through the normal `open` path, but
+     * only once the new root view is actually attached to the iOS window
+     * hierarchy.
+     *
+     * Why a class lookup at all: an HMR reboot calls
+     * `ɵresetCompiledComponents()` which clears each component's `ɵcmp`
+     * field but **leaves the class identity unchanged**. The patched
+     * `ɵɵdefineComponent` then re-registers the same class object under
+     * the same source name when Angular re-renders the component. A
+     * fresh-class lookup therefore returns either the same object the
+     * stash captured (most common) or, on the rare occasion that the
+     * source file's `@Component` decorator was re-evaluated into a brand
+     * new class object (e.g. the user added `@Component(...)` to a new
+     * exported symbol), the live one. Either way, a single check is
+     * enough — the previous retry schedule was a no-op in 100 % of
+     * observed cycles because the captured class IS the live class.
+     */
+    private _restoreSingleDialog;
+    /**
+     * Maximum time we'll wait for the new root view to attach to the
+     * iOS window before giving up and trying the open anyway. NS Vite's
+     * worst observed reboot-to-rootview-loaded gap is ~250 ms; one
+     * second leaves headroom for slower devices without leaving the
+     * captured dialog stuck in the stash if something genuinely goes
+     * wrong.
+     */
+    private static readonly _ROOT_VIEW_LOADED_TIMEOUT_MS;
+    /**
+     * Defer the actual `this.open(...)` call until the new root view's
+     * underlying iOS `UIViewController.view` is in the window hierarchy.
+     *
+     * iOS silently rejects `presentViewControllerAnimatedCompletion` if
+     * the parent controller's view is not yet attached to a `UIWindow`
+     * (see `view/index.ios.ts::_showNativeModalView`, which logs to
+     * `Trace` and returns without throwing). In dev that would surface
+     * as a vanished modal with no actionable error.
+     *
+     * NS marks a view as `isLoaded === true` from
+     * `UILayoutViewController.viewWillAppear`, which fires once iOS has
+     * decided to add the view to its window. Listening for the
+     * `loadedEvent` (one-shot) plus an extra macrotask gives UIKit a
+     * chance to finish window attachment before we present.
+     */
+    private _scheduleRestoreOpenWhenReady;
+    private _pollForRootView;
+    private _performRestoreOpen;
+    /**
+     * Test/debug helper: discard any captured modals without restoring them.
+     * Mostly useful when projects want to opt out of restoration without
+     * recompiling. Public callers should prefer `preserveOnHmr: false` instead.
+     */
+    static _clearPendingHmrDialogs(): void;
     /**
      * Attaches the user-provided component to the already-created dialog container.
      * @param componentOrTemplateRef The type of component being loaded into the dialog,
@@ -1383,6 +1548,32 @@ declare class NativeDialogCloseDirective implements OnInit, OnChanges {
     static ɵdir: i0.ɵɵDirectiveDeclaration<NativeDialogCloseDirective, "[native-dialog-close], [nativeDialogClose]", ["nativeDialogClose"], { "dialogResult": { "alias": "native-dialog-close"; "required": false; }; "_matDialogClose": { "alias": "nativeDialogClose"; "required": false; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Convenience module that re-exports the `NativeDialogCloseDirective` for
+ * template-driven `[nativeDialogClose]` usage.
+ *
+ * **Important**: `NativeDialog` itself is **not** listed in this module's
+ * `providers` array. The service is `@Injectable({ providedIn: 'root' })`,
+ * which already registers a single root-level instance and is fully
+ * tree-shakeable. Listing it here as well caused Angular to treat the
+ * module-level provider and the `providedIn: 'root'` factory as
+ * *separate* registrations once the module was pulled into a standalone
+ * app via `importProvidersFrom(NativeDialogModule, ...)`. The duplicate
+ * registration triggered:
+ *
+ *  - Two `NativeDialog` instances in the same root environment injector,
+ *    each subscribing to `postAngularBootstrap$`, which produced
+ *    duplicate restore attempts during HMR.
+ *  - `NG0200: Circular dependency detected for NativeDialog` while a
+ *    captured modal was being re-opened during HMR restore, because the
+ *    second resolution started while the first was still in progress.
+ *
+ * Removing the redundant entry collapses both providers back into a
+ * single root-level instance, which is what `providedIn: 'root'`
+ * documents. App authors who explicitly wire `NativeDialog` themselves
+ * (e.g. in a feature module's `providers`) keep working unchanged
+ * because they're targeting the same class symbol.
+ */
 declare class NativeDialogModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<NativeDialogModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<NativeDialogModule, never, [typeof NativeDialogCloseDirective], [typeof NativeDialogCloseDirective]>;
@@ -2076,6 +2267,35 @@ declare class NativeScriptRouterModule {
 declare function rootRoute(router: Router): ActivatedRoute;
 declare function provideNativeScriptRouter(routes: Routes, ...features: RouterFeatures[]): i0.EnvironmentProviders;
 
+/**
+ * True while the Angular HMR layer is restoring a captured route stack
+ * onto the freshly-bootstrapped router. The window opens just before
+ * `START_PATH` resolves to a deep URL and closes once the router has
+ * walked the entire forward navigation list (or aborted it).
+ *
+ * User-app code that runs default navigations on component init (e.g. a
+ * bottom-nav defaulting to its first tab) can consult this flag to skip
+ * its default navigation so the framework's restored route survives:
+ *
+ * ```ts
+ * if (isAngularHmrRestoringRoute()) {
+ *   return; // framework is restoring a deeper route — leave it alone.
+ * }
+ * defaultTabNavigation();
+ * ```
+ *
+ * Returns `false` outside of HMR or after the replay window has closed.
+ * Production builds always see `false` because the framework never
+ * opens the window there.
+ */
+declare function isAngularHmrRestoringRoute(): boolean;
+/**
+ * The target route the framework is currently restoring, or `null` when
+ * no replay is in progress. Useful when the consumer wants to compare
+ * against the current router URL.
+ */
+declare function getAngularHmrRestoringRoute(): string | null;
+
 declare class NativeScriptDebug {
     static readonly animationsTraceCategory = "ns-animations";
     static readonly rendererTraceCategory = "ns-renderer";
@@ -2084,6 +2304,7 @@ declare class NativeScriptDebug {
     static readonly routeReuseStrategyTraceCategory = "ns-route-reuse-strategy";
     static readonly listViewTraceCategory = "ns-list-view";
     static readonly bootstrapCategory = "bootstrap";
+    static readonly hmrTraceCategory = "ns-ng-hmr";
     static readonly enabled: boolean;
     static isLogEnabled(): boolean;
     static animationsLog(message: string): void;
@@ -2098,6 +2319,8 @@ declare class NativeScriptDebug {
     static listViewError(message: string): void;
     static bootstrapLog(message: string): void;
     static bootstrapLogError(message: string): void;
+    static hmrLog(message: string): void;
+    static hmrLogError(message: string): void;
 }
 
 /**
@@ -2257,5 +2480,5 @@ declare class NativeScriptNgZone implements NgZone {
 }
 declare function provideNativeScriptNgZone(options?: NgZoneOptions): i0.StaticProvider[];
 
-export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeDialogState, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getFirstNativeLikeView, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil_d as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
+export { APP_ROOT_VIEW, ActionBarComponent, ActionBarScope, ActionItemDirective, AndroidFilterComponent, AppHostAsyncView, AppHostView, AppleFilterComponent, BasePortalOutlet, BaseValueAccessor, COMMON_PROVIDERS, CdkPortal, CdkPortalOutlet, CheckedValueAccessor, CommentNode, ComponentPortal, DEVICE, DISABLE_ROOT_VIEW_HANDLING, DateValueAccessor, DetachedLoader, DomPortal, ENABLE_REUSABE_VIEWS, EmulatedRenderer, FrameDirective, FramePageComponent, FramePageModule, FrameService, IOSFilterComponent, InjectableAnimationEngine, InvisibleNode, ItemContext, ListViewComponent, ModalDialogParams, ModalDialogService, NAMESPACE_FILTERS, NATIVESCRIPT_MODULE_PROVIDERS, NATIVESCRIPT_MODULE_STATIC_PROVIDERS, NATIVESCRIPT_ROOT_MODULE_ID, NATIVE_DIALOG_DATA, NATIVE_DIALOG_DEFAULT_OPTIONS, NSEmptyOutletComponent, NSFileSystem, NSLocationStrategy, NSRouteReuseStrategy, NSRouterLink, NSRouterLinkActive, NativeDialog, NativeDialogCloseDirective, NativeDialogConfig, NativeDialogModule, NativeDialogRef, NativeDialog as NativeDialogService, NativeDialogState, NativeModalRef, NativeScriptAnimationDriver, NativeScriptAnimationPlayer, NativeScriptAnimationsModule, NativeScriptCommonModule, NativeScriptDocument, NativeScriptDomPortalOutlet, NativeScriptFormsModule, NativeScriptHttpClientModule, NativeScriptLoadingService, NativeScriptModule, NativeScriptNgSafeEvent, NativeScriptNgZone, NativeScriptRendererFactory, NativeScriptRendererHelperService, NativeScriptRouterModule, NativeScriptSanitizer, NativescriptXhrFactory, NavigationButtonDirective, NgViewRef, NsHttpBackEnd, NsTemplatedItem, NumberValueAccessor, Outlet, PAGE_FACTORY, PREVENT_CHANGE_EVENTS_DURING_CD, PREVENT_SPECIFIC_EVENTS_DURING_CD, PageDirective, PageRoute, PageRouterOutlet, PageService, PlatformNamespaceFilter, Portal, PortalModule, RootCompositeModule, RootViewProxy, RouterExtensions, START_PATH, SelectedIndexValueAccessor, TEMPLATED_ITEMS_COMPONENT, TabViewDirective, TabViewItemDirective, TemplateKeyDirective, TemplatePortal, TextNode, TextValueAccessor, TimeValueAccessor, VisionOSFilterComponent, bootstrapApplication, createKeyframeAnimation, customFrameComponentFactory, customFrameDirectiveFactory, customPageFactory, customPageFactoryFromFrame, dashCaseToCamelCase, defaultNavOptions, defaultPageFactory, defaultPageFactoryProvider, detachViewFromParent, disableRootViewHanding, errorHandler, extractSingleViewRecursive, frameMeta, generateDetachedLoader, generateFallbackRootView, generateNativeScriptView, generateRandomId, generateRootLayoutAndProxy, getAngularHmrRestoringRoute, getFirstNativeLikeView, getItemViewRoot, getSingleViewRecursive, getViewClass, getViewMeta, instantiateDefaultStyleNormalizer, instantiateSupportedAnimationDriver, isAngularHmrRestoringRoute, isBlank, isContentView, isDetachedElement, isInvisibleNode, isJsObject, isKnownView, isLayout, isListLikeIterable, isPresent, isView, onAfterLivesync, onBeforeLivesync, once, platformNativeScript, platformNativeScriptDynamic, postAngularBootstrap$, preAngularDisposal$, provideLocationStrategy, provideNativeScriptHttpClient, provideNativeScriptNgZone, provideNativeScriptRouter, registerElement, registerNativeScriptViewComponents, rootRoute, runNativeScriptAngularApp, throwIfAlreadyLoaded, throwNoPortalAttachedError, throwNullPortalError, throwNullPortalOutletError, throwPortalAlreadyAttachedError, throwPortalOutletAlreadyDisposedError, throwUnknownPortalTypeError, COMPONENT_VARIABLE as ɵCOMPONENT_VARIABLE, CONTENT_ATTR as ɵCONTENT_ATTR, HOST_ATTR as ɵHOST_ATTR, NativeScriptDebug as ɵNativeScriptAngularDebug, viewUtil_d as ɵViewUtil, actionBarMeta as ɵactionBarMeta, elementMap as ɵelementMap, isActionItem as ɵisActionItem, isNavigationButton as ɵisNavigationButton };
 export type { AppLaunchView, AppOptions, AppRunOptions, ApplicationConfig, BaseShowModalOptions, CdkPortalOutletAttachedRef, ComponentType, HmrOptions, Keyframe, LocationState, ModalDialogOptions, NamespaceFilter, NativeShowModalOptions, NavigationOptions, NgModuleEvent, NgModuleReason, NgView, NgViewTemplate, PageFactory, PageFactoryOptions, PortalOutlet, RootLocator, SelectableView, SetupItemViewArgs, ShowDialogOptions, TabViewItemDef, TemplatedItemsHost, TextView, ViewClass, ViewClassMeta, ViewExtensions, ViewResolver };