@angular/platform-browser#DomSanitizer TypeScript Examples

class MockDomSanitizer implements DomSanitizer {
  bypassSecurityTrustHtml(value: string): SafeHtml {
    throw new Error('Method not implemented.');
  }

  bypassSecurityTrustStyle(value: string): SafeStyle {
    throw new Error('Method not implemented.');
  }

  bypassSecurityTrustScript(value: string): SafeScript {
    throw new Error('Method not implemented.');
  }

  bypassSecurityTrustUrl(value: string): SafeUrl {
    throw new Error('Method not implemented.');
  }

  bypassSecurityTrustResourceUrl(value: string): SafeResourceUrl {
    throw new Error('Method not implemented.');
  }

  sanitize(context: any, content: string): string {
    return content;
  }
}

describe('SafeUrlPipe', () => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [BrowserModule],
    });
  });
  it('create an instance', () => {
    const domSanitizer = TestBed.get(DomSanitizer);
    const pipe = new SafeUrlPipe(domSanitizer);
    expect(pipe).toBeTruthy();
  });
});

constructor(public navCtrl: NavController,
              public navParams: NavParams,
              private domSanitizer: DomSanitizer,
              private loadingCtrl: LoadingController) {
    if (this.navParams.data != undefined) {
      this.item = this.navParams.data;
      this.title = this.item.title.substring(0, 25);
    }
  }

public constructor(
    public wowUpService: WowUpService,
    public electronService: ElectronService,
    private _sessionService: SessionService,
    private _patchNotesService: PatchNotesService,
    private _sanitizer: DomSanitizer,
    private _linkService: LinkService
  ) {
    this.changeLogs = this._patchNotesService.changeLogs;
    const tabIndexSub = this._sessionService.selectedHomeTab$
      .pipe(
        filter((newTabIndex) => newTabIndex === this.tabIndex),
        map(() => {
          window.getSelection()?.empty();
        })
      )
      .subscribe();

    this._subscriptions.push(tabIndexSub);
  }

constructor(
    matRegistry: MatIconRegistry,
    sanitizer: DomSanitizer,
    public cfg: ConfigService,
    private storage: StorageService
  ) {
    (window as any).browserComputePathBoundingBox = browserComputePathBoundingBox;
    for (const icon of ['delete', 'logo', 'more', 'github', 'zoom_in', 'zoom_out', 'zoom_fit', 'sponsor']) {
      matRegistry.addSvgIcon(icon, sanitizer.bypassSecurityTrustResourceUrl(`./assets/${icon}.svg`));
    }
    this.parsedPath = new Svg('');
    this.reloadPath(this.rawPath, true);
  }

constructor(
        private cropService: CropService,
        private cropperPositionService: CropperPositionService,
        private loadImageService: LoadImageService,
        private sanitizer: DomSanitizer,
        private cd: ChangeDetectorRef
    ) {
        this.reset();
    }

constructor(
    periodService: PeriodService,
    iconRegistry: MatIconRegistry,
    sanitizer: DomSanitizer
  ) {
    iconRegistry.addSvgIcon(
      "left",
      sanitizer.bypassSecurityTrustResourceUrl("assets/left.svg")
    );
    iconRegistry.addSvgIcon(
      "right",
      sanitizer.bypassSecurityTrustResourceUrl("assets/right.svg")
    );

    this.month = periodService.getCurrentPeriod().month;
    this.year = periodService.getCurrentPeriod().year;
  }

constructor(
    public events: Events,
    public route: ActivatedRoute,
    private router: Router,
    public zone: NgZone,
    private translate: TranslateService,
    private didService: DIDService,
    public theme: GlobalThemeService,
    public actionSheetController: ActionSheetController,
    public profileService: ProfileService,
    private globalIntentService: GlobalIntentService,
    private globalPopupService: GlobalPopupService,
    private globalNavService: GlobalNavService,
    private globalNativeService: GlobalNativeService,
    private didDocumentsService: DIDDocumentsService,
    private authService: AuthService,
    private credentialsService: CredentialsService,
    private sanitizer: DomSanitizer,
    private globalCredentialTypesService: GlobalCredentialTypesService
  ) {
    this.init();
  }

// max params shouldnt effect constructors
  constructor(
    private modalController: ModalController,
    private popoverController: PopoverController,
    private sanitizer: DomSanitizer,
    private popupService: PopupService,
    private loaderService: LoaderService,
    private fileService: FileService
  ) {}

describe('SafePipe', () => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [BrowserModule],
    });
  });

  it('create an instance', () => {
    const domSanitizer = TestBed.inject(DomSanitizer);
    const pipe = new SafePipe(domSanitizer);
    expect(pipe).toBeTruthy();
  });
});

constructor(
    private formBuilder: FormBuilder,
    private sidebarService: SidebarService,
    private dataSourceService: DataSourceService,
    private dashboardService: DashboardService,
    private sanitizer: DomSanitizer,
    private alertService: AlertService) {

    this.exportModelForm = this.formBuilder.group({
      model: [null, Validators.required]
    });

    this.dashBoardForm = this.formBuilder.group({
      dashboard: [null, Validators.required]
    });

  }

constructor(
    private readonly platform: Platform,
    private readonly collectorService: CollectorService,
    private readonly iconRegistry: MatIconRegistry,
    private readonly sanitizer: DomSanitizer,
    private readonly capacitorFactsProvider: CapacitorFactsProvider,
    private readonly webCryptoApiSignatureProvider: WebCryptoApiSignatureProvider,
    private readonly captureService: CaptureService,
    private readonly cameraService: CameraService,
    private readonly errorService: ErrorService,
    notificationService: NotificationService,
    pushNotificationService: PushNotificationService,
    langaugeService: LanguageService,
    diaBackendAuthService: DiaBackendAuthService,
    diaBackendNotificationService: DiaBackendNotificationService,
    uploadService: DiaBackendAssetUploadingService
  ) {
    notificationService.requestPermission();
    pushNotificationService.register();
    langaugeService.initialize();
    diaBackendAuthService.initialize$().pipe(untilDestroyed(this)).subscribe();
    uploadService.initialize$().pipe(untilDestroyed(this)).subscribe();
    diaBackendNotificationService
      .initialize$()
      .pipe(untilDestroyed(this))
      .subscribe();
    this.initializeApp();
    this.restoreAppState();
    this.initializeCollector();
    this.registerIcon();
  }

constructor(
    public imageService: ImageService,
    private sanitizer: DomSanitizer,
    protected overlay: Overlay,
    protected router: Router,
    protected destroyer: Destroyer,
  ) {
    super();
  }

constructor(
    private route: ActivatedRoute,
    private router: Router,
    private store: Store<fromCustomers.State>,
    private customerService: CustomerService,
    private dialogService: NbDialogService,
    private notificationService: NotificationService,
    private domSanitizer: DomSanitizer,
  ) {}

constructor(private matIconRegistry: MatIconRegistry, private domSanitizer: DomSanitizer, private themeService: ThemeService) {

    this.themeService.initTheme();

    this.matIconRegistry.addSvgIcon(
      "github",
      this.domSanitizer.bypassSecurityTrustResourceUrl('/assets/github.svg')
    );

    this.matIconRegistry.addSvgIcon(
      'preview',
      this.domSanitizer.bypassSecurityTrustResourceUrl('/assets/preview.svg')
    );

  }

constructor(
    public sdkgen: SdkgenService,
    private domSanitizer: DomSanitizer,
    private matIconRegistry: MatIconRegistry,
  ) {
    for (const icon of ["typescript", "dot-net", "kotlin", "swift", "dart"]) {
      this.matIconRegistry.addSvgIcon(icon, this.domSanitizer.bypassSecurityTrustResourceUrl(`assets/${icon}.svg`));
    }
  }

constructor(
    private readonly momentRepository: MomentRepository,
    private readonly route: ActivatedRoute,
    private readonly router: Router,
    private readonly sanitizer: DomSanitizer,
    private readonly httpClient: HttpClient,
    private readonly languagesService: LanguagesService,
    private readonly dialogsService: DialogsService
  ) {}

constructor(
        @Optional() @Inject(PREVIEW_MODAL) public previewModal: Type<any>,
        private router: Router,
        private previewWebService: PreviewWebService,
        private appService: AppService,
        private authenticationService: AuthenticationService,
        private searchService: SearchService,
        private modalService: ModalService,
        private recentDocumentsService: RecentDocumentsService,
        public exprBuilder: ExprBuilder,
        private domSanitizer: DomSanitizer) {

        // Subscribe to own events and add documents to the recent documents service
        this.events.subscribe(event => {
            if(event.record && (event.type === PreviewEventType.Modal || event.type === PreviewEventType.Route || event.type === PreviewEventType.Window)){
                this.recentDocumentsService.addDocument(event.record, false);
            }
        });
    }

constructor(
    public dashboardSandbox: DashboardSandbox,
    private router: Router,
    private _sanitizer: DomSanitizer,
    private configService: ConfigService,
    public titleService: Title,
    public layoutSandbox: LayoutSandbox
  ) {
    Object.assign(this, { horizontalbar, line, single });
  }

constructor(
    private platform: Platform,
    public modalController: ModalController,
    private sanitizer: DomSanitizer,
    private configurationService: ConfigurationService,
    private toast: ToastController,
    public alertController: AlertController,
    public translate: TranslateService,
    public themeSwitcherService: ThemeSwitcherService,
    public boardThemeSwitcherService: BoardThemeSwitcherService) {
    this.configurationService.initialize().then(config => {
      this.configuration = config;
    });
  }

constructor(
        private errorService: ErrorService,
        private snackBar: MatSnackBar,
        private iconRegistry: MatIconRegistry,
        private sanitizer: DomSanitizer,
    ) {
        iconRegistry.addSvgIcon(
            'check',
            sanitizer.bypassSecurityTrustResourceUrl('assets/img/yes-icon.svg'),
        );
        iconRegistry.addSvgIcon(
            'ban',
            sanitizer.bypassSecurityTrustResourceUrl('assets/img/no-icon.svg'),
        );
        this.initializeErrors();
    }

constructor(
        private oneInchApiService: OneInchApiService,
        private gnosisService: GnosisService,
        private tokenPriceService: TokenPriceService,
        public tokenService: TokenService,
        private ethereumService: EthereumService,
        iconRegistry: MatIconRegistry,
        sanitizer: DomSanitizer
    ) {

        iconRegistry.addSvgIcon('settings', sanitizer.bypassSecurityTrustResourceUrl('assets/settings.svg'));
        iconRegistry.addSvgIcon('swap', sanitizer.bypassSecurityTrustResourceUrl('assets/swap.svg'));

        // need to subscribe before addListener
        this.gnosisService.walletAddress$.subscribe();
        // this.gnosisService.isMainNet$.subscribe(console.log);

        this.sortedTokens$ = this.gnosisService.walletAddress$.pipe(
            switchMap((walletAddress) => {
                return combineLatest([
                    this.tokenService.getSortedTokens(walletAddress),
                    this.tokenService.tokenHelper$
                ]);
            }),
            map(([tokens, tokenHelper]) => {

                this.updateFromAmountValidator(tokenHelper);
                this.openLoader = false;
                return tokens;
            }),
            shareReplay({bufferSize: 1, refCount: true})
        );

        this.filteredFromTokens$ = this.getFilteredTokens(this.autoCompleteCtrlFromToken);
        this.filteredToTokens$ = this.getFilteredTokens(this.autoCompleteCtrlToToken);

        this.swapForm.controls.fromAmount.setValue(this.fromAmount, {emitEvent: false});

        const fromAmountChange$ = this.swapForm.controls.fromAmount.valueChanges.pipe(
            startWith(this.fromAmount),
            debounceTime(200),
            distinctUntilChanged(),
            map((value: string) => ({
                fromAmount: value,
                resetFields: true
            }))
        );

        const fromAmountListener$ = merge(fromAmountChange$, this.updateAmounts.asObservable())
            .pipe(
                switchMap((({fromAmount}) => {
                    return this.setAmounts(fromAmount).pipe(
                        // background refresh
                        repeatWhen((completed) => completed.pipe(delay(20000)))
                    );
                }))
            );

        this.subscription.add(fromAmountListener$.subscribe());
        this.gnosisService.addListeners();
    }

constructor(private sanitized: DomSanitizer) { }

constructor(private router: Router, private sanitizer: DomSanitizer) {
    this.dataSource.data = TREE_DATA;
  }

constructor(private sanitizer: DomSanitizer) { }

constructor(
    private electronService: ElectronService,
    private albumArtService: AlbumArtService,
    private downloadService: DownloadService,
    private searchService: SearchService,
    private sanitizer: DomSanitizer,
    public settingsService: SettingsService
  ) { }

constructor(public domSanitizer: DomSanitizer, public http: HttpClient) {}

constructor(private registry: LgBrandIconRegistry, private sanitizer: DomSanitizer) {
    this.registry.registerBrandIcon(this.icons);
  }

constructor(private sanitizer: DomSanitizer) { }