@angular/core#NgZone TypeScript Examples

constructor(
    public router: Router,
    public zone: NgZone,
    public platform: Platform,
    private modalCtrl: ModalController,
    private identityService: IdentityService,
    private uxService: UXService,
    private translate: TranslateService,
    private popup: PopupProvider,
    public theme: GlobalThemeService,
    private events: Events,
    public element: ElementRef,
    private mnemonicKeypadService: GlobalMnemonicKeypadService
  ) {
    const navigation = this.router.getCurrentNavigation();
    if (!Util.isEmptyObject(navigation.extras.state)) {
      this.nextStepId = navigation.extras.state.enterEvent.stepId;
      //Logger.log('didsessions', 'Importdid - nextStepId', this.nextStepId);
      if (!Util.isEmptyObject(navigation.extras.state.mnemonic)) {
        this.mnemonicSentence = navigation.extras.state.mnemonic;
        this.onMnemonicSentenceChanged();
        this.readonly = true;
      }
    }
  }

constructor(protected zone: NgZone) {
    super(zone, 'color-block');
    this.formGroup = new FormGroup({
      r: new FormControl(null, [Validators.required]),
      g: new FormControl(null, [Validators.required]),
      b: new FormControl(null, [Validators.required]),
      a: new FormControl(null, [Validators.required]),
      hex: new FormControl(null, [Validators.required, Validators.pattern(matchers.hex6)]),
    });
  }

constructor(
    private personalCardsService: PersonalCardsService,
    private networkService: NetworkService,
    private router: Router,
    private activatedRoute: ActivatedRoute,
    private inAppBrowser: InAppBrowser,
    private loaderService: LoaderService,
    private zone: NgZone,
    private matSnackBar: MatSnackBar,
    private snackbarProperties: SnackbarPropertiesService,
    private modalController: ModalController,
    private dateService: DateService,
    private apiV2Service: ApiV2Service,
    private platform: Platform,
    private spinnerDialog: SpinnerDialog,
    private trackingService: TrackingService
  ) {}

constructor(
        private ngZone: NgZone,
        public wallet: WalletService,
        private authService: AuthenticationService,
        private globalService: GlobalService,
        private apiService: ApiService,
        private appState: ApplicationStateService,
        private router: Router) {

    }

constructor(private _dialog: MatDialog,
    private _overlay: Overlay,
    private _zone: NgZone,
    private _adapter: ColorAdapter,
    @Optional() private _dir: Directionality,
    @Inject(NGX_MAT_COLOR_PICKER_SCROLL_STRATEGY) scrollStrategy: any,
    @Optional() @Inject(DOCUMENT) private _document: any,
    private _viewContainerRef: ViewContainerRef) {
    this._scrollStrategy = scrollStrategy;
  }

constructor(
        private electronService: ElectronService,
        private authService: AuthenticationService,
        private router: Router,
        private zone: NgZone,
        private log: Logger,
        private apiService: ApiService,
        public updateService: UpdateService,
        public appState: ApplicationStateService) {

    }

constructor(private _dialog: MatDialog,
    private _overlay: Overlay,
    private _ngZone: NgZone,
    private _viewContainerRef: ViewContainerRef,
    @Inject(MAT_DATEPICKER_SCROLL_STRATEGY) scrollStrategy: any,
    @Optional() private _dateAdapter: NgxMatDateAdapter<D>,
    @Optional() private _dir: Directionality,
    @Optional() @Inject(DOCUMENT) private _document: any) {
    if (!this._dateAdapter) {
      throw createMissingDateImplError('NgxMatDateAdapter');
    }

    this._scrollStrategy = scrollStrategy;
  }

constructor(private _dialog: MatDialog,
    private _overlay: Overlay,
    private _ngZone: NgZone,
    private _viewContainerRef: ViewContainerRef,
    @Inject(MAT_DATEPICKER_SCROLL_STRATEGY) scrollStrategy: any,
    @Optional() private _dateAdapter: NgxMatDateAdapter<D>,
    @Optional() private _dir: Directionality,
    @Optional() @Inject(DOCUMENT) private _document: any) {
    if (!this._dateAdapter) {
      throw createMissingDateImplError('NgxMatDateAdapter');
    }

    this._scrollStrategy = scrollStrategy;
  }

constructor(
        public events: Events,
        public native: Native,
        public zone: NgZone,
        public modalCtrl: ModalController,
        public translate: TranslateService,
        public localStorage: LocalStorage,
        private erc721Service: ERC721Service,
        private erc1155Service: ERC1155Service,
        private authService: AuthService,
        public popupProvider: PopupProvider,
        private prefs: GlobalPreferencesService,
        private safeService: SafeService, // Keep this - init
        private networkService: WalletNetworkService,
        private globalNetworksService: GlobalNetworksService,
        private walletNetworkService: WalletNetworkService,
        private offlineTransactionsService: OfflineTransactionsService, // Keep for init
        private didSessions: GlobalDIDSessionsService
    ) {
        WalletService.instance = this;
    }

appInitialize = (
  config: InoElementsConfig,
  doc: Document,
  zone: NgZone
) => {
  return (): any => {
    const win: InoElementsWindow | undefined = doc.defaultView as any;
    if (win && typeof (window as any) !== 'undefined') {
      if (didInitialize) {
        return;
      }
      didInitialize = true;

      win.inoElements = win.inoElements || {};
      win.inoElements.config = config;

      const aelFn =
        '__zone_symbol__addEventListener' in (doc.body as any)
          ? '__zone_symbol__addEventListener'
          : 'addEventListener';

      /* eslint-disable prefer-arrow/prefer-arrow-functions */
      return applyPolyfills().then(() => {
        return defineCustomElements(win, {
          exclude: [],
          syncQueue: true,
          raf,
          jmp: (h: any) => zone.runOutsideAngular(h),
          ael(elm, eventName, cb, opts) {
            (elm as any)[aelFn](eventName, cb, opts);
          },
          rel(elm, eventName, cb, opts) {
            elm.removeEventListener(eventName, cb, opts);
          },
        });
      });
    }
  };
}

constructor(
    public zone: NgZone,
    public alertController:AlertController,
    private router: Router,
    private adminService: AdminService,
    private popup: PopupService,
    public theme: GlobalThemeService,
    private native: GlobalNativeService,
    private globalNav: GlobalNavService,
    private translate: TranslateService,
    // public navParams: NavParams // Err - No provider for Navparams
  ) {
    const navigation = this.router.getCurrentNavigation();
    if(navigation.extras.state) {
      const providerId = navigation.extras.state.providerId;
      Logger.log('HiveManager', 'Provider id', providerId);
      void this.init(providerId);
    }

/*     this.providerId = navParams.get('providerId');
    Logger.log('HiveManager', 'Provider id', this.providerId);
    this.init();

    this.retrieveAdminDIDPublicationStatus();
    Logger.log('HiveManager', "Editing provider:", this.managedProvider); */
  }

// end::host-app:register-initializer[]

// tag::micro-app:initializer[]
@NgModule({
  providers: [
    {
      provide: APP_INITIALIZER,
      useFactory: provideConnectToHostFn, // <1>
      deps: [NgZone], // <2>
      multi: true,
    },
  ],
  // ... other metadata omitted
})
export class AppModule {
}

constructor(
    overlay: Overlay,
    viewContainerRef: ViewContainerRef,
    elRef: ElementRef,
    renderer: Renderer2,
    cdr: ChangeDetectorRef,
    ngZone: NgZone,
  ) {
    super(overlay, viewContainerRef, elRef, renderer, cdr, ngZone);
    new DropdownActiveDirective(this, elRef, renderer).customClass = 'isActive';
    this.type = TooltipType.Plain;
    this.position = 'bottom end';
    this.trigger = TooltipTrigger.Click;
  }

public constructor(
    public electronService: ElectronService,
    private _wowUpService: WowUpService,
    private _ngZone: NgZone,
    private _snackBar: MatSnackBar,
    private _translateService: TranslateService
  ) {
    const windowMaximizedSubscription = this.electronService.windowMaximized$.subscribe((maximized) => {
      this._ngZone.run(() => (this.isMaximized = maximized));
    });

    this._subscriptions = [windowMaximizedSubscription];

    this.electronService.on(IPC_WINDOW_ENTER_FULLSCREEN, () => {
      this.isFullscreen = true;
      const localeKey = this.electronService.isMac ? "APP.FULLSCREEN_SNACKBAR.MAC" : "APP.FULLSCREEN_SNACKBAR.WINDOWS";
      const message = this._translateService.instant(localeKey);
      this._snackBarRef = this._snackBar.openFromComponent(CenteredSnackbarComponent, {
        duration: 5000,
        panelClass: ["wowup-snackbar", "text-1"],
        data: {
          message,
        },
        verticalPosition: "top",
      });
    });

    this.electronService.on(IPC_WINDOW_LEAVE_FULLSCREEN, () => {
      this.isFullscreen = false;
      this._snackBarRef?.dismiss();
      this._snackBarRef = undefined;
    });
  }

constructor(
    private readonly dataStore: DataStore,
    private readonly dataAnalyzer: DataAnalyzer,
    private readonly changeDetectorRef: ChangeDetectorRef,
    private readonly zone: NgZone,
    private readonly dialog: MatDialog,
    readonly home: HomeComponent,
  ) {
    this.viewRange = 'month' // Ensure row is updated
    this.todayDayID = dataStore.getCurrentDayID()
  }

constructor(
        public translate: TranslateService,
        private nav: GlobalNavService,
        public theme: GlobalThemeService,
        public httpClient: HttpClient,
        public zone: NgZone,
        private platform: Platform,
        private globalStartupService: GlobalStartupService,
        private globalIntentService: GlobalIntentService,
        private globalStorageService: GlobalStorageService,
        public dappbrowserService: DappBrowserService,
        public walletNetworkService: WalletNetworkService,
        private walletNetworkUIService: WalletNetworkUIService,
        private favoritesService: FavoritesService
    ) {
        this.initDapps();
    }

constructor(
    private readonly changeDetectorRef: ChangeDetectorRef,
    private readonly dataStore: DataStore,
    private readonly dataAnalyzer: DataAnalyzer,
    private readonly dialog: MatDialog,
    private readonly zone: NgZone,
    private readonly home: HomeComponent,
  ) {
    this.alertActionCtx = {
      showItemInItems: (itemID: ItemID) => {
        this.home.showInItems(itemID)
      },
      showItemInQueue: (itemID: ItemID) => {
        this.home.showInQueue(itemID)
      },
      editItem: (itemID: ItemID) => {
        const item = this.dataStore.getItem(itemID)
        if (item === undefined) return
        const dialogRef = this.dialog.open(ItemDetailsComponent, {
          width: ItemDetailsComponent.DIALOG_WIDTH,
          data: {item},
          hasBackdrop: true,
          disableClose: false,
          autoFocus: false,
        })
      },
      dataStore: this.dataStore,
    }
  }

/**
 * TODO: This will not be needed when markDirty becomes stable API
 */
export function shouldCall<T>(predicate: Predicate<T>): MethodDecorator {
    return (_, key, desc: PropertyDescriptor) => {
        const {value} = desc;

        desc.value = function (this: T, ...args: any[]) {
            const zone = arguments[0];

            if (zone instanceof NgZone) {
                Object.defineProperty(this, key, {
                    value(this: T, ...args: any[]) {
                        if (predicate.apply(this, args)) {
                            zone.run(() => {
                                value.apply(this, args);
                            });
                        }
                    },
                });
            } else if (predicate.apply(this, args)) {
                value.apply(this, args);
            }
        };
    };
}

constructor(
    private readonly web3PublicService: PublicBlockchainAdapterService,
    private readonly volumeApiService: VolumeApiService,
    private readonly authService: AuthService,
    private readonly tokensService: TokensService,
    private readonly errorService: ErrorsService,
    private readonly httpClient: HttpClient,
    private readonly zone: NgZone
  ) {
    this.getStakingTokenPrice();
  }

constructor(
    public toastCtrl: ToastController,
    private platform: Platform,
    private loadingCtrl: LoadingController,
    private ngZone: NgZone,
    public route: Router,
    public activateRoute: ActivatedRoute,
    public nav: NavController,
    public user: UserService,
    public homeService: HomeServiceService,
    public afstore: AngularFirestore,
    public toast: ToastController,
    public router: Router,
  ) {
  }

constructor(
    @Inject(ENV)
    private readonly env: typeof environment,
    private readonly settingsService: SettingsService,
    private readonly settingsQuery: SettingsQuery,
    private readonly walletsAccountsService: WalletsAccountsService,
    private readonly walletsAccountsQuery: WalletsAccountsQuery,
    private readonly walletsOperationsQuery: WalletsOperationsQuery,
    private readonly alertsLabelsService: AlertsLabelsService,
    private readonly horizonApisQuery: HorizonApisQuery,
    private readonly route: ActivatedRoute,
    @Inject(DOCUMENT)
    private readonly document: Document,
    private readonly renderer2: Renderer2,
    private readonly globalsService: GlobalsService,
    private readonly ngZone: NgZone,
    private readonly translateService: TranslateService,
  ) { }

constructor(
    @Inject(PLATFORM_ID) platformId: Object,
    private readonly headerStore: HeaderStore,
    private readonly authService: AuthService,
    private readonly iframeService: IframeService,
    private readonly cdr: ChangeDetectorRef,
    private readonly storeService: StoreService,
    private readonly router: Router,
    private readonly errorService: ErrorsService,
    private readonly queryParamsService: QueryParamsService,
    private readonly swapFormService: SwapFormService,
    private readonly swapsService: SwapsService,
    private readonly myTradesService: MyTradesService,
    private readonly tokensService: TokensService,
    @Inject(WINDOW) private readonly window: Window,
    @Inject(DOCUMENT) private readonly document: Document,
    @Self() private readonly destroy$: TuiDestroyService,
    private readonly gtmService: GoogleTagManagerService,
    private readonly zone: NgZone
  ) {
    this.loadUser();
    this.advertisementType = 'default';
    this.currentUser$ = this.authService.getCurrentUser();
    this.isMobileMenuOpened$ = this.headerStore.getMobileMenuOpeningStatus();
    this.isMobile$ = this.headerStore.getMobileDisplayStatus();
    this.headerStore.setMobileDisplayStatus(this.window.innerWidth <= this.headerStore.mobileWidth);
    if (isPlatformBrowser(platformId)) {
      this.zone.runOutsideAngular(() => {
        this.setNotificationPosition();
        this.window.onscroll = () => {
          this.setNotificationPosition();
        };
      });
    }
    this.swapType$ = this.swapsService.swapMode$;
  }

constructor(
    private stateTransfer: StateTransferService,
    private ngZone: NgZone,
    private routedExtensions: RouterExtensions,
    private grocyService: GrocyService,
    private _fb: FormBuilder
  ) {
    this.grocyService.locations().subscribe(loc => this.locationsArr = loc);
    this.grocyService.allProducts().subscribe(prods => this.productsArr = prods);

    const state = this.stateTransfer.readAndClearState();

    if (state && state.type === "scannedItemEdit") {
      this.originalScannedItem = state.scannedItem;

      this.form.setValue({
        quantity: this.originalScannedItem.quantity,
        location: this.originalScannedItem.location || null,
        product: this.originalScannedItem.grocyProduct || null,
        bestByDate: dateStringParser(this.originalScannedItem.bestBeforeDate)
      });

      this.selectionCallback = state.callback;
    }

  }

// end::intent-client-decorator[]

// tag::emit-inside-angular[]
function synchronizeWithAngular<T>(zone: NgZone): MonoTypeOperatorFunction<T> {
  return pipe(
    subscribeInside(continueFn => zone.runOutsideAngular(continueFn)),
    observeInside(continueFn => zone.run(continueFn)),
  );
}