@cisstech/nge
Version:
NG Essentials is a collection of libraries for Angular developers.
204 lines • 23.9 kB
JavaScript
import { Inject, Injectable, Optional } from '@angular/core';
import { BehaviorSubject, firstValueFrom } from 'rxjs';
import { map } from 'rxjs/operators';
import { NGE_MONACO_CONFIG } from '../monaco-config';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export class NgeMonacoThemeService {
constructor(http, config) {
this.http = http;
this.config = config;
this.themes = new BehaviorSubject([]);
this.activeTheme = new BehaviorSubject(undefined);
}
/**
* Gets the current active theme of monaco editor (undefined if monaco editor is not loaded).
*/
get theme() {
return this.activeTheme.value;
}
/**
* Gets an observable that emit each time monaco editor theme change.
*
* Note: The observable emits first with the current theme
* the first time `subscribe()` method is called.
*/
get themeChanges() {
return this.activeTheme.asObservable();
}
/**
* Gets an observable that emit each time monaco editor theme list change.
*/
get themesChanges() {
return this.themes.asObservable().pipe(map((e) => e.slice()) // return a copy of the array
);
}
async activate() {
//this.decorateCreateEditorAPI()
const node = document.createElement('div');
const editor = monaco.editor.create(node);
this.themeService = editor._themeService;
setTimeout(() => editor.dispose());
this.retrieveThemes();
await this.setTheme(this.config?.theming?.default || 'vs');
node.remove();
}
/**
* Switches monaco editor theme.
* @param themeName The new theme to use.
*
*/
async setTheme(themeName) {
await this.defineTheme(themeName);
monaco.editor.setTheme(themeName);
this.activeTheme.next(this.themeService.getColorTheme());
}
/**
* Gets the information about the given `themeName`
* @param themeName The theme to get.
* @returns A promise that resolves with the theme info.
*/
async getTheme(themeName) {
await this.defineTheme(themeName);
return this.themeService._knownThemes.get(themeName);
}
/**
* Defines a theme for the Monaco editor.
* @remarks
* - If the theme is already defined, this method does nothing.
* @param themeName - The name of the theme to define.
* @throws {ReferenceError} If the themeName argument is not provided.
* @throws {Error} If the specified theme is missing.
* @throws {Error} If HttpClientModule is missing in AppModule.
* @returns A Promise that resolves when the theme is defined successfully.
*/
async defineTheme(themeName) {
if (!themeName) {
throw new ReferenceError('Argument "themeName" is required');
}
const knownThemes = this.themeService._knownThemes;
if (knownThemes.has(themeName)) {
return;
}
const customThemePath = this.config?.theming?.themes?.find((e) => {
return this.themeNameFromPath(e) === themeName;
});
if (!customThemePath) {
throw new Error(`[nge-monaco] Missing theme "${themeName}"`);
}
if (!this.http) {
throw new Error('[nge-monaco] Missing HttpClientModule in AppModule. See README for more information');
}
try {
const theme = await firstValueFrom(this.http.get(customThemePath));
monaco.editor.defineTheme(themeName, {
base: theme.base,
inherit: theme.inherit,
rules: theme.rules,
colors: theme.colors,
});
}
catch (error) {
console.error('[nge-monaco] Failed to load theme ' + customThemePath, error);
}
}
retrieveThemes() {
const themes = [];
this.themeService._knownThemes.forEach((theme) => {
themes.push(theme.themeName);
});
const customThemes = (this.config?.theming?.themes || []).map(this.themeNameFromPath.bind(this));
this.themes.next(themes.concat(customThemes));
}
themeNameFromPath(path) {
const name = path.split('/').pop();
if (!name) {
throw new Error(`[nge-monaco]: invalid theme path "${path}"`);
}
return name.replace('.json', '');
}
decorateCreateEditorAPI() {
const createEditor = monaco.editor.create;
monaco.editor.create = (element, options, override) => {
const editor = createEditor.call(monaco.editor, element, options, override);
const updateOptions = editor.updateOptions;
editor.updateOptions = (newOptions) => {
updateOptions.call(editor, newOptions);
if (newOptions.theme) {
this.setTheme(newOptions.theme).catch(console.error);
}
};
if (options?.theme) {
this.setTheme(options.theme).catch(console.error);
}
return editor;
};
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMonacoThemeService, deps: [{ token: i1.HttpClient, optional: true }, { token: NGE_MONACO_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMonacoThemeService, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: NgeMonacoThemeService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: () => [{ type: i1.HttpClient, decorators: [{
type: Optional
}] }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [NGE_MONACO_CONFIG]
}] }] });
/** List of all custom themes from of the library */
export const NGE_MONACO_THEMES = [
'active4d.json',
'all-hallows-eve.json',
'amy.json',
'birds-of-paradise.json',
'blackboard.json',
'brilliance-black.json',
'brilliance-dull.json',
'chrome-devtools.json',
'clouds-midnight.json',
'clouds.json',
'cobalt.json',
'dawn.json',
'dreamweaver.json',
'eiffel.json',
'espresso-libre.json',
'github.json',
'idle-fingers.json',
'idle.json',
'iplastic.json',
'katzenmilch.json',
'kuroir-theme.json',
'kr-theme.json',
'lazy.json',
'magicwb-amiga.json',
'merbivore-soft.json',
'merbivore.json',
'monokai-bright.json',
'monokai.json',
'monoindustrial.json',
'night-owl.json',
'nord.json',
'oceanic-next.json',
'one-dark-pro.json',
'pastels-on-dark.json',
'slush-and-poppies.json',
'solarized-dark.json',
'solarized-light.json',
'space-cadet.json',
'sunburst.json',
'textmate.json',
'tomorrow-night-blue.json',
'tomorrow-night-bright.json',
'tomorrow-night-eighties.json',
'tomorrow-night.json',
'tomorrow.json',
'twilight.json',
'upstream-sunburst.json',
'vibrant-ink.json',
'xcode.json',
'zenburnesque.json',
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monaco-theme.service.js","sourceRoot":"","sources":["../../../../../../projects/nge/monaco/src/services/monaco-theme.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpClient } from '@angular/common/http'\nimport { Inject, Injectable, Optional } from '@angular/core'\nimport { BehaviorSubject, Observable, firstValueFrom } from 'rxjs'\nimport { map } from 'rxjs/operators'\nimport { NgeMonacoContribution } from '../contributions/monaco-contribution'\nimport { NGE_MONACO_CONFIG, NgeMonacoConfig } from '../monaco-config'\n\n@Injectable({ providedIn: 'root' })\nexport class NgeMonacoThemeService implements NgeMonacoContribution {\n  private readonly themes = new BehaviorSubject<string[]>([])\n  private readonly activeTheme = new BehaviorSubject<NgeMonacoTheme | undefined>(undefined)\n\n  private themeService: any\n\n  constructor(\n    @Optional()\n    private readonly http: HttpClient,\n\n    @Optional()\n    @Inject(NGE_MONACO_CONFIG)\n    private readonly config: NgeMonacoConfig\n  ) {}\n\n  /**\n   * Gets the current active theme of monaco editor (undefined if monaco editor is not loaded).\n   */\n  get theme(): NgeMonacoTheme | undefined {\n    return this.activeTheme.value\n  }\n\n  /**\n   * Gets an observable that emit each time monaco editor theme change.\n   *\n   * Note: The observable emits first with the current theme\n   * the first time `subscribe()` method is called.\n   */\n  get themeChanges(): Observable<NgeMonacoTheme | undefined> {\n    return this.activeTheme.asObservable()\n  }\n\n  /**\n   * Gets an observable that emit each time monaco editor theme list change.\n   */\n  get themesChanges(): Observable<string[]> {\n    return this.themes.asObservable().pipe(\n      map((e) => e.slice()) // return a copy of the array\n    )\n  }\n\n  async activate(): Promise<void> {\n    //this.decorateCreateEditorAPI()\n\n    const node = document.createElement('div')\n\n    const editor = monaco.editor.create(node)\n    this.themeService = (editor as any)._themeService\n    setTimeout(() => editor.dispose())\n\n    this.retrieveThemes()\n\n    await this.setTheme(this.config?.theming?.default || 'vs')\n    node.remove()\n  }\n\n  /**\n   * Switches monaco editor theme.\n   * @param themeName The new theme to use.\n   *\n   */\n  async setTheme(themeName: string): Promise<void> {\n    await this.defineTheme(themeName)\n    monaco.editor.setTheme(themeName)\n    this.activeTheme.next(this.themeService.getColorTheme())\n  }\n\n  /**\n   * Gets the information about the given `themeName`\n   * @param themeName The theme to get.\n   * @returns A promise that resolves with the theme info.\n   */\n  async getTheme(themeName: string): Promise<NgeMonacoTheme> {\n    await this.defineTheme(themeName)\n    return this.themeService._knownThemes.get(themeName)\n  }\n\n  /**\n   * Defines a theme for the Monaco editor.\n   * @remarks\n   * - If the theme is already defined, this method does nothing.\n   * @param themeName - The name of the theme to define.\n   * @throws {ReferenceError} If the themeName argument is not provided.\n   * @throws {Error} If the specified theme is missing.\n   * @throws {Error} If HttpClientModule is missing in AppModule.\n   * @returns A Promise that resolves when the theme is defined successfully.\n   */\n  async defineTheme(themeName: string): Promise<void> {\n    if (!themeName) {\n      throw new ReferenceError('Argument \"themeName\" is required')\n    }\n\n    const knownThemes: Map<string, NgeMonacoTheme> = this.themeService._knownThemes\n    if (knownThemes.has(themeName)) {\n      return\n    }\n\n    const customThemePath = this.config?.theming?.themes?.find((e) => {\n      return this.themeNameFromPath(e) === themeName\n    })\n    if (!customThemePath) {\n      throw new Error(`[nge-monaco] Missing theme \"${themeName}\"`)\n    }\n\n    if (!this.http) {\n      throw new Error('[nge-monaco] Missing HttpClientModule in AppModule. See README for more information')\n    }\n\n    try {\n      const theme = await firstValueFrom(this.http.get<any>(customThemePath))\n      monaco.editor.defineTheme(themeName, {\n        base: theme.base,\n        inherit: theme.inherit,\n        rules: theme.rules,\n        colors: theme.colors as any,\n      })\n    } catch (error) {\n      console.error('[nge-monaco] Failed to load theme ' + customThemePath, error)\n    }\n  }\n\n  private retrieveThemes(): void {\n    const themes: string[] = []\n    this.themeService._knownThemes.forEach((theme: any) => {\n      themes.push(theme.themeName)\n    })\n    const customThemes: string[] = (this.config?.theming?.themes || []).map(this.themeNameFromPath.bind(this))\n    this.themes.next(themes.concat(customThemes))\n  }\n\n  private themeNameFromPath(path: string): string {\n    const name = path.split('/').pop()\n    if (!name) {\n      throw new Error(`[nge-monaco]: invalid theme path \"${path}\"`)\n    }\n    return name.replace('.json', '')\n  }\n\n  private decorateCreateEditorAPI(): void {\n    const createEditor = monaco.editor.create\n    monaco.editor.create = (\n      element: HTMLElement,\n      options?: monaco.editor.IStandaloneEditorConstructionOptions | undefined,\n      override?: monaco.editor.IEditorOverrideServices | undefined\n    ) => {\n      const editor = createEditor.call(monaco.editor, element, options, override)\n      const updateOptions = editor.updateOptions\n      editor.updateOptions = (newOptions: monaco.editor.IStandaloneEditorConstructionOptions) => {\n        updateOptions.call(editor, newOptions)\n        if (newOptions.theme) {\n          this.setTheme(newOptions.theme).catch(console.error)\n        }\n      }\n\n      if (options?.theme) {\n        this.setTheme(options.theme).catch(console.error)\n      }\n      return editor\n    }\n  }\n}\n\nexport interface NgeMonacoTheme {\n  id: string\n  type: 'light' | 'dark' | 'hc'\n  colors: Map<string, any>\n  themeName: string\n  semanticHighlighting: boolean\n  themeData: monaco.editor.IStandaloneThemeData\n  defaultColors: Map<string, any>\n  defines(colorId: string): boolean\n  getColor(colorId: string, useDefault?: boolean): any\n  getColors(): Map<string, any>\n}\n\n/** List of all custom themes from of the library */\nexport const NGE_MONACO_THEMES = [\n  'active4d.json',\n  'all-hallows-eve.json',\n  'amy.json',\n  'birds-of-paradise.json',\n  'blackboard.json',\n  'brilliance-black.json',\n  'brilliance-dull.json',\n  'chrome-devtools.json',\n  'clouds-midnight.json',\n  'clouds.json',\n  'cobalt.json',\n  'dawn.json',\n  'dreamweaver.json',\n  'eiffel.json',\n  'espresso-libre.json',\n  'github.json',\n  'idle-fingers.json',\n  'idle.json',\n  'iplastic.json',\n  'katzenmilch.json',\n  'kuroir-theme.json',\n  'kr-theme.json',\n  'lazy.json',\n  'magicwb-amiga.json',\n  'merbivore-soft.json',\n  'merbivore.json',\n  'monokai-bright.json',\n  'monokai.json',\n  'monoindustrial.json',\n  'night-owl.json',\n  'nord.json',\n  'oceanic-next.json',\n  'one-dark-pro.json',\n  'pastels-on-dark.json',\n  'slush-and-poppies.json',\n  'solarized-dark.json',\n  'solarized-light.json',\n  'space-cadet.json',\n  'sunburst.json',\n  'textmate.json',\n  'tomorrow-night-blue.json',\n  'tomorrow-night-bright.json',\n  'tomorrow-night-eighties.json',\n  'tomorrow-night.json',\n  'tomorrow.json',\n  'twilight.json',\n  'upstream-sunburst.json',\n  'vibrant-ink.json',\n  'xcode.json',\n  'zenburnesque.json',\n]\n"]}