ngx-quill
Version:
Angular components for the easy use of the QuillJS richt text editor.
86 lines • 14.1 kB
JavaScript
import { DOCUMENT } from '@angular/common';
import { Injectable, Inject, Optional } from '@angular/core';
import { defer, firstValueFrom, isObservable } from 'rxjs';
import { shareReplay } from 'rxjs/operators';
import { defaultModules, QUILL_CONFIG_TOKEN, } from 'ngx-quill/config';
import * as i0 from "@angular/core";
class QuillService {
constructor(injector, config) {
this.config = config;
this.quill$ = defer(async () => {
if (!this.Quill) {
// Quill adds events listeners on import https://github.com/quilljs/quill/blob/develop/core/emitter.js#L8
// We'd want to use the unpatched `addEventListener` method to have all event callbacks to be run outside of zone.
// We don't know yet if the `zone.js` is used or not, just save the value to restore it back further.
const maybePatchedAddEventListener = this.document.addEventListener;
// There're 2 types of Angular applications:
// 1) zone-full (by default)
// 2) zone-less
// The developer can avoid importing the `zone.js` package and tells Angular that he/she is responsible for running
// the change detection by himself. This is done by "nooping" the zone through `CompilerOptions` when bootstrapping
// the root module. We fallback to `document.addEventListener` if `__zone_symbol__addEventListener` is not defined,
// this means the `zone.js` is not imported.
// The `__zone_symbol__addEventListener` is basically a native DOM API, which is not patched by zone.js, thus not even going
// through the `zone.js` task lifecycle. You can also access the native DOM API as follows `target[Zone.__symbol__('methodName')]`.
this.document.addEventListener =
// eslint-disable-next-line @typescript-eslint/dot-notation
this.document['__zone_symbol__addEventListener'] ||
this.document.addEventListener;
const quillImport = await import(/* webpackChunkName: 'quill' */ 'quill');
this.document.addEventListener = maybePatchedAddEventListener;
this.Quill = (quillImport.default ? quillImport.default : quillImport);
}
// Only register custom options and modules once
this.config.customOptions?.forEach((customOption) => {
const newCustomOption = this.Quill.import(customOption.import);
newCustomOption.whitelist = customOption.whitelist;
this.Quill.register(newCustomOption, true, this.config.suppressGlobalRegisterWarning);
});
return await this.registerCustomModules(this.Quill, this.config.customModules, this.config.suppressGlobalRegisterWarning);
}).pipe(shareReplay({ bufferSize: 1, refCount: true }));
this.document = injector.get(DOCUMENT);
if (!this.config) {
this.config = { modules: defaultModules };
}
}
getQuill() {
return this.quill$;
}
/**
* Marked as internal so it won't be available for `ngx-quill` consumers, this is only
* internal method to be used within the library.
*
* @internal
*/
async registerCustomModules(Quill, customModules, suppressGlobalRegisterWarning) {
if (Array.isArray(customModules)) {
// eslint-disable-next-line prefer-const
for (let { implementation, path } of customModules) {
// The `implementation` might be an observable that resolves the actual implementation,
// e.g. if it should be lazy loaded.
if (isObservable(implementation)) {
implementation = await firstValueFrom(implementation);
}
Quill.register(path, implementation, suppressGlobalRegisterWarning);
}
}
// Return `Quill` constructor so we'll be able to re-use its return value except of using
// `map` operators, etc.
return Quill;
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: QuillService, deps: [{ token: i0.Injector }, { token: QUILL_CONFIG_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: QuillService, providedIn: 'root' }); }
}
export { QuillService };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.5", ngImport: i0, type: QuillService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root',
}]
}], ctorParameters: function () { return [{ type: i0.Injector }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [QUILL_CONFIG_TOKEN]
}] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quill.service.js","sourceRoot":"","sources":["../../../../projects/ngx-quill/src/lib/quill.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common'\nimport { Injectable, Inject, Injector, Optional } from '@angular/core'\nimport { defer, firstValueFrom, isObservable, Observable } from 'rxjs'\nimport { shareReplay } from 'rxjs/operators'\n\nimport {\n  defaultModules,\n  QUILL_CONFIG_TOKEN,\n  QuillConfig,\n  CustomModule,\n} from 'ngx-quill/config'\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class QuillService {\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  private Quill!: any\n  private document: Document\n  private quill$: Observable<any> = defer(async () => {\n    if (!this.Quill) {\n      // Quill adds events listeners on import https://github.com/quilljs/quill/blob/develop/core/emitter.js#L8\n      // We'd want to use the unpatched `addEventListener` method to have all event callbacks to be run outside of zone.\n      // We don't know yet if the `zone.js` is used or not, just save the value to restore it back further.\n      const maybePatchedAddEventListener = this.document.addEventListener\n      // There're 2 types of Angular applications:\n      // 1) zone-full (by default)\n      // 2) zone-less\n      // The developer can avoid importing the `zone.js` package and tells Angular that he/she is responsible for running\n      // the change detection by himself. This is done by \"nooping\" the zone through `CompilerOptions` when bootstrapping\n      // the root module. We fallback to `document.addEventListener` if `__zone_symbol__addEventListener` is not defined,\n      // this means the `zone.js` is not imported.\n      // The `__zone_symbol__addEventListener` is basically a native DOM API, which is not patched by zone.js, thus not even going\n      // through the `zone.js` task lifecycle. You can also access the native DOM API as follows `target[Zone.__symbol__('methodName')]`.\n      this.document.addEventListener =\n        // eslint-disable-next-line @typescript-eslint/dot-notation\n        this.document['__zone_symbol__addEventListener'] ||\n        this.document.addEventListener\n      const quillImport = await import(/* webpackChunkName: 'quill' */ 'quill')\n      this.document.addEventListener = maybePatchedAddEventListener\n\n      this.Quill = (\n        quillImport.default ? quillImport.default : quillImport\n      ) as any\n    }\n\n    // Only register custom options and modules once\n    this.config.customOptions?.forEach((customOption) => {\n      const newCustomOption = this.Quill.import(customOption.import)\n      newCustomOption.whitelist = customOption.whitelist\n      this.Quill.register(\n        newCustomOption,\n        true,\n        this.config.suppressGlobalRegisterWarning\n      )\n    })\n\n    return await this.registerCustomModules(\n      this.Quill,\n      this.config.customModules,\n      this.config.suppressGlobalRegisterWarning\n    )\n  }).pipe(shareReplay({ bufferSize: 1, refCount: true }))\n\n  constructor(\n    injector: Injector,\n    @Optional() @Inject(QUILL_CONFIG_TOKEN) public config: QuillConfig\n  ) {\n    this.document = injector.get(DOCUMENT)\n\n    if (!this.config) {\n      this.config = { modules: defaultModules }\n    }\n  }\n\n  getQuill() {\n    return this.quill$\n  }\n\n  /**\n   * Marked as internal so it won't be available for `ngx-quill` consumers, this is only\n   * internal method to be used within the library.\n   *\n   * @internal\n   */\n  async registerCustomModules(\n    Quill: any,\n    customModules: CustomModule[] | undefined,\n    suppressGlobalRegisterWarning?: boolean\n  ): Promise<any> {\n    if (Array.isArray(customModules)) {\n      // eslint-disable-next-line prefer-const\n      for (let { implementation, path } of customModules) {\n        // The `implementation` might be an observable that resolves the actual implementation,\n        // e.g. if it should be lazy loaded.\n        if (isObservable(implementation)) {\n          implementation = await firstValueFrom(implementation)\n        }\n        Quill.register(path, implementation, suppressGlobalRegisterWarning)\n      }\n    }\n\n    // Return `Quill` constructor so we'll be able to re-use its return value except of using\n    // `map` operators, etc.\n    return Quill\n  }\n}\n"]}