ngx-quill

  • Version 26.0.5
  • Published
  • 343 kB
  • 1 dependency
  • MIT license

Install

npm i ngx-quill
yarn add ngx-quill
pnpm add ngx-quill

Overview

Angular components for the easy use of the QuillJS richt text editor.

Index

Classes

class QuillEditorBase

abstract class QuillEditorBase
implements
AfterViewInit,
ControlValueAccessor,
OnChanges,
OnInit,
OnDestroy,
Validator {}

    property beforeRender

    readonly beforeRender: any;

      property bounds

      readonly bounds: any;

        property classes

        readonly classes: any;

          property compareValues

          readonly compareValues: any;

            property content

            content: any;

              property customModules

              readonly customModules: any;

                property customOptions

                readonly customOptions: any;

                  property customToolbarPosition

                  readonly customToolbarPosition: any;

                    property debounceTime

                    readonly debounceTime: any;

                      property debug

                      readonly debug: any;

                        property defaultEmptyValue

                        readonly defaultEmptyValue: any;

                          property disabled

                          disabled: boolean;

                            property editorChangeHandler

                            editorChangeHandler: (
                            event: 'text-change' | 'selection-change',
                            current: any | Range | null,
                            old: any | Range | null,
                            source: string
                            ) => void;

                              property editorElem

                              editorElem: HTMLElement;

                                property filterNull

                                readonly filterNull: any;

                                  property format

                                  readonly format: any;

                                    property formats

                                    readonly formats: any;

                                      property linkPlaceholder

                                      readonly linkPlaceholder: any;

                                        property maxLength

                                        readonly maxLength: any;

                                          property minLength

                                          readonly minLength: any;

                                            property modules

                                            readonly modules: any;

                                              property onBlur

                                              onBlur: EventEmitter<Blur>;

                                                property onContentChanged

                                                onContentChanged: EventEmitter<ContentChange>;

                                                  property onEditorChanged

                                                  onEditorChanged: EventEmitter<EditorChangeContent | EditorChangeSelection>;

                                                    property onEditorCreated

                                                    onEditorCreated: EventEmitter<QuillType>;

                                                      property onFocus

                                                      onFocus: EventEmitter<Focus>;

                                                        property onModelChange

                                                        onModelChange: (modelValue?: any) => void;

                                                          property onModelTouched

                                                          onModelTouched: () => void;

                                                            property onNativeBlur

                                                            onNativeBlur: EventEmitter<Blur>;

                                                              property onNativeFocus

                                                              onNativeFocus: EventEmitter<Focus>;

                                                                property onSelectionChanged

                                                                onSelectionChanged: EventEmitter<SelectionChange>;

                                                                  property onValidatorChanged

                                                                  onValidatorChanged: () => void;

                                                                    property ɵdir

                                                                    static ɵdir: i0.ɵɵDirectiveDeclaration<
                                                                    QuillEditorBase,
                                                                    never,
                                                                    never,
                                                                    {
                                                                    format: { alias: 'format'; required: false; isSignal: true };
                                                                    theme: { alias: 'theme'; required: false; isSignal: true };
                                                                    modules: { alias: 'modules'; required: false; isSignal: true };
                                                                    debug: { alias: 'debug'; required: false; isSignal: true };
                                                                    readOnly: { alias: 'readOnly'; required: false; isSignal: true };
                                                                    placeholder: { alias: 'placeholder'; required: false; isSignal: true };
                                                                    maxLength: { alias: 'maxLength'; required: false; isSignal: true };
                                                                    minLength: { alias: 'minLength'; required: false; isSignal: true };
                                                                    required: { alias: 'required'; required: false; isSignal: true };
                                                                    formats: { alias: 'formats'; required: false; isSignal: true };
                                                                    customToolbarPosition: {
                                                                    alias: 'customToolbarPosition';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    sanitize: { alias: 'sanitize'; required: false; isSignal: true };
                                                                    beforeRender: { alias: 'beforeRender'; required: false; isSignal: true };
                                                                    styles: { alias: 'styles'; required: false; isSignal: true };
                                                                    registry: { alias: 'registry'; required: false; isSignal: true };
                                                                    bounds: { alias: 'bounds'; required: false; isSignal: true };
                                                                    customOptions: {
                                                                    alias: 'customOptions';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    customModules: {
                                                                    alias: 'customModules';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    trackChanges: { alias: 'trackChanges'; required: false; isSignal: true };
                                                                    classes: { alias: 'classes'; required: false; isSignal: true };
                                                                    trimOnValidation: {
                                                                    alias: 'trimOnValidation';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    linkPlaceholder: {
                                                                    alias: 'linkPlaceholder';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    compareValues: {
                                                                    alias: 'compareValues';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    filterNull: { alias: 'filterNull'; required: false; isSignal: true };
                                                                    debounceTime: { alias: 'debounceTime'; required: false; isSignal: true };
                                                                    defaultEmptyValue: {
                                                                    alias: 'defaultEmptyValue';
                                                                    required: false;
                                                                    isSignal: true;
                                                                    };
                                                                    valueGetter: { alias: 'valueGetter'; required: false; isSignal: true };
                                                                    valueSetter: { alias: 'valueSetter'; required: false; isSignal: true };
                                                                    },
                                                                    {
                                                                    onEditorCreated: 'onEditorCreated';
                                                                    onEditorChanged: 'onEditorChanged';
                                                                    onContentChanged: 'onContentChanged';
                                                                    onSelectionChanged: 'onSelectionChanged';
                                                                    onFocus: 'onFocus';
                                                                    onBlur: 'onBlur';
                                                                    onNativeFocus: 'onNativeFocus';
                                                                    onNativeBlur: 'onNativeBlur';
                                                                    },
                                                                    never,
                                                                    never,
                                                                    false,
                                                                    never
                                                                    >;

                                                                      property ɵfac

                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<QuillEditorBase, never>;

                                                                        property placeholder

                                                                        readonly placeholder: any;

                                                                          property quillEditor

                                                                          quillEditor: QuillType;

                                                                            property readOnly

                                                                            readonly readOnly: any;

                                                                              property registry

                                                                              readonly registry: any;

                                                                                property required

                                                                                readonly required: any;

                                                                                  property sanitize

                                                                                  readonly sanitize: any;

                                                                                    property selectionChangeHandler

                                                                                    selectionChangeHandler: (
                                                                                    range: Range | null,
                                                                                    oldRange: Range | null,
                                                                                    source: string
                                                                                    ) => void;

                                                                                      property styles

                                                                                      readonly styles: any;

                                                                                        property textChangeHandler

                                                                                        textChangeHandler: (
                                                                                        delta: DeltaType,
                                                                                        oldDelta: DeltaType,
                                                                                        source: string
                                                                                        ) => void;

                                                                                          property theme

                                                                                          readonly theme: any;

                                                                                            property toolbarPosition

                                                                                            readonly toolbarPosition: any;

                                                                                              property trackChanges

                                                                                              readonly trackChanges: any;

                                                                                                property trimOnValidation

                                                                                                readonly trimOnValidation: any;

                                                                                                  property valueGetter

                                                                                                  valueGetter: any;

                                                                                                    property valueSetter

                                                                                                    valueSetter: any;

                                                                                                      method addClasses

                                                                                                      addClasses: (classList: string) => void;

                                                                                                        method ngAfterViewInit

                                                                                                        ngAfterViewInit: () => void;

                                                                                                          method ngOnChanges

                                                                                                          ngOnChanges: (changes: SimpleChanges) => void;

                                                                                                            method ngOnDestroy

                                                                                                            ngOnDestroy: () => void;

                                                                                                              method ngOnInit

                                                                                                              ngOnInit: () => void;

                                                                                                                method normalizeClassNames

                                                                                                                static normalizeClassNames: (classes: string) => string[];

                                                                                                                  method registerOnChange

                                                                                                                  registerOnChange: (fn: (modelValue: any) => void) => void;

                                                                                                                    method registerOnTouched

                                                                                                                    registerOnTouched: (fn: () => void) => void;

                                                                                                                      method registerOnValidatorChange

                                                                                                                      registerOnValidatorChange: (fn: () => void) => void;

                                                                                                                        method removeClasses

                                                                                                                        removeClasses: (classList: string) => void;

                                                                                                                          method setDisabledState

                                                                                                                          setDisabledState: (isDisabled?: boolean) => void;

                                                                                                                            method validate

                                                                                                                            validate: () => {
                                                                                                                            minLengthError?: { given: number; minLength: number };
                                                                                                                            maxLengthError?: { given: number; maxLength: number };
                                                                                                                            requiredError?: { empty: boolean };
                                                                                                                            };

                                                                                                                              method writeValue

                                                                                                                              writeValue: (currentValue: any) => void;

                                                                                                                                class QuillEditorComponent

                                                                                                                                class QuillEditorComponent extends QuillEditorBase {}

                                                                                                                                  property ɵcmp

                                                                                                                                  static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                  QuillEditorComponent,
                                                                                                                                  'quill-editor',
                                                                                                                                  never,
                                                                                                                                  {},
                                                                                                                                  {},
                                                                                                                                  never,
                                                                                                                                  [
                                                                                                                                  '[above-quill-editor-toolbar]',
                                                                                                                                  '[quill-editor-toolbar]',
                                                                                                                                  '[below-quill-editor-toolbar]'
                                                                                                                                  ],
                                                                                                                                  true,
                                                                                                                                  never
                                                                                                                                  >;

                                                                                                                                    property ɵfac

                                                                                                                                    static ɵfac: i0.ɵɵFactoryDeclaration<QuillEditorComponent, never>;

                                                                                                                                      class QuillModule

                                                                                                                                      class QuillModule {}

                                                                                                                                        property ɵfac

                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<QuillModule, never>;

                                                                                                                                          property ɵinj

                                                                                                                                          static ɵinj: i0.ɵɵInjectorDeclaration<QuillModule>;

                                                                                                                                            property ɵmod

                                                                                                                                            static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                            QuillModule,
                                                                                                                                            never,
                                                                                                                                            [
                                                                                                                                            typeof i1.QuillEditorComponent,
                                                                                                                                            typeof i2.QuillViewComponent,
                                                                                                                                            typeof i3.QuillViewHTMLComponent
                                                                                                                                            ],
                                                                                                                                            [
                                                                                                                                            typeof i1.QuillEditorComponent,
                                                                                                                                            typeof i2.QuillViewComponent,
                                                                                                                                            typeof i3.QuillViewHTMLComponent
                                                                                                                                            ]
                                                                                                                                            >;

                                                                                                                                              method forRoot

                                                                                                                                              static forRoot: (config?: QuillConfig) => ModuleWithProviders<QuillModule>;

                                                                                                                                                class QuillService

                                                                                                                                                class QuillService {}

                                                                                                                                                  constructor

                                                                                                                                                  constructor(injector: Injector, config: QuillConfig);

                                                                                                                                                    property config

                                                                                                                                                    config: QuillConfig;

                                                                                                                                                      property ɵfac

                                                                                                                                                      static ɵfac: i0.ɵɵFactoryDeclaration<QuillService, [null, { optional: true }]>;

                                                                                                                                                        property ɵprov

                                                                                                                                                        static ɵprov: i0.ɵɵInjectableDeclaration<QuillService>;

                                                                                                                                                          method getQuill

                                                                                                                                                          getQuill: () => Observable<any>;

                                                                                                                                                            class QuillViewComponent

                                                                                                                                                            class QuillViewComponent implements AfterViewInit, OnChanges, OnDestroy {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(
                                                                                                                                                              elementRef: ElementRef,
                                                                                                                                                              renderer: Renderer2,
                                                                                                                                                              zone: NgZone,
                                                                                                                                                              service: QuillService,
                                                                                                                                                              domSanitizer: DomSanitizer,
                                                                                                                                                              platformId: any
                                                                                                                                                              );

                                                                                                                                                                property beforeRender

                                                                                                                                                                readonly beforeRender: any;

                                                                                                                                                                  property content

                                                                                                                                                                  readonly content: any;

                                                                                                                                                                    property customModules

                                                                                                                                                                    readonly customModules: any;

                                                                                                                                                                      property customOptions

                                                                                                                                                                      readonly customOptions: any;

                                                                                                                                                                        property debug

                                                                                                                                                                        readonly debug: any;

                                                                                                                                                                          property domSanitizer

                                                                                                                                                                          protected domSanitizer: DomSanitizer;

                                                                                                                                                                            property editorElem

                                                                                                                                                                            editorElem: HTMLElement;

                                                                                                                                                                              property elementRef

                                                                                                                                                                              elementRef: ElementRef;

                                                                                                                                                                                property format

                                                                                                                                                                                readonly format: any;

                                                                                                                                                                                  property formats

                                                                                                                                                                                  readonly formats: any;

                                                                                                                                                                                    property modules

                                                                                                                                                                                    readonly modules: any;

                                                                                                                                                                                      property onEditorCreated

                                                                                                                                                                                      onEditorCreated: EventEmitter<any>;

                                                                                                                                                                                        property ɵcmp

                                                                                                                                                                                        static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                        QuillViewComponent,
                                                                                                                                                                                        'quill-view',
                                                                                                                                                                                        never,
                                                                                                                                                                                        {
                                                                                                                                                                                        format: { alias: 'format'; required: false; isSignal: true };
                                                                                                                                                                                        theme: { alias: 'theme'; required: false; isSignal: true };
                                                                                                                                                                                        modules: { alias: 'modules'; required: false; isSignal: true };
                                                                                                                                                                                        debug: { alias: 'debug'; required: false; isSignal: true };
                                                                                                                                                                                        formats: { alias: 'formats'; required: false; isSignal: true };
                                                                                                                                                                                        sanitize: { alias: 'sanitize'; required: false; isSignal: true };
                                                                                                                                                                                        beforeRender: { alias: 'beforeRender'; required: false; isSignal: true };
                                                                                                                                                                                        strict: { alias: 'strict'; required: false; isSignal: true };
                                                                                                                                                                                        content: { alias: 'content'; required: false; isSignal: true };
                                                                                                                                                                                        customModules: {
                                                                                                                                                                                        alias: 'customModules';
                                                                                                                                                                                        required: false;
                                                                                                                                                                                        isSignal: true;
                                                                                                                                                                                        };
                                                                                                                                                                                        customOptions: {
                                                                                                                                                                                        alias: 'customOptions';
                                                                                                                                                                                        required: false;
                                                                                                                                                                                        isSignal: true;
                                                                                                                                                                                        };
                                                                                                                                                                                        },
                                                                                                                                                                                        { onEditorCreated: 'onEditorCreated' },
                                                                                                                                                                                        never,
                                                                                                                                                                                        never,
                                                                                                                                                                                        true,
                                                                                                                                                                                        never
                                                                                                                                                                                        >;

                                                                                                                                                                                          property ɵfac

                                                                                                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<QuillViewComponent, never>;

                                                                                                                                                                                            property platformId

                                                                                                                                                                                            protected platformId: any;

                                                                                                                                                                                              property quillEditor

                                                                                                                                                                                              quillEditor: QuillType;

                                                                                                                                                                                                property renderer

                                                                                                                                                                                                protected renderer: Renderer2;

                                                                                                                                                                                                  property sanitize

                                                                                                                                                                                                  readonly sanitize: any;

                                                                                                                                                                                                    property service

                                                                                                                                                                                                    protected service: QuillService;

                                                                                                                                                                                                      property strict

                                                                                                                                                                                                      readonly strict: any;

                                                                                                                                                                                                        property theme

                                                                                                                                                                                                        readonly theme: any;

                                                                                                                                                                                                          property valueSetter

                                                                                                                                                                                                          valueSetter: (quillEditor: QuillType, value: any) => any;

                                                                                                                                                                                                            property zone

                                                                                                                                                                                                            protected zone: NgZone;

                                                                                                                                                                                                              method ngAfterViewInit

                                                                                                                                                                                                              ngAfterViewInit: () => void;

                                                                                                                                                                                                                method ngOnChanges

                                                                                                                                                                                                                ngOnChanges: (changes: SimpleChanges) => void;

                                                                                                                                                                                                                  method ngOnDestroy

                                                                                                                                                                                                                  ngOnDestroy: () => void;

                                                                                                                                                                                                                    class QuillViewHTMLComponent

                                                                                                                                                                                                                    class QuillViewHTMLComponent implements OnChanges {}

                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                      constructor(sanitizer: DomSanitizer, service: QuillService);

                                                                                                                                                                                                                        property content

                                                                                                                                                                                                                        readonly content: any;

                                                                                                                                                                                                                          property innerHTML

                                                                                                                                                                                                                          readonly innerHTML: any;

                                                                                                                                                                                                                            property ɵcmp

                                                                                                                                                                                                                            static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                            QuillViewHTMLComponent,
                                                                                                                                                                                                                            'quill-view-html',
                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                            {
                                                                                                                                                                                                                            content: { alias: 'content'; required: false; isSignal: true };
                                                                                                                                                                                                                            theme: { alias: 'theme'; required: false; isSignal: true };
                                                                                                                                                                                                                            sanitize: { alias: 'sanitize'; required: false; isSignal: true };
                                                                                                                                                                                                                            },
                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                            never,
                                                                                                                                                                                                                            true,
                                                                                                                                                                                                                            never
                                                                                                                                                                                                                            >;

                                                                                                                                                                                                                              property ɵfac

                                                                                                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<QuillViewHTMLComponent, never>;

                                                                                                                                                                                                                                property sanitize

                                                                                                                                                                                                                                readonly sanitize: any;

                                                                                                                                                                                                                                  property service

                                                                                                                                                                                                                                  protected service: QuillService;

                                                                                                                                                                                                                                    property theme

                                                                                                                                                                                                                                    readonly theme: any;

                                                                                                                                                                                                                                      property themeClass

                                                                                                                                                                                                                                      readonly themeClass: any;

                                                                                                                                                                                                                                        method ngOnChanges

                                                                                                                                                                                                                                        ngOnChanges: (changes: SimpleChanges) => void;

                                                                                                                                                                                                                                          Interfaces

                                                                                                                                                                                                                                          interface Blur

                                                                                                                                                                                                                                          interface Blur {}

                                                                                                                                                                                                                                            property editor

                                                                                                                                                                                                                                            editor: QuillType;

                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                              source: string;

                                                                                                                                                                                                                                                interface ContentChange

                                                                                                                                                                                                                                                interface ContentChange {}

                                                                                                                                                                                                                                                  property content

                                                                                                                                                                                                                                                  content: DeltaType;

                                                                                                                                                                                                                                                    property delta

                                                                                                                                                                                                                                                    delta: DeltaType;

                                                                                                                                                                                                                                                      property editor

                                                                                                                                                                                                                                                      editor: QuillType;

                                                                                                                                                                                                                                                        property html

                                                                                                                                                                                                                                                        html: string | null;

                                                                                                                                                                                                                                                          property oldDelta

                                                                                                                                                                                                                                                          oldDelta: DeltaType;

                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                            source: string;

                                                                                                                                                                                                                                                              property text

                                                                                                                                                                                                                                                              text: string;

                                                                                                                                                                                                                                                                interface Focus

                                                                                                                                                                                                                                                                interface Focus {}

                                                                                                                                                                                                                                                                  property editor

                                                                                                                                                                                                                                                                  editor: QuillType;

                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                      interface Range

                                                                                                                                                                                                                                                                      interface Range {}

                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                        index: number;

                                                                                                                                                                                                                                                                          property length

                                                                                                                                                                                                                                                                          length: number;

                                                                                                                                                                                                                                                                            interface SelectionChange

                                                                                                                                                                                                                                                                            interface SelectionChange {}

                                                                                                                                                                                                                                                                              property editor

                                                                                                                                                                                                                                                                              editor: QuillType;

                                                                                                                                                                                                                                                                                property oldRange

                                                                                                                                                                                                                                                                                oldRange: Range | null;

                                                                                                                                                                                                                                                                                  property range

                                                                                                                                                                                                                                                                                  range: Range | null;

                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                      type EditorChangeContent

                                                                                                                                                                                                                                                                                      type EditorChangeContent = ContentChange & {
                                                                                                                                                                                                                                                                                      event: 'text-change';
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        type EditorChangeSelection

                                                                                                                                                                                                                                                                                        type EditorChangeSelection = SelectionChange & {
                                                                                                                                                                                                                                                                                        event: 'selection-change';
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          Package Files (6)

                                                                                                                                                                                                                                                                                          Dependencies (1)

                                                                                                                                                                                                                                                                                          Dev Dependencies (0)

                                                                                                                                                                                                                                                                                          No dev dependencies.

                                                                                                                                                                                                                                                                                          Peer Dependencies (3)

                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ngx-quill.

                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ngx-quill)
                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/ngx-quill"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>