ngx-quill

ngx-quill

Version 27.0.2
Published 15 days ago
177 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,
    true,
    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 {}

property config

readonly config: QuillConfig;

property ɵfac

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

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)

tslib

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (3)

Badge

To add a badge like this oneto 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>

Updated 14 days ago.
Package analyzed in 5107 ms.
Missing or incorrect documentation? Open an issue for this package.