@nova-ui/bits
Version:
SolarWinds Nova Framework
150 lines • 23.3 kB
JavaScript
// © 2022 SolarWinds Worldwide, LLC. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import { DOCUMENT } from "@angular/common";
import { Inject, Injectable, RendererFactory2 } from "@angular/core";
import { ActivatedRoute, NavigationEnd, Router } from "@angular/router";
import { BehaviorSubject } from "rxjs";
import { filter, map } from "rxjs/operators";
import * as i0 from "@angular/core";
import * as i1 from "@angular/router";
/** @dynamic */
export class ThemeSwitchService {
constructor(rendererFactory, router, _route, document) {
this.rendererFactory = rendererFactory;
this.router = router;
this._route = _route;
this.document = document;
/** @ignore BehaviorSubject indicating whether we should display theme switcher */
this.showThemeSwitcherSubject = new BehaviorSubject(false);
/** BehaviorSubject indicating whether dark mode is enabled */
this.isDarkModeEnabledSubject = new BehaviorSubject(null);
/** Should route be refreshed after theme switching */
this.withRefreshRoute = false;
this.darkModePreferenceHandler = (event) => {
const isDarkModeEnabled = typeof event === "boolean" ? event : event.matches;
const isDarkPrevColorMode = this.isDarkModeEnabledSubject.getValue();
const demoContainerElement = this.document.children[0];
/** Adding class "dark-nova-theme" to html element we make dark mode, otherwise - light mode */
this.renderer[isDarkModeEnabled ? "addClass" : "removeClass"](demoContainerElement, "dark-nova-theme");
/**
* Reiniting route in case when theme is switching forced
* It allows to avoid reiniting route while application is started
*/
if (isDarkPrevColorMode !== null &&
isDarkPrevColorMode !== isDarkModeEnabled &&
this.withRefreshRoute) {
this.reInitRoute();
}
this.isDarkModeEnabledSubject.next(isDarkModeEnabled);
};
/** Getting renderer instance */
this.renderer = this.rendererFactory.createRenderer(null, null);
this.router.events
.pipe(filter((event) => event instanceof NavigationEnd), map(() => {
let route = this._route.root;
while (route.firstChild) {
route = route.firstChild;
}
return route;
}))
.subscribe((route) => {
const showThemeSwitcher = (route.snapshot.data || {})
.showThemeSwitcher;
if (typeof showThemeSwitcher === "undefined") {
return;
}
this.showThemeSwitcherSubject.next(showThemeSwitcher);
if (showThemeSwitcher) {
/** Case when route is changed on the same page (see on breadcrumb component docs page) */
if (typeof this.isDarkModeEnabledSubject.getValue() ===
"boolean") {
this.darkThemePreference = window.matchMedia("(prefers-color-scheme: dark)");
return;
}
this.enableColorSchemePreferenceHandling();
}
else {
/** Reset to light theme */
this.darkModePreferenceHandler(false);
this.disableColorSchemePreferenceHandling();
}
});
}
/**
* Use this method to manually toggle your app between light and dark theme
*
* @param isDarkModeEnabled Use true for dark theme and false for light theme
*/
setDarkTheme(isDarkModeEnabled) {
this.darkModePreferenceHandler(isDarkModeEnabled);
}
/**
* Use this method to configure the service to synchronize your app's theme with the user's
* light/dark mode system preference
*/
enableColorSchemePreferenceHandling() {
this.darkThemePreference = window.matchMedia("(prefers-color-scheme: dark)");
/** First call to set initial theme */
this.darkModePreferenceHandler(this.darkThemePreference.matches);
/** If browser supports subscribing to MediaQueryList event we do it */
if (typeof this.darkThemePreference.addEventListener === "function") {
this.darkThemePreference.addEventListener("change", this.darkModePreferenceHandler);
}
}
/**
* Use this method to disable synchronization of your app's theme with the user's light/dark mode
* system preference
*/
disableColorSchemePreferenceHandling() {
if (this.darkThemePreference &&
typeof this.darkThemePreference.removeEventListener === "function") {
this.darkThemePreference.removeEventListener("change", this.darkModePreferenceHandler);
}
}
reInitRoute() {
/**
* Logic for refreshing route
*/
const scrolledElement = this.document.children[0];
const currentScrollTopPosition = scrolledElement.scrollTop;
const originalShouldReuseRoute = this.router.routeReuseStrategy.shouldReuseRoute;
this.router.routeReuseStrategy.shouldReuseRoute = () => false;
this.router.navigated = false;
this.router.navigate([this.router.url]).then(() => {
this.router.routeReuseStrategy.shouldReuseRoute =
originalShouldReuseRoute;
/** After reiniting route we should restore scroll position */
setTimeout(() => (scrolledElement.scrollTop = currentScrollTopPosition));
});
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeSwitchService, deps: [{ token: i0.RendererFactory2 }, { token: i1.Router }, { token: i1.ActivatedRoute }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeSwitchService, providedIn: "root" }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ThemeSwitchService, decorators: [{
type: Injectable,
args: [{
providedIn: "root",
}]
}], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: i1.Router }, { type: i1.ActivatedRoute }, { type: Document, decorators: [{
type: Inject,
args: [DOCUMENT]
}] }] });
export default ThemeSwitchService;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"theme-switch.service.js","sourceRoot":"","sources":["../../../src/services/theme-switch.service.ts"],"names":[],"mappings":"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","sourcesContent":["// © 2022 SolarWinds Worldwide, LLC. All rights reserved.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n//  of this software and associated documentation files (the \"Software\"), to\n//  deal in the Software without restriction, including without limitation the\n//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n//  sell copies of the Software, and to permit persons to whom the Software is\n//  furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n//  all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n//  THE SOFTWARE.\n\nimport { DOCUMENT } from \"@angular/common\";\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from \"@angular/core\";\nimport { ActivatedRoute, NavigationEnd, Router } from \"@angular/router\";\nimport { BehaviorSubject } from \"rxjs\";\nimport { filter, map } from \"rxjs/operators\";\n\n/** @dynamic */\n@Injectable({\n    providedIn: \"root\",\n})\nexport class ThemeSwitchService {\n    /** @ignore BehaviorSubject indicating whether we should display theme switcher */\n    public showThemeSwitcherSubject: BehaviorSubject<boolean> =\n        new BehaviorSubject<boolean>(false);\n\n    /** BehaviorSubject indicating whether dark mode is enabled */\n    public isDarkModeEnabledSubject: BehaviorSubject<boolean | null> =\n        new BehaviorSubject<boolean | null>(null);\n\n    /** Should route be refreshed after theme switching */\n    public withRefreshRoute: boolean = false;\n\n    /** Keep information about preferred dark color scheme on OS */\n    private darkThemePreference: MediaQueryList;\n\n    private renderer: Renderer2;\n\n    constructor(\n        private rendererFactory: RendererFactory2,\n        private router: Router,\n        private _route: ActivatedRoute,\n        @Inject(DOCUMENT) private document: Document\n    ) {\n        /** Getting renderer instance */\n        this.renderer = this.rendererFactory.createRenderer(null, null);\n\n        this.router.events\n            .pipe(\n                filter((event) => event instanceof NavigationEnd),\n                map(() => {\n                    let route = this._route.root;\n                    while (route.firstChild) {\n                        route = route.firstChild;\n                    }\n                    return route;\n                })\n            )\n            .subscribe((route) => {\n                const showThemeSwitcher = (route.snapshot.data || {})\n                    .showThemeSwitcher;\n\n                if (typeof showThemeSwitcher === \"undefined\") {\n                    return;\n                }\n\n                this.showThemeSwitcherSubject.next(showThemeSwitcher);\n\n                if (showThemeSwitcher) {\n                    /** Case when route is changed on the same page (see on breadcrumb component docs page) */\n                    if (\n                        typeof this.isDarkModeEnabledSubject.getValue() ===\n                        \"boolean\"\n                    ) {\n                        this.darkThemePreference = window.matchMedia(\n                            \"(prefers-color-scheme: dark)\"\n                        );\n                        return;\n                    }\n\n                    this.enableColorSchemePreferenceHandling();\n                } else {\n                    /** Reset to light theme */\n                    this.darkModePreferenceHandler(false);\n\n                    this.disableColorSchemePreferenceHandling();\n                }\n            });\n    }\n\n    /**\n     * Use this method to manually toggle your app between light and dark theme\n     *\n     * @param isDarkModeEnabled Use true for dark theme and false for light theme\n     */\n    public setDarkTheme(isDarkModeEnabled: boolean): void {\n        this.darkModePreferenceHandler(isDarkModeEnabled);\n    }\n\n    /**\n     * Use this method to configure the service to synchronize your app's theme with the user's\n     * light/dark mode system preference\n     */\n    public enableColorSchemePreferenceHandling(): void {\n        this.darkThemePreference = window.matchMedia(\n            \"(prefers-color-scheme: dark)\"\n        );\n\n        /** First call to set initial theme */\n        this.darkModePreferenceHandler(this.darkThemePreference.matches);\n\n        /** If browser supports subscribing to MediaQueryList event we do it */\n        if (typeof this.darkThemePreference.addEventListener === \"function\") {\n            this.darkThemePreference.addEventListener(\n                \"change\",\n                this.darkModePreferenceHandler\n            );\n        }\n    }\n\n    /**\n     * Use this method to disable synchronization of your app's theme with the user's light/dark mode\n     * system preference\n     */\n    public disableColorSchemePreferenceHandling(): void {\n        if (\n            this.darkThemePreference &&\n            typeof this.darkThemePreference.removeEventListener === \"function\"\n        ) {\n            this.darkThemePreference.removeEventListener(\n                \"change\",\n                this.darkModePreferenceHandler\n            );\n        }\n    }\n\n    private darkModePreferenceHandler = (\n        event: MediaQueryListEvent | boolean\n    ) => {\n        const isDarkModeEnabled =\n            typeof event === \"boolean\" ? event : event.matches;\n        const isDarkPrevColorMode = this.isDarkModeEnabledSubject.getValue();\n        const demoContainerElement = this.document.children[0];\n\n        /** Adding class \"dark-nova-theme\" to html element we make dark mode, otherwise - light mode */\n        this.renderer[isDarkModeEnabled ? \"addClass\" : \"removeClass\"](\n            demoContainerElement,\n            \"dark-nova-theme\"\n        );\n\n        /**\n         * Reiniting route in case when theme is switching forced\n         * It allows to avoid reiniting route while application is started\n         */\n        if (\n            isDarkPrevColorMode !== null &&\n            isDarkPrevColorMode !== isDarkModeEnabled &&\n            this.withRefreshRoute\n        ) {\n            this.reInitRoute();\n        }\n\n        this.isDarkModeEnabledSubject.next(isDarkModeEnabled);\n    };\n\n    private reInitRoute() {\n        /**\n         * Logic for refreshing route\n         */\n        const scrolledElement = this.document.children[0];\n        const currentScrollTopPosition = scrolledElement.scrollTop;\n        const originalShouldReuseRoute =\n            this.router.routeReuseStrategy.shouldReuseRoute;\n\n        this.router.routeReuseStrategy.shouldReuseRoute = () => false;\n        this.router.navigated = false;\n\n        this.router.navigate([this.router.url]).then(() => {\n            this.router.routeReuseStrategy.shouldReuseRoute =\n                originalShouldReuseRoute;\n\n            /** After reiniting route we should restore scroll position */\n            setTimeout(\n                () => (scrolledElement.scrollTop = currentScrollTopPosition)\n            );\n        });\n    }\n}\n\nexport default ThemeSwitchService;\n"]}