@rb-mwindh/ngx-theme-manager
Version:
Angular component to switch between different theming stylesheets
197 lines • 23.9 kB
JavaScript
import { Inject, Injectable, InjectionToken, Optional, } from '@angular/core';
import { debounceTime, filter, map, skipWhile, Subject, take, takeUntil, takeWhile, tap, } from 'rxjs';
import * as i0 from "@angular/core";
import * as i1 from "./internal";
import * as i2 from "@angular/router";
const PREFIX = 'ngx-theme-manager';
/**
* @group InjectionToken
*/
export const STORAGE_KEY = new InjectionToken(`${PREFIX}/STORAGE_KEY`, {
factory: () => `${PREFIX}/current-theme`,
});
/**
* @group InjectionToken
*/
export const QUERY_PARAM = new InjectionToken(`${PREFIX}/QUERY_PARAM`, {
factory: () => `theme`,
});
/**
* Service for managing and switching between different themes in an application.
*
* @group Services
* @group Public API
*/
export class ThemeService {
/**
* Subject for triggering cleanup on service destruction.
*
* @private
*/
#destroyed;
/**
* Creates a new instance
*
* @param {ThemeRegistryService} registry - Service for registering available themes
* @param {ThemeTrackingService} tracker - Service for tracking the currently selected theme
* @param {ThemeStyleManagerService} manager - Service for theme discovery, activation and deactivation
* @param {StorageService} storage - Service for storing the currently selected theme in the browser storage
* @param {ActivatedRoute} activatedRoute - Angular service for managing the current route
* @param {Router} router - Angular service for navigating between routes
* @param {string} storageKey - Key for storing the currently selected theme in browser storage
* @param {string} queryParam - Query parameter name for specifying the theme in the route
*/
constructor(registry, tracker, manager, storage, activatedRoute, router, storageKey, queryParam) {
this.registry = registry;
this.tracker = tracker;
this.manager = manager;
this.storage = storage;
this.activatedRoute = activatedRoute;
this.router = router;
this.storageKey = storageKey;
this.queryParam = queryParam;
/**
* Subject for triggering cleanup on service destruction.
*
* @private
*/
this.#destroyed = new Subject();
/**
* Observable stream that emits the currently active theme.
*/
this.themes$ = this.registry.themes$;
/**
* Observable stream of all registered themes.
*/
this.currentTheme$ = this.tracker.currentTheme$;
// update the current route, the browser storage and the style elements' media attribute,
// when the currently selected theme changes
this.tracker.currentTheme$
.pipe(filter(isNotNull), tap((theme) => this.#updateRouteParam(theme)), tap((theme) => this.#updateStoredTheme(theme)), tap((theme) => manager.use(theme)), takeUntil(this.#destroyed))
.subscribe();
// calculate the initially selected theme
this.registry.themes$
.pipe(debounceTime(1), takeWhile(() => !this.tracker.currentTheme), map((themes) => themes.find((theme) => theme.defaultTheme) || themes[0]), map((defaultTheme) => ({
fromRoute: this.#themeFromRoute,
fromStorage: this.#themeFromStorage,
defaultTheme: defaultTheme?.id,
})), map(({ fromRoute, fromStorage, defaultTheme }) => fromRoute || fromStorage || defaultTheme), tap((initialTheme) => {
if (!this.tracker.currentTheme) {
this.tracker.currentTheme = initialTheme;
}
}), take(1))
.subscribe();
// if we got a storage key, update current theme on storage changes
if (!!this.storageKey) {
this.storage.changes$
.pipe(skipWhile(() => !this.tracker.currentTheme), filter(({ key }) => key === this.storageKey), map(({ newValue }) => newValue), tap((theme) => (this.tracker.currentTheme = theme)), takeUntil(this.#destroyed))
.subscribe();
}
// if we got a query param, update the current theme on route param changes
if (!!this.queryParam) {
this.activatedRoute.queryParamMap
.pipe(skipWhile(() => !this.tracker.currentTheme), filter((map) => map.has(this.queryParam)), map((map) => map.get(this.queryParam)), tap((theme) => (this.tracker.currentTheme = theme)), takeUntil(this.#destroyed))
.subscribe();
}
}
/**
* Cleanup logic to be executed when the service is destroyed.
*
* @internal
*/
ngOnDestroy() {
this.#destroyed.next();
this.#destroyed.complete();
}
/**
* Select the theme to be used
*
* @param {string} theme
*/
selectTheme(theme) {
this.tracker.currentTheme = theme;
}
/**
* Gets the theme from the browser's storage.
*
* @returns {string | null} - The stored theme or null if the storage key is not provided
* @private
*/
get #themeFromStorage() {
if (!this.storageKey) {
return null;
}
return this.storage.getItem(this.storageKey);
}
/**
* Gets the theme from the current route's query.
*
* @returns {string | null} - The current theme or null if the query param is not provided
* @private
*/
get #themeFromRoute() {
if (!this.queryParam) {
return null;
}
return this.activatedRoute.snapshot.queryParamMap.get(this.queryParam);
}
/**
* Updates the browser's url query params with the given theme ID.
*
* Does nothing if the query param is not provided.
*
* @param {string} theme - The theme ID to update in the browser's url query params
* @private
*/
#updateRouteParam(theme) {
if (!this.queryParam) {
return;
}
this.router.navigate([], {
relativeTo: this.activatedRoute,
queryParams: theme ? { [this.queryParam]: theme } : {},
queryParamsHandling: 'merge',
preserveFragment: true,
});
}
/**
* Updates the theme ID in the browser's storage.
*
* Does nothing if the storage key is not provided.
*
* @param {string} theme - The theme ID to save in the browser's storage
* @private
*/
#updateStoredTheme(theme) {
if (!this.storageKey) {
return;
}
this.storage.setItem(this.storageKey, theme);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ThemeService, deps: [{ token: i1.ThemeRegistryService }, { token: i1.ThemeTrackingService }, { token: i1.ThemeStyleManagerService }, { token: i1.StorageService }, { token: i2.ActivatedRoute }, { token: i2.Router }, { token: STORAGE_KEY, optional: true }, { token: QUERY_PARAM, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ThemeService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.1", ngImport: i0, type: ThemeService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: () => [{ type: i1.ThemeRegistryService }, { type: i1.ThemeTrackingService }, { type: i1.ThemeStyleManagerService }, { type: i1.StorageService }, { type: i2.ActivatedRoute }, { type: i2.Router }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [STORAGE_KEY]
}] }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [QUERY_PARAM]
}] }] });
/**
* Type guard.
*
* @param {T | null]} arg - The argument to guard
* @internal
*/
function isNotNull(arg) {
return arg !== null;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme.service.js","sourceRoot":"","sources":["../../../../projects/ngx-theme-manager/src/lib/theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Inject,\n  Injectable,\n  InjectionToken,\n  OnDestroy,\n  Optional,\n} from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport {\n  debounceTime,\n  filter,\n  map,\n  skipWhile,\n  Subject,\n  take,\n  takeUntil,\n  takeWhile,\n  tap,\n} from 'rxjs';\nimport {\n  StorageService,\n  ThemeRegistryService,\n  ThemeStyleManagerService,\n  ThemeTrackingService,\n} from './internal';\n\nconst PREFIX = 'ngx-theme-manager';\n\n/**\n * @group InjectionToken\n */\nexport const STORAGE_KEY = new InjectionToken<string>(\n  `${PREFIX}/STORAGE_KEY`,\n  {\n    factory: () => `${PREFIX}/current-theme`,\n  },\n);\n\n/**\n * @group InjectionToken\n */\nexport const QUERY_PARAM = new InjectionToken<string>(\n  `${PREFIX}/QUERY_PARAM`,\n  {\n    factory: () => `theme`,\n  },\n);\n\n/**\n * Service for managing and switching between different themes in an application.\n *\n * @group Services\n * @group Public API\n */\n@Injectable({ providedIn: 'root' })\nexport class ThemeService implements OnDestroy {\n  /**\n   * Subject for triggering cleanup on service destruction.\n   *\n   * @private\n   */\n  readonly #destroyed = new Subject<void>();\n\n  /**\n   * Observable stream that emits the currently active theme.\n   */\n  public readonly themes$ = this.registry.themes$;\n\n  /**\n   * Observable stream of all registered themes.\n   */\n  public readonly currentTheme$ = this.tracker.currentTheme$;\n\n  /**\n   * Creates a new instance\n   *\n   * @param {ThemeRegistryService} registry - Service for registering available themes\n   * @param {ThemeTrackingService} tracker - Service for tracking the currently selected theme\n   * @param {ThemeStyleManagerService} manager - Service for theme discovery, activation and deactivation\n   * @param {StorageService} storage - Service for storing the currently selected theme in the browser storage\n   * @param {ActivatedRoute} activatedRoute - Angular service for managing the current route\n   * @param {Router} router - Angular service for navigating between routes\n   * @param {string} storageKey - Key for storing the currently selected theme in browser storage\n   * @param {string} queryParam - Query parameter name for specifying the theme in the route\n   */\n  constructor(\n    private readonly registry: ThemeRegistryService,\n    private readonly tracker: ThemeTrackingService,\n    private readonly manager: ThemeStyleManagerService,\n    private readonly storage: StorageService,\n    private readonly activatedRoute: ActivatedRoute,\n    private readonly router: Router,\n    @Optional() @Inject(STORAGE_KEY) private readonly storageKey?: string,\n    @Optional() @Inject(QUERY_PARAM) private readonly queryParam?: string,\n  ) {\n    // update the current route, the browser storage and the style elements' media attribute,\n    // when the currently selected theme changes\n    this.tracker.currentTheme$\n      .pipe(\n        filter(isNotNull),\n        tap((theme) => this.#updateRouteParam(theme)),\n        tap((theme) => this.#updateStoredTheme(theme)),\n        tap((theme) => manager.use(theme)),\n        takeUntil(this.#destroyed),\n      )\n      .subscribe();\n\n    // calculate the initially selected theme\n    this.registry.themes$\n      .pipe(\n        debounceTime(1),\n        takeWhile(() => !this.tracker.currentTheme),\n        map(\n          (themes) =>\n            themes.find((theme) => theme.defaultTheme) || themes[0],\n        ),\n        map((defaultTheme) => ({\n          fromRoute: this.#themeFromRoute,\n          fromStorage: this.#themeFromStorage,\n          defaultTheme: defaultTheme?.id,\n        })),\n        map(\n          ({ fromRoute, fromStorage, defaultTheme }) =>\n            fromRoute || fromStorage || defaultTheme,\n        ),\n        tap((initialTheme) => {\n          if (!this.tracker.currentTheme) {\n            this.tracker.currentTheme = initialTheme;\n          }\n        }),\n        take(1),\n      )\n      .subscribe();\n\n    // if we got a storage key, update current theme on storage changes\n    if (!!this.storageKey) {\n      this.storage.changes$\n        .pipe(\n          skipWhile(() => !this.tracker.currentTheme),\n          filter(({ key }) => key === this.storageKey),\n          map(({ newValue }) => newValue),\n          tap((theme) => (this.tracker.currentTheme = theme)),\n          takeUntil(this.#destroyed),\n        )\n        .subscribe();\n    }\n\n    // if we got a query param, update the current theme on route param changes\n    if (!!this.queryParam) {\n      this.activatedRoute.queryParamMap\n        .pipe(\n          skipWhile(() => !this.tracker.currentTheme),\n          filter((map) => map.has(this.queryParam!)),\n          map((map) => map.get(this.queryParam!)),\n          tap((theme) => (this.tracker.currentTheme = theme)),\n          takeUntil(this.#destroyed),\n        )\n        .subscribe();\n    }\n  }\n\n  /**\n   * Cleanup logic to be executed when the service is destroyed.\n   *\n   * @internal\n   */\n  ngOnDestroy() {\n    this.#destroyed.next();\n    this.#destroyed.complete();\n  }\n\n  /**\n   * Select the theme to be used\n   *\n   * @param {string} theme\n   */\n  selectTheme(theme: string) {\n    this.tracker.currentTheme = theme;\n  }\n\n  /**\n   * Gets the theme from the browser's storage.\n   *\n   * @returns {string | null} - The stored theme or null if the storage key is not provided\n   * @private\n   */\n  get #themeFromStorage(): string | null {\n    if (!this.storageKey) {\n      return null;\n    }\n    return this.storage.getItem(this.storageKey);\n  }\n\n  /**\n   * Gets the theme from the current route's query.\n   *\n   * @returns {string | null} - The current theme or null if the query param is not provided\n   * @private\n   */\n  get #themeFromRoute(): string | null {\n    if (!this.queryParam) {\n      return null;\n    }\n    return this.activatedRoute.snapshot.queryParamMap.get(this.queryParam);\n  }\n\n  /**\n   * Updates the browser's url query params with the given theme ID.\n   *\n   * Does nothing if the query param is not provided.\n   *\n   * @param {string} theme - The theme ID to update in the browser's url query params\n   * @private\n   */\n  #updateRouteParam(theme: string) {\n    if (!this.queryParam) {\n      return;\n    }\n    this.router.navigate([], {\n      relativeTo: this.activatedRoute,\n      queryParams: theme ? { [this.queryParam]: theme } : {},\n      queryParamsHandling: 'merge',\n      preserveFragment: true,\n    });\n  }\n\n  /**\n   * Updates the theme ID in the browser's storage.\n   *\n   * Does nothing if the storage key is not provided.\n   *\n   * @param {string} theme - The theme ID to save in the browser's storage\n   * @private\n   */\n  #updateStoredTheme(theme: string) {\n    if (!this.storageKey) {\n      return;\n    }\n    this.storage.setItem(this.storageKey, theme);\n  }\n}\n\n/**\n * Type guard.\n *\n * @param {T | null]} arg - The argument to guard\n * @internal\n */\nfunction isNotNull<T>(arg: T | null): arg is T {\n  return arg !== null;\n}\n"]}