124 |
129 |         <textarea
130 |           style={{ display:'block', width:300, height:300 }}
131 |           value={this.state.events.join('\n')}
132 |           readOnly={true}
133 |         />
134 |       </div>
135 |     );
136 |   }
137 | 
138 | }
139 | 
140 | const root = ReactDOM.createRoot(document.getElementById('app'));
141 | 
142 | root.render(
143 |   <React.StrictMode>
144 |     <Editor />
145 |   </React.StrictMode>
146 | );
147 | 


--------------------------------------------------------------------------------
/test/index.spec.js:
--------------------------------------------------------------------------------
  1 | // load Cypress TypeScript definitions for IntelliSense
  2 | /// <reference types="cypress" />
  3 | 
  4 | import React from "react";
  5 | import ReactDOM from "react-dom";
  6 | import Quill from "quill";
  7 | import ReactQuill from "../lib";
  8 | 
  9 | Cypress.Commands.add("renderWithProps", (props = {}) => {
 10 |   return cy.window().then(w => {
 11 |     const target = w.document.getElementById("app");
 12 |     function TestHarness() {
 13 |       const [editorProps, setEditorProps] = React.useState(props);
 14 |       w.setProps = setEditorProps;
 15 |       w.editorRef = React.useRef();
 16 |       return <ReactQuill {...editorProps} ref={w.editorRef} />;
 17 |     }
 18 |     ReactDOM.render(<TestHarness />, target);
 19 |   });
 20 | });
 21 | 
 22 | Cypress.Commands.add("setProps", (props = {}) => {
 23 |   return cy.window().then(window => {
 24 |     // Hook into function provided by test harness:
 25 |     window.setProps(props);
 26 |   });
 27 | });
 28 | 
 29 | // Returns the editor contenteditable node
 30 | Cypress.Commands.add("getEditor", () => {
 31 |   return cy.get(".ql-editor");
 32 | });
 33 | 
 34 | // Returns a reference to the editor react element
 35 | Cypress.Commands.add("getEditorRef", () =>
 36 |   cy.window().then(w => w.editorRef.current)
 37 | );
 38 | 
 39 | describe("<ReactQuill />", () => {
 40 |   beforeEach(() => {
 41 |     cy.visit("/test.html");
 42 |   });
 43 | 
 44 |   it("can type in editor", function() {
 45 |     cy.renderWithProps({});
 46 |     cy.getEditor()
 47 |       .type("hello world\n\nfoo bar")
 48 |       .should("contain", "hello world")
 49 |       .should("contain", "foo bar");
 50 |   });
 51 | 
 52 |   it("can set value with HTML string", function() {
 53 |     const text = "Hello, world";
 54 |     cy.renderWithProps({
 55 |       value: `<p>${text}</p>`
 56 |     });
 57 |     cy.getEditor().should("contain", text);
 58 |   });
 59 | 
 60 |   it("can set value with Quill delta", function() {
 61 |     const text = "Hello, world";
 62 |     const delta = { ops: [{ insert: text }] };
 63 |     cy.renderWithProps({
 64 |       value: delta
 65 |     });
 66 |     cy.getEditor().should("contain", text);
 67 |   });
 68 | 
 69 |   it("updates the content when the value prop changes", () => {
 70 |     const text = "Hello, world";
 71 |     const change = "Goodbye, world";
 72 |     cy.renderWithProps({value: text})
 73 |       .getEditor()
 74 |         .should("contain", text)
 75 |       .setProps({value: change})
 76 |       .getEditor()
 77 |         .should("contain", change)
 78 |         .should("not.contain", text);
 79 |   });
 80 | 
 81 | 
 82 |   it("allows using Deltas as defaultValue", () => {
 83 |     const text = "Hello, world";
 84 |     const delta = { ops: [{ insert: text }] };
 85 |     cy.renderWithProps({
 86 |       defaultValue: delta
 87 |     });
 88 |     cy.getEditor().should("contain", text);
 89 |   });
 90 | 
 91 |   it("allows using Deltas as defaultValue", () => {
 92 |     const text = "Hello, world";
 93 |     const delta = { ops: [{ insert: text }] };
 94 |     cy.renderWithProps({
 95 |       defaultValue: delta
 96 |     });
 97 |     cy.getEditor().should("contain", text);
 98 |   });
 99 | 
100 |   it("cannot type in read-only editor", function() {
101 |     cy.renderWithProps({ readOnly: true });
102 |     cy.getEditor().should("have.attr", "contenteditable", "false");
103 |   });
104 | 
105 |   it("preserves content when switching to read-only mode", function() {
106 |     cy.renderWithProps({});
107 |     cy.getEditor().as("editor");
108 |     cy.get("@editor")
109 |       .type("some text")
110 |       .should("contain", "some text");
111 |     cy.setProps({ readOnly: true });
112 |     cy.get("@editor").should("contain", "some text");
113 |   });
114 | 
115 |   it("calls onChange after typing", () => {
116 |     const props = {
117 |       onChange: (_, delta) => {},
118 |       value: "<p>Hello, world</p>"
119 |     };
120 |     cy.spy(props, "onChange");
121 |     cy.renderWithProps(props);
122 |     cy.getEditor()
123 |       .type("!!!")
124 |       .then(() => {
125 |         expect(props.onChange).to.be.called;
126 |       });
127 |   });
128 | 
129 |   it("can imperatively focus and blur using ref .blur() and .focus()", () => {
130 |     cy.renderWithProps();
131 |     cy.getEditor()
132 |       .type("hello")
133 |       .then(editor => {
134 |         cy.getEditorRef().then(reactquill => {
135 |           reactquill.blur();
136 |           expect(editor).to.not.be.focused;
137 |           reactquill.focus();
138 |           expect(editor).to.be.focused;
139 |         });
140 |       });
141 |   });
142 | 
143 |   it("can access underlying Quill instance using ref .getEditor()", () => {
144 |     cy.renderWithProps();
145 |     cy.getEditorRef().then(reactquill => {
146 |       expect(reactquill.getEditor()).to.be.instanceOf(Quill);
147 |     });
148 |   });
149 | 
150 |   it("passes options to Quill from props", () => {
151 |     const enabledFormats = ["underline", "bold", "italic"];
152 |     const props = {
153 |       placeholder: "foobar",
154 |       readOnly: true,
155 |       formats: enabledFormats,
156 |       modules: {
157 |         toolbar: enabledFormats
158 |       }
159 |     };
160 |     cy.renderWithProps(props);
161 |     cy.getEditorRef().then(reactquill => {
162 |       const quill = reactquill.getEditor();
163 |       expect(quill.options.placeholder).to.equal(props.placeholder);
164 |       expect(quill.options.readOnly).to.equal(props.readOnly);
165 |       expect(quill.options.modules).to.include.keys(Object.keys(props.modules));
166 |       expect(quill.options.formats).to.include.members(props.formats);
167 |     });
168 |   });
169 | 
170 |   it("prevents using Delta changesets from events as value", () => {
171 |     const value = "<p>Hello, world</p>";
172 |     const changedValue = "Adieu, world!";
173 |     let lastDelta;
174 |     const onChange = (_, delta) => {
175 |       lastDelta = delta;
176 |     };
177 |     cy.renderWithProps({ value, onChange });
178 |     cy.getEditor()
179 |       .type("?")
180 |       .window(w => {
181 |         expect(() => w.setProps({ value: lastDelta })).to.throw(
182 |           "You are passing the `delta` object from the `onChange` event back"
183 |         );
184 |       });
185 |   });
186 | });
187 | 
188 | describe("old test suite", () => {
189 |   // Instead of running the old test inside JSDOM, run
190 |   // the tests inside the browser environment.
191 |   // This works because we are using Chai and Mocha,
192 |   // just like Cypress.
193 | 
194 |   const Enzyme = require("enzyme");
195 |   const EnzymeAdapter = require("enzyme-adapter-react-16");
196 |   Enzyme.configure({ adapter: new EnzymeAdapter() });
197 | 
198 |   require("./index.js");
199 | });
200 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | ## v2.0.0
  4 | 
  5 | - Fully ported to TypeScript (#549)
  6 | - Fully React16 compliant (#549)
  7 | - Removed Mixin (#549)
  8 | - Removed Toolbar (#549)
  9 | - Support for React 18 (#793, #822)
 10 | 
 11 | ## v1.3.4
 12 | 
 13 | - Bump Quill to 1.3.7 to close a security vulnerability (#575)
 14 | 
 15 | ## v1.3.3
 16 | 
 17 | - Pin Quill types version (#420 @daggmano)
 18 | 
 19 | ## v1.3.2
 20 | 
 21 | - Add preserveWhitespace prop (#407 @royshouvik)
 22 | 
 23 | ## v1.3.1
 24 | 
 25 | - Add back default export (#374, #384 one19)
 26 | 
 27 | ## v1.3.0
 28 | 
 29 | - Add scrollingContainer prop
 30 | - Fix Typescript exports
 31 | - Fix tabindex prop
 32 | 
 33 | ## v1.2.6
 34 | 
 35 | Replaced React.DOM with react-dom-factories (#319 thienanle)
 36 | 
 37 | ## v1.2.5
 38 | 
 39 | - Fix issue with unnecessary editor focus on mount (#321 jetzhou)
 40 | - Switch to Quill's clipboard.convert from the paste API that now grabs focus automatically
 41 | 
 42 | ## v1.2.4
 43 | 
 44 | - Only restore focus if editor had focus (#312 @MattKunze)
 45 | 
 46 | ## v1.2.2
 47 | 
 48 | - Add Typescript definitions (#277 @Charrondev)
 49 | - Fixes for TS definitions (#294 @jdhungtington, #296 @ajaska)
 50 | 
 51 | ## v1.1.0
 52 | 
 53 | - Add support for React 16 and onwards by depending on `prop-types` and `create-react-class` (#181 @mikecousins)
 54 | - Allow setting contents with a Quill Delta via the `value` prop (#101)
 55 | - Add onFocus/onBlur props (#110)
 56 | - Add tabindex support (#232)
 57 | 
 58 | ## v1.0.0
 59 | 
 60 | This release supports Quill v1.0.0+. ⚠️ There are many breaking changes, so refer to the documentation for information on how to migrate your application.
 61 | 
 62 | - Updated to support Quill v1.0.0+ (@clemmy, @alexkrolick)
 63 | - Bundling Quill with ReactQuill (@clemmy)
 64 | - Deprecated `toolbar` property and component
 65 | - Deprecated the `styles` property
 66 | - Deprecated custom formats via the `formats` property
 67 | - Deprecated the `pollInterval` property
 68 | - Rerendering on `style` property change (@lavrton)
 69 | - Improved docs for `bounds`, which now rerenders on change
 70 | - Performing deep props comparison to avoid rerenders
 71 | - Fixed the unprivileged editor not returning values
 72 | - Restoring selection event after text change
 73 | - Fixed the order of parameters in change events (@webcarrot)
 74 | - Using 'core' instead of 'base' CSS (@alexkrolick)
 75 | - Added support for the `placeholder` property (@alexkrolick)
 76 | - Enable/disable editor using top-level Quill API (@alexkrolick)
 77 | - Prevent whitespace issues when initializing the editor (@bobrafie)
 78 | - Using buttons instead of spans for toolbar actions (@clemmy)
 79 | - Removed getHtml from unprivileged editor (@clemmy)
 80 | - Fixed calculations for range fields (@clemmy)
 81 | - Removed deprecated destroy functionality (@clemmy)
 82 | - Added return statement to proxy editor methods (@druti)
 83 | - Inline styles support for Quill Toolbar (@e-jigsaw)
 84 | - Fixed custom font size definitions (@clemmy)
 85 | - Support for bullet and ordered lists in toolbar (@clemmy)
 86 | - Updated the toolbar alignment section (@clemmy)
 87 | - Updated rendering of toolbar actions (@clemmy)
 88 | - Improved toolbar renderChoices implementation (@zhang-z)
 89 | - Fixed use of `defaultValue` in Toolbar selects
 90 | - Fixed bounds validation in setEditorSelection (@wouterh)
 91 | - Exposed Quill in exports (@tdg5)
 92 | - Added unhook function to clean up event listeners on unmount (@alexkrolick, @jrmmnr)
 93 | - Fixed documentation typos (@l3kn)
 94 | - Started testing with Enzyme (@alexkrolick)
 95 | - Fixed issue where changing props caused re-render artifacts (#147)
 96 | - Fixed bounds validation in setEditorSelection (@wouterh)
 97 | - Updated README.md to reference core.css instead of base.css (@sandbochs)
 98 | - Updated React peerDependency (@rpellerin)
 99 | - Removed inline Parchment formats for font-size and font-family (#217)
100 | 
101 | ## v0.4.1
102 | 
103 | - Added contents of `dist` to NPM package.
104 | 
105 | ## v0.4.0
106 | 
107 | This release finally adds support for React 0.14. ⚠️ Shims to support older versions of React have been removed.
108 | 
109 | - React 0.14 support (@jacktrades, #49)
110 | - Removed shims for React 0.12 and 0.13
111 | - Bumped Quill.js to v0.20.1
112 | - _Normal_ and _smaller_ sizes are not swapped anymore. (#63)
113 | - Various toolbar choice items are now correctly ordered.
114 | - Added image tooltips to the default set of modules (@kairxa, #54)
115 | - Fixed extra white-space in classnames (@asiniy, #67)
116 | - Published the Quill namespace on ReactQuill (@Sajam, #60)
117 | - Quill stylesheets are now linked to `dist/` for convenience. (#70)
118 | - Exposed editor accessor methods in change events. (#33)
119 | 
120 | ## v0.3.0
121 | 
122 | - Bumped Quill.js to v0.2.0
123 | - Exposed `focus` and `blur` public methods from component.
124 | - Exposed `getEditor` public method to retrieve the backing Quill instance from the component.
125 | - Added callbacks for listening to keyboard events.
126 | - Added tooltips for toolbar choice controls (@bird512).
127 | - Added support for child nodes in toolbar items (@1000hz).
128 | - Added support for custom formats in the configuration (@csk157).
129 | - Added an option to disable the toolbar entirely by passing `false` to `toolbar`.
130 | - Added an option to disable styles entirely by passing `false` to `style` (@kkerr1).
131 | - Fixed an issue where the Quill would duplicate React IDs inside the toolbar leading to errors. Fixes #15.
132 | - Fixes an issue where the editor could be used while null (@brucedlukens).
133 | - Fixes an issue where null would be set on the editor. Fixes #48.
134 | - Fixes an issue where the editor would be instantiated with the wrong value. Fixes #50.
135 | - Avoiding parsing Quill's `dist` directory with webpack.
136 | 
137 | ## v0.2.2
138 | 
139 | - Added missing `modules` propType and documentation.
140 | - Children are now cloned so ReactQuill can own their refs. Fixes #20.
141 | 
142 | ## v0.2.1
143 | 
144 | - Link toolbar button and module are now enabled by default. Fixes #19.
145 | 
146 | ## v0.2.0
147 | 
148 | - Fix React warnings about unique `key` props in toolbar (@Janekk).
149 | - Sending `delta` and `source` from editor change events. Fixes #17.
150 | - Rewritten uncontrolled and semi-controlled operation. Should fix #9, #10 and #14.
151 | - Editor props can now be changed after mounting.
152 | - Added callback for selection change event. Closes #12.
153 | 
154 | ## v0.1.1
155 | 
156 | - The pre-compiled distributable is not shipped with the NPM package anymore. Should fix #2.
157 | - Sourcemaps are now emitted for both distributables, as separate files.
158 | - Avoiding parsing Quill as it ships with a pre-built main.
159 | 
160 | ## v0.1.0
161 | 
162 | - Added support for toolbar separators.
163 | - Added support for font family selectors.
164 | - Updated the default toolbar to match Quill's.
165 | - Updated Quill to v0.19.12.
166 | 
167 | ## v0.0.6
168 | 
169 | - Added keywords for inclusion in [React.parts](https://react.parts).
170 | 
171 | ## v0.0.5
172 | 
173 | - Default empty content for components with no value.
174 | - Fixes wrong `QuillToolbar` propType.
175 | 
176 | ## v0.0.4
177 | 
178 | - Added color toggle to toolbar (@chrismcv)
179 | - Exporting default item sets on `QuillToolbar`
180 | - Fixed `QuillComponent` only accepting a single child.
181 | 
182 | ## v0.0.3
183 | 
184 | - Switched from `quilljs` package to `quill`.
185 | - Using the new `destroy()` from Quill.
186 | 
187 | ## v0.0.2
188 | 
189 | - Compatible with React 0.12.
190 | 
191 | ## v0.0.1
192 | 
193 | - Initial version.
194 | 


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Test suite uses mocha and enzyme to mock browser APIs
  3 |  *
  4 |  * See Enzyme docs:
  5 |  * https://github.com/airbnb/enzyme/blob/master/docs/guides/jsdom.md
  6 |  * https://github.com/airbnb/enzyme/blob/master/docs/api/mount.md
  7 |  */
  8 | 
  9 | const React = require('react');
 10 | const sinon = require('sinon');
 11 | const ReactQuill = require('../lib/index');
 12 | const { Quill } = require('../lib/index');
 13 | 
 14 | const {
 15 |   mountReactQuill,
 16 |   getQuillInstance,
 17 |   getQuillContentsAsHTML,
 18 |   setQuillContentsFromHTML,
 19 |   withMockedConsole,
 20 | } = require('./utils');
 21 | 
 22 | console.log(
 23 |   '\n\
 24 |   Note that some functionality cannot be tested outside of a full browser environment.\n\n\
 25 |   To manually test the component:\n\
 26 |     1) Run "npm install" & "npm run build"\n\
 27 |     2) Open "demo/index.html" in a web browser.\
 28 | '
 29 | );
 30 | 
 31 | describe('<ReactQuill />', function() {
 32 |   it('calls componentDidMount', () => {
 33 |     sinon.spy(ReactQuill.prototype, 'componentDidMount');
 34 |     const wrapper = mountReactQuill();
 35 |     // @ts-ignore method injected by sinon spy
 36 |     expect(ReactQuill.prototype.componentDidMount.calledOnce).to.equal(true);
 37 |   });
 38 | 
 39 |   it('allows props to be set', () => {
 40 |     const props = { readOnly: true };
 41 |     const wrapper = mountReactQuill(props);
 42 |     expect(wrapper.props().readOnly).to.equal(true);
 43 |     wrapper.setProps({ readOnly: false });
 44 |     expect(wrapper.props().readOnly).to.equal(false);
 45 |   });
 46 | 
 47 |   it('attaches a Quill instance to the component', () => {
 48 |     const wrapper = mountReactQuill();
 49 |     const quill = getQuillInstance(wrapper);
 50 |     expect(quill instanceof Quill).to.equal(true);
 51 |   });
 52 | 
 53 |   it('passes options to Quill from props', () => {
 54 |     const enabledFormats = ['underline', 'bold', 'italic'];
 55 |     const props = {
 56 |       placeholder: 'foobar',
 57 |       readOnly: true,
 58 |       formats: enabledFormats,
 59 |       modules: {
 60 |         toolbar: enabledFormats,
 61 |       },
 62 |     };
 63 |     const wrapper = mountReactQuill(props);
 64 |     const quill = getQuillInstance(wrapper);
 65 |     expect(quill.options.placeholder).to.equal(props.placeholder);
 66 |     expect(quill.options.readOnly).to.equal(props.readOnly);
 67 |     expect(quill.options.modules).to.include.keys(Object.keys(props.modules));
 68 |     expect(quill.options.formats).to.include.members(props.formats);
 69 |   });
 70 | 
 71 |   it('allows using HTML strings as value', () => {
 72 |     const html = '<p>Hello, world!</p>';
 73 |     const wrapper = mountReactQuill({ value: html });
 74 |     const quill = getQuillInstance(wrapper);
 75 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(html);
 76 |   });
 77 | 
 78 |   it('allows using HTML strings as defaultValue', () => {
 79 |     const html = '<p>Hello, world!</p>';
 80 |     const wrapper = mountReactQuill({ defaultValue: html });
 81 |     const quill = getQuillInstance(wrapper);
 82 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(html);
 83 |   });
 84 | 
 85 |   it('allows using Deltas as value', () => {
 86 |     const html = '<p>Hello, world!</p>';
 87 |     const delta = { ops: [{ insert: 'Hello, world!' }] };
 88 |     const wrapper = mountReactQuill({ value: delta });
 89 |     const quill = getQuillInstance(wrapper);
 90 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(html);
 91 |   });
 92 | 
 93 |   it('prevents using Delta changesets from events as value', done => {
 94 |     const value = '<p>Hello, world!</p>';
 95 |     const changedValue = '<p>Adieu, world!</p>';
 96 |     let calledDone = false;
 97 |     let wrapper;
 98 | 
 99 |     const onChange = (value, delta) => {
100 |       // Setting props unconditionally here will cause a change loop
101 |       if (!calledDone) wrapper.setProps({ value: delta });
102 |     };
103 |     wrapper = mountReactQuill({ value, onChange });
104 | 
105 |     const expectedErr = /You are passing the `delta` object from the `onChange` event back/;
106 |     // this test knows a lot about the implementation,
107 |     // but we need to wrap the right function with a catch
108 |     // in order to prevent errors from it from propagating
109 |     const originalValidateProps = wrapper.instance().validateProps;
110 | 
111 |     wrapper.instance().validateProps = function(props) {
112 |       try {
113 |         originalValidateProps.call(wrapper.instance(), props);
114 |       } catch (err) {
115 |         if (!calledDone && expectedErr.test(err)) {
116 |           calledDone = true;
117 |           done();
118 |         }
119 |       }
120 |     }.bind(wrapper.instance());
121 | 
122 |     setQuillContentsFromHTML(wrapper, changedValue);
123 |   });
124 | 
125 |   it('allows using Deltas as defaultValue', () => {
126 |     const html = '<p>Hello, world!</p>';
127 |     const delta = { ops: [{ insert: 'Hello, world!' }] };
128 |     const wrapper = mountReactQuill({ defaultValue: html });
129 |     const quill = getQuillInstance(wrapper);
130 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(html);
131 |   });
132 | 
133 |   it('calls onChange with the new value when Quill calls pasteHTML', () => {
134 |     const onChangeSpy = sinon.spy();
135 |     const inHtml = '<p>Hello, world!</p>';
136 |     const onChange = value => {
137 |       expect(inHtml).to.equal(value);
138 |       onChangeSpy();
139 |     };
140 |     const wrapper = mountReactQuill({ onChange });
141 |     setQuillContentsFromHTML(wrapper, inHtml);
142 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(inHtml);
143 |     expect(onChangeSpy).to.have.property('callCount', 1);
144 |   });
145 | 
146 |   it('calls onChange with the new value when Quill calls insertText', () => {
147 |     const onChangeSpy = sinon.spy();
148 |     const inHtml = '<p><strong>Hello, World!</strong></p>';
149 |     const onChange = value => {
150 |       expect(inHtml).to.equal(value);
151 |       onChangeSpy();
152 |     };
153 |     const wrapper = mountReactQuill({ onChange });
154 |     const quill = getQuillInstance(wrapper);
155 |     quill.insertText(0, 'Hello, World!', 'bold', true);
156 |     expect(getQuillContentsAsHTML(wrapper)).to.equal(inHtml);
157 |     expect(onChangeSpy).to.have.property('callCount', 1);
158 |   });
159 | 
160 |   it('shows defaultValue if value prop is undefined', () => {
161 |     const defaultValue = '<p>Hello, world!</p>';
162 |     const wrapper = mountReactQuill({ defaultValue });
163 |     const quill = getQuillInstance(wrapper);
164 |     // @ts-ignore untyped instance
165 |     expect(wrapper.instance().getEditorContents()).to.equal(defaultValue);
166 |   });
167 | 
168 |   it('shows the value prop instead of defaultValue if both are defined', () => {
169 |     const defaultValue = '<p>Hello, world!</p>';
170 |     const value = '<p>Good night, moon!</p>';
171 |     const wrapper = mountReactQuill({
172 |       defaultValue: defaultValue,
173 |       value: value,
174 |     });
175 |     const quill = getQuillInstance(wrapper);
176 |     // @ts-ignore untyped instance
177 |     expect(wrapper.instance().getEditorContents()).to.equal(value);
178 |   });
179 | 
180 |   it('uses a custom editing area if provided', () => {
181 |     const div = React.createFactory('div');
182 |     const editingArea = div({ id: 'venus' });
183 |     const wrapper = mountReactQuill({}, editingArea);
184 |     const quill = getQuillInstance(wrapper);
185 |     expect(wrapper.getDOMNode().querySelector('div#venus')).not.to.be.null;
186 |   });
187 | 
188 |   /**
189 |    * This can't be tested with the current state of JSDOM.
190 |    * The selection functions have been shimmed in this test suite,
191 |    * but they  will not work until DOM traversal is implemented in
192 |    * https://github.com/tmpvar/jsdom/issues/317.
193 |    * Leaving this pending test as a reminder to follow up.
194 |    */
195 |   it('focuses editor when calling focus()');
196 | 
197 |   /**
198 |    * A test for this may work if checking document.activeElement,
199 |    * but chances are the focus was never removed from the body
200 |    * after calling focus(). See JSDOM issue #317.
201 |    */
202 |   it('removes focus from the editor when calling blur()');
203 | 
204 |   /**
205 |    * In a browser, querySelector('.ql-editor').textContent = 'hi' would
206 |    * trigger a 'text-change' event, but here it doesn't. Is the polyfill
207 |    * for MutationObserver not working?
208 |    */
209 |   it('calls onChange after the textContent of the editor changes');
210 | 
211 |   /**
212 |    * This is hard to do without Selenium's 'type' function, but it is the
213 |    * ultimate test of whether everything is working or not
214 |    */
215 |   it('calls onChange after keypresses are sent to the editor');
216 | });
217 | 


--------------------------------------------------------------------------------
/test/polyfills/MutationObserver.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @license
  3 |  * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
  4 |  * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
  5 |  * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
  6 |  * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
  7 |  * Code distributed by Google as part of the polymer project is also
  8 |  * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
  9 |  */
 10 | // @version 0.7.24
 11 | if (typeof WeakMap === "undefined") {
 12 |   (function() {
 13 |     var defineProperty = Object.defineProperty;
 14 |     var counter = Date.now() % 1e9;
 15 |     var WeakMap = function() {
 16 |       this.name = "__st" + (Math.random() * 1e9 >>> 0) + (counter++ + "__");
 17 |     };
 18 |     WeakMap.prototype = {
 19 |       set: function(key, value) {
 20 |         var entry = key[this.name];
 21 |         if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {
 22 |           value: [ key, value ],
 23 |           writable: true
 24 |         });
 25 |         return this;
 26 |       },
 27 |       get: function(key) {
 28 |         var entry;
 29 |         return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined;
 30 |       },
 31 |       "delete": function(key) {
 32 |         var entry = key[this.name];
 33 |         if (!entry || entry[0] !== key) return false;
 34 |         entry[0] = entry[1] = undefined;
 35 |         return true;
 36 |       },
 37 |       has: function(key) {
 38 |         var entry = key[this.name];
 39 |         if (!entry) return false;
 40 |         return entry[0] === key;
 41 |       }
 42 |     };
 43 |     window.WeakMap = WeakMap;
 44 |   })();
 45 | }
 46 | 
 47 | module.exports = function(global) {
 48 |   if (global.JsMutationObserver) {
 49 |     return;
 50 |   }
 51 |   var registrationsTable = new WeakMap();
 52 |   var setImmediate;
 53 |   if (/Trident|Edge/.test(navigator.userAgent)) {
 54 |     setImmediate = setTimeout;
 55 |   } else if (window.setImmediate) {
 56 |     setImmediate = window.setImmediate;
 57 |   } else {
 58 |     var setImmediateQueue = [];
 59 |     var sentinel = String(Math.random());
 60 |     window.addEventListener("message", function(e) {
 61 |       if (e.data === sentinel) {
 62 |         var queue = setImmediateQueue;
 63 |         setImmediateQueue = [];
 64 |         queue.forEach(function(func) {
 65 |           func();
 66 |         });
 67 |       }
 68 |     });
 69 |     setImmediate = function(func) {
 70 |       setImmediateQueue.push(func);
 71 |       window.postMessage(sentinel, "*");
 72 |     };
 73 |   }
 74 |   var isScheduled = false;
 75 |   var scheduledObservers = [];
 76 |   function scheduleCallback(observer) {
 77 |     scheduledObservers.push(observer);
 78 |     if (!isScheduled) {
 79 |       isScheduled = true;
 80 |       setImmediate(dispatchCallbacks);
 81 |     }
 82 |   }
 83 |   function wrapIfNeeded(node) {
 84 |     return window.ShadowDOMPolyfill && window.ShadowDOMPolyfill.wrapIfNeeded(node) || node;
 85 |   }
 86 |   function dispatchCallbacks() {
 87 |     isScheduled = false;
 88 |     var observers = scheduledObservers;
 89 |     scheduledObservers = [];
 90 |     observers.sort(function(o1, o2) {
 91 |       return o1.uid_ - o2.uid_;
 92 |     });
 93 |     var anyNonEmpty = false;
 94 |     observers.forEach(function(observer) {
 95 |       var queue = observer.takeRecords();
 96 |       removeTransientObserversFor(observer);
 97 |       if (queue.length) {
 98 |         observer.callback_(queue, observer);
 99 |         anyNonEmpty = true;
100 |       }
101 |     });
102 |     if (anyNonEmpty) dispatchCallbacks();
103 |   }
104 |   function removeTransientObserversFor(observer) {
105 |     observer.nodes_.forEach(function(node) {
106 |       var registrations = registrationsTable.get(node);
107 |       if (!registrations) return;
108 |       registrations.forEach(function(registration) {
109 |         if (registration.observer === observer) registration.removeTransientObservers();
110 |       });
111 |     });
112 |   }
113 |   function forEachAncestorAndObserverEnqueueRecord(target, callback) {
114 |     for (var node = target; node; node = node.parentNode) {
115 |       var registrations = registrationsTable.get(node);
116 |       if (registrations) {
117 |         for (var j = 0; j < registrations.length; j++) {
118 |           var registration = registrations[j];
119 |           var options = registration.options;
120 |           if (node !== target && !options.subtree) continue;
121 |           var record = callback(options);
122 |           if (record) registration.enqueue(record);
123 |         }
124 |       }
125 |     }
126 |   }
127 |   var uidCounter = 0;
128 |   function JsMutationObserver(callback) {
129 |     this.callback_ = callback;
130 |     this.nodes_ = [];
131 |     this.records_ = [];
132 |     this.uid_ = ++uidCounter;
133 |   }
134 |   JsMutationObserver.prototype = {
135 |     observe: function(target, options) {
136 |       target = wrapIfNeeded(target);
137 |       if (!options.childList && !options.attributes && !options.characterData || options.attributeOldValue && !options.attributes || options.attributeFilter && options.attributeFilter.length && !options.attributes || options.characterDataOldValue && !options.characterData) {
138 |         throw new SyntaxError();
139 |       }
140 |       var registrations = registrationsTable.get(target);
141 |       if (!registrations) registrationsTable.set(target, registrations = []);
142 |       var registration;
143 |       for (var i = 0; i < registrations.length; i++) {
144 |         if (registrations[i].observer === this) {
145 |           registration = registrations[i];
146 |           registration.removeListeners();
147 |           registration.options = options;
148 |           break;
149 |         }
150 |       }
151 |       if (!registration) {
152 |         registration = new Registration(this, target, options);
153 |         registrations.push(registration);
154 |         this.nodes_.push(target);
155 |       }
156 |       registration.addListeners();
157 |     },
158 |     disconnect: function() {
159 |       this.nodes_.forEach(function(node) {
160 |         var registrations = registrationsTable.get(node);
161 |         for (var i = 0; i < registrations.length; i++) {
162 |           var registration = registrations[i];
163 |           if (registration.observer === this) {
164 |             registration.removeListeners();
165 |             registrations.splice(i, 1);
166 |             break;
167 |           }
168 |         }
169 |       }, this);
170 |       this.records_ = [];
171 |     },
172 |     takeRecords: function() {
173 |       var copyOfRecords = this.records_;
174 |       this.records_ = [];
175 |       return copyOfRecords;
176 |     }
177 |   };
178 |   function MutationRecord(type, target) {
179 |     this.type = type;
180 |     this.target = target;
181 |     this.addedNodes = [];
182 |     this.removedNodes = [];
183 |     this.previousSibling = null;
184 |     this.nextSibling = null;
185 |     this.attributeName = null;
186 |     this.attributeNamespace = null;
187 |     this.oldValue = null;
188 |   }
189 |   function copyMutationRecord(original) {
190 |     var record = new MutationRecord(original.type, original.target);
191 |     record.addedNodes = original.addedNodes.slice();
192 |     record.removedNodes = original.removedNodes.slice();
193 |     record.previousSibling = original.previousSibling;
194 |     record.nextSibling = original.nextSibling;
195 |     record.attributeName = original.attributeName;
196 |     record.attributeNamespace = original.attributeNamespace;
197 |     record.oldValue = original.oldValue;
198 |     return record;
199 |   }
200 |   var currentRecord, recordWithOldValue;
201 |   function getRecord(type, target) {
202 |     return currentRecord = new MutationRecord(type, target);
203 |   }
204 |   function getRecordWithOldValue(oldValue) {
205 |     if (recordWithOldValue) return recordWithOldValue;
206 |     recordWithOldValue = copyMutationRecord(currentRecord);
207 |     recordWithOldValue.oldValue = oldValue;
208 |     return recordWithOldValue;
209 |   }
210 |   function clearRecords() {
211 |     currentRecord = recordWithOldValue = undefined;
212 |   }
213 |   function recordRepresentsCurrentMutation(record) {
214 |     return record === recordWithOldValue || record === currentRecord;
215 |   }
216 |   function selectRecord(lastRecord, newRecord) {
217 |     if (lastRecord === newRecord) return lastRecord;
218 |     if (recordWithOldValue && recordRepresentsCurrentMutation(lastRecord)) return recordWithOldValue;
219 |     return null;
220 |   }
221 |   function Registration(observer, target, options) {
222 |     this.observer = observer;
223 |     this.target = target;
224 |     this.options = options;
225 |     this.transientObservedNodes = [];
226 |   }
227 |   Registration.prototype = {
228 |     enqueue: function(record) {
229 |       var records = this.observer.records_;
230 |       var length = records.length;
231 |       if (records.length > 0) {
232 |         var lastRecord = records[length - 1];
233 |         var recordToReplaceLast = selectRecord(lastRecord, record);
234 |         if (recordToReplaceLast) {
235 |           records[length - 1] = recordToReplaceLast;
236 |           return;
237 |         }
238 |       } else {
239 |         scheduleCallback(this.observer);
240 |       }
241 |       records[length] = record;
242 |     },
243 |     addListeners: function() {
244 |       this.addListeners_(this.target);
245 |     },
246 |     addListeners_: function(node) {
247 |       var options = this.options;
248 |       if (options.attributes) node.addEventListener("DOMAttrModified", this, true);
249 |       if (options.characterData) node.addEventListener("DOMCharacterDataModified", this, true);
250 |       if (options.childList) node.addEventListener("DOMNodeInserted", this, true);
251 |       if (options.childList || options.subtree) node.addEventListener("DOMNodeRemoved", this, true);
252 |     },
253 |     removeListeners: function() {
254 |       this.removeListeners_(this.target);
255 |     },
256 |     removeListeners_: function(node) {
257 |       var options = this.options;
258 |       if (options.attributes) node.removeEventListener("DOMAttrModified", this, true);
259 |       if (options.characterData) node.removeEventListener("DOMCharacterDataModified", this, true);
260 |       if (options.childList) node.removeEventListener("DOMNodeInserted", this, true);
261 |       if (options.childList || options.subtree) node.removeEventListener("DOMNodeRemoved", this, true);
262 |     },
263 |     addTransientObserver: function(node) {
264 |       if (node === this.target) return;
265 |       this.addListeners_(node);
266 |       this.transientObservedNodes.push(node);
267 |       var registrations = registrationsTable.get(node);
268 |       if (!registrations) registrationsTable.set(node, registrations = []);
269 |       registrations.push(this);
270 |     },
271 |     removeTransientObservers: function() {
272 |       var transientObservedNodes = this.transientObservedNodes;
273 |       this.transientObservedNodes = [];
274 |       transientObservedNodes.forEach(function(node) {
275 |         this.removeListeners_(node);
276 |         var registrations = registrationsTable.get(node);
277 |         for (var i = 0; i < registrations.length; i++) {
278 |           if (registrations[i] === this) {
279 |             registrations.splice(i, 1);
280 |             break;
281 |           }
282 |         }
283 |       }, this);
284 |     },
285 |     handleEvent: function(e) {
286 |       e.stopImmediatePropagation();
287 |       switch (e.type) {
288 |        case "DOMAttrModified":
289 |         var name = e.attrName;
290 |         var namespace = e.relatedNode.namespaceURI;
291 |         var target = e.target;
292 |         var record = new getRecord("attributes", target);
293 |         record.attributeName = name;
294 |         record.attributeNamespace = namespace;
295 |         var oldValue = e.attrChange === MutationEvent.ADDITION ? null : e.prevValue;
296 |         forEachAncestorAndObserverEnqueueRecord(target, function(options) {
297 |           if (!options.attributes) return;
298 |           if (options.attributeFilter && options.attributeFilter.length && options.attributeFilter.indexOf(name) === -1 && options.attributeFilter.indexOf(namespace) === -1) {
299 |             return;
300 |           }
301 |           if (options.attributeOldValue) return getRecordWithOldValue(oldValue);
302 |           return record;
303 |         });
304 |         break;
305 | 
306 |        case "DOMCharacterDataModified":
307 |         var target = e.target;
308 |         var record = getRecord("characterData", target);
309 |         var oldValue = e.prevValue;
310 |         forEachAncestorAndObserverEnqueueRecord(target, function(options) {
311 |           if (!options.characterData) return;
312 |           if (options.characterDataOldValue) return getRecordWithOldValue(oldValue);
313 |           return record;
314 |         });
315 |         break;
316 | 
317 |        case "DOMNodeRemoved":
318 |         this.addTransientObserver(e.target);
319 | 
320 |        case "DOMNodeInserted":
321 |         var changedNode = e.target;
322 |         var addedNodes, removedNodes;
323 |         if (e.type === "DOMNodeInserted") {
324 |           addedNodes = [ changedNode ];
325 |           removedNodes = [];
326 |         } else {
327 |           addedNodes = [];
328 |           removedNodes = [ changedNode ];
329 |         }
330 |         var previousSibling = changedNode.previousSibling;
331 |         var nextSibling = changedNode.nextSibling;
332 |         var record = getRecord("childList", e.target.parentNode);
333 |         record.addedNodes = addedNodes;
334 |         record.removedNodes = removedNodes;
335 |         record.previousSibling = previousSibling;
336 |         record.nextSibling = nextSibling;
337 |         forEachAncestorAndObserverEnqueueRecord(e.relatedNode, function(options) {
338 |           if (!options.childList) return;
339 |           return record;
340 |         });
341 |       }
342 |       clearRecords();
343 |     }
344 |   };
345 |   global.JsMutationObserver = JsMutationObserver;
346 |   if (!global.MutationObserver) {
347 |     global.MutationObserver = JsMutationObserver;
348 |     JsMutationObserver._isPolyfilled = true;
349 |   }
350 | }


--------------------------------------------------------------------------------
/src/index.tsx:
--------------------------------------------------------------------------------
  1 | /*
  2 | React-Quill
  3 | https://github.com/zenoamaro/react-quill
  4 | */
  5 | 
  6 | import React from 'react';
  7 | import ReactDOM from 'react-dom';
  8 | import isEqual from 'lodash/isEqual';
  9 | 
 10 | import Quill, {
 11 |   QuillOptionsStatic,
 12 |   DeltaStatic,
 13 |   RangeStatic,
 14 |   BoundsStatic,
 15 |   StringMap,
 16 |   Sources,
 17 | } from 'quill';
 18 | 
 19 | // Merged namespace hack to export types along with default object
 20 | // See: https://github.com/Microsoft/TypeScript/issues/2719
 21 | namespace ReactQuill {
 22 |   export type Value = string | DeltaStatic;
 23 |   export type Range = RangeStatic | null;
 24 | 
 25 |   export interface QuillOptions extends QuillOptionsStatic {
 26 |     tabIndex?: number,
 27 |   }
 28 | 
 29 |   export interface ReactQuillProps {
 30 |     bounds?: string | HTMLElement,
 31 |     children?: React.ReactElement<any>,
 32 |     className?: string,
 33 |     defaultValue?: Value,
 34 |     formats?: string[],
 35 |     id?: string,
 36 |     modules?: StringMap,
 37 |     onChange?(
 38 |       value: string,
 39 |       delta: DeltaStatic,
 40 |       source: Sources,
 41 |       editor: UnprivilegedEditor,
 42 |     ): void,
 43 |     onChangeSelection?(
 44 |       selection: Range,
 45 |       source: Sources,
 46 |       editor: UnprivilegedEditor,
 47 |     ): void,
 48 |     onFocus?(
 49 |       selection: Range,
 50 |       source: Sources,
 51 |       editor: UnprivilegedEditor,
 52 |     ): void,
 53 |     onBlur?(
 54 |       previousSelection: Range,
 55 |       source: Sources,
 56 |       editor: UnprivilegedEditor,
 57 |     ): void,
 58 |     onKeyDown?: React.EventHandler<any>,
 59 |     onKeyPress?: React.EventHandler<any>,
 60 |     onKeyUp?: React.EventHandler<any>,
 61 |     placeholder?: string,
 62 |     preserveWhitespace?: boolean,
 63 |     readOnly?: boolean,
 64 |     scrollingContainer?: string | HTMLElement,
 65 |     style?: React.CSSProperties,
 66 |     tabIndex?: number,
 67 |     theme?: string,
 68 |     value?: Value,
 69 |   }
 70 | 
 71 |   export interface UnprivilegedEditor {
 72 |     getLength(): number;
 73 |     getText(index?: number, length?: number): string;
 74 |     getHTML(): string;
 75 |     getBounds(index: number, length?: number): BoundsStatic;
 76 |     getSelection(focus?: boolean): RangeStatic;
 77 |     getContents(index?: number, length?: number): DeltaStatic;
 78 |   }
 79 | }
 80 | 
 81 | // Re-import everything from namespace into scope for comfort
 82 | import Value = ReactQuill.Value;
 83 | import Range = ReactQuill.Range;
 84 | import QuillOptions = ReactQuill.QuillOptions;
 85 | import ReactQuillProps = ReactQuill.ReactQuillProps;
 86 | import UnprivilegedEditor = ReactQuill.UnprivilegedEditor;
 87 | 
 88 | interface ReactQuillState {
 89 |   generation: number,
 90 | }
 91 | 
 92 | class ReactQuill extends React.Component<ReactQuillProps, ReactQuillState> {
 93 | 
 94 |   static displayName = 'React Quill'
 95 | 
 96 |   /*
 97 |   Export Quill to be able to call `register`
 98 |   */
 99 |   static Quill = Quill;
100 | 
101 |   /*
102 |   Changing one of these props should cause a full re-render and a
103 |   re-instantiation of the Quill editor.
104 |   */
105 |   dirtyProps: (keyof ReactQuillProps)[] = [
106 |     'modules',
107 |     'formats',
108 |     'bounds',
109 |     'theme',
110 |     'children',
111 |   ]
112 | 
113 |   /*
114 |   Changing one of these props should cause a regular update. These are mostly
115 |   props that act on the container, rather than the quillized editing area.
116 |   */
117 |   cleanProps: (keyof ReactQuillProps)[] = [
118 |     'id',
119 |     'className',
120 |     'style',
121 |     'placeholder',
122 |     'tabIndex',
123 |     'onChange',
124 |     'onChangeSelection',
125 |     'onFocus',
126 |     'onBlur',
127 |     'onKeyPress',
128 |     'onKeyDown',
129 |     'onKeyUp',
130 |   ]
131 | 
132 |   static defaultProps = {
133 |     theme: 'snow',
134 |     modules: {},
135 |     readOnly: false,
136 |   }
137 | 
138 |   state: ReactQuillState = {
139 |     generation: 0,
140 |   }
141 | 
142 |   /*
143 |   The Quill Editor instance.
144 |   */
145 |   editor?: Quill
146 | 
147 |   /*
148 |   Reference to the element holding the Quill editing area.
149 |   */
150 |   editingArea?: React.ReactInstance | null
151 | 
152 |   /*
153 |   Tracks the internal value of the Quill editor
154 |   */
155 |   value: Value
156 | 
157 |   /*
158 |   Tracks the internal selection of the Quill editor
159 |   */
160 |   selection: Range = null
161 | 
162 |   /*
163 |   Used to compare whether deltas from `onChange` are being used as `value`.
164 |   */
165 |   lastDeltaChangeSet?: DeltaStatic
166 | 
167 |   /*
168 |   Stores the contents of the editor to be restored after regeneration.
169 |   */
170 |   regenerationSnapshot?: {
171 |     delta: DeltaStatic,
172 |     selection: Range,
173 |   }
174 | 
175 |   /*
176 |   A weaker, unprivileged proxy for the editor that does not allow accidentally
177 |   modifying editor state.
178 |   */
179 |   unprivilegedEditor?: UnprivilegedEditor
180 | 
181 |   constructor(props: ReactQuillProps) {
182 |     super(props);
183 |     const value = this.isControlled()? props.value : props.defaultValue;
184 |     this.value = value ?? '';
185 |   }
186 | 
187 |   validateProps(props: ReactQuillProps): void {
188 |     if (React.Children.count(props.children) > 1) throw new Error(
189 |       'The Quill editing area can only be composed of a single React element.'
190 |     );
191 | 
192 |     if (React.Children.count(props.children)) {
193 |       const child = React.Children.only(props.children);
194 |       if (child?.type === 'textarea') throw new Error(
195 |         'Quill does not support editing on a <textarea>. Use a <div> instead.'
196 |       );
197 |     }
198 | 
199 |     if (
200 |       this.lastDeltaChangeSet &&
201 |       props.value === this.lastDeltaChangeSet
202 |     ) throw new Error(
203 |       'You are passing the `delta` object from the `onChange` event back ' +
204 |       'as `value`. You most probably want `editor.getContents()` instead. ' +
205 |       'See: https://github.com/zenoamaro/react-quill#using-deltas'
206 |     );
207 |   }
208 | 
209 |   shouldComponentUpdate(nextProps: ReactQuillProps, nextState: ReactQuillState) {
210 |     this.validateProps(nextProps);
211 | 
212 |     // If the editor hasn't been instantiated yet, or the component has been
213 |     // regenerated, we already know we should update.
214 |     if (!this.editor || this.state.generation !== nextState.generation) {
215 |       return true;
216 |     }
217 | 
218 |     // Handle value changes in-place
219 |     if ('value' in nextProps) {
220 |       const prevContents = this.getEditorContents();
221 |       const nextContents = nextProps.value ?? '';
222 | 
223 |       // NOTE: Seeing that Quill is missing a way to prevent edits, we have to
224 |       //       settle for a hybrid between controlled and uncontrolled mode. We
225 |       //       can't prevent the change, but we'll still override content
226 |       //       whenever `value` differs from current state.
227 |       // NOTE: Comparing an HTML string and a Quill Delta will always trigger a
228 |       //       change, regardless of whether they represent the same document.
229 |       if (!this.isEqualValue(nextContents, prevContents)) {
230 |         this.setEditorContents(this.editor, nextContents);
231 |       }
232 |     }
233 | 
234 |     // Handle read-only changes in-place
235 |     if (nextProps.readOnly !== this.props.readOnly) {
236 |       this.setEditorReadOnly(this.editor, nextProps.readOnly!);
237 |     }
238 | 
239 |     // Clean and Dirty props require a render
240 |     return [...this.cleanProps, ...this.dirtyProps].some((prop) => {
241 |       return !isEqual(nextProps[prop], this.props[prop]);
242 |     });
243 |   }
244 | 
245 |   shouldComponentRegenerate(nextProps: ReactQuillProps): boolean {
246 |     // Whenever a `dirtyProp` changes, the editor needs reinstantiation.
247 |     return this.dirtyProps.some((prop) => {
248 |       return !isEqual(nextProps[prop], this.props[prop]);
249 |     });
250 |   }
251 | 
252 |   componentDidMount() {
253 |     this.instantiateEditor();
254 |     this.setEditorContents(this.editor!, this.getEditorContents());
255 |   }
256 | 
257 |   componentWillUnmount() {
258 |     this.destroyEditor();
259 |   }
260 | 
261 |   componentDidUpdate(prevProps: ReactQuillProps, prevState: ReactQuillState) {
262 |     // If we're changing one of the `dirtyProps`, the entire Quill Editor needs
263 |     // to be re-instantiated. Regenerating the editor will cause the whole tree,
264 |     // including the container, to be cleaned up and re-rendered from scratch.
265 |     // Store the contents so they can be restored later.
266 |     if (this.editor && this.shouldComponentRegenerate(prevProps)) {
267 |       const delta = this.editor.getContents();
268 |       const selection = this.editor.getSelection();
269 |       this.regenerationSnapshot = {delta, selection};
270 |       this.setState({generation: this.state.generation + 1});
271 |       this.destroyEditor();
272 |     }
273 | 
274 |     // The component has been regenerated, so it must be re-instantiated, and
275 |     // its content must be restored to the previous values from the snapshot.
276 |     if (this.state.generation !== prevState.generation) {
277 |       const {delta, selection} = this.regenerationSnapshot!;
278 |       delete this.regenerationSnapshot;
279 |       this.instantiateEditor();
280 |       const editor = this.editor!;
281 |       editor.setContents(delta);
282 |       postpone(() => this.setEditorSelection(editor, selection));
283 |     }
284 |   }
285 | 
286 |   instantiateEditor(): void {
287 |     if (this.editor) {
288 |       this.hookEditor(this.editor);
289 |     } else {
290 |       this.editor = this.createEditor(
291 |         this.getEditingArea(),
292 |         this.getEditorConfig()
293 |       );
294 |     }
295 |   }
296 | 
297 |   destroyEditor(): void {
298 |     if (!this.editor) return;
299 |     this.unhookEditor(this.editor);
300 |   }
301 | 
302 |   /*
303 |   We consider the component to be controlled if `value` is being sent in props.
304 |   */
305 |   isControlled(): boolean {
306 |     return 'value' in this.props;
307 |   }
308 | 
309 |   getEditorConfig(): QuillOptions {
310 |     return {
311 |       bounds: this.props.bounds,
312 |       formats: this.props.formats,
313 |       modules: this.props.modules,
314 |       placeholder: this.props.placeholder,
315 |       readOnly: this.props.readOnly,
316 |       scrollingContainer: this.props.scrollingContainer,
317 |       tabIndex: this.props.tabIndex,
318 |       theme: this.props.theme,
319 |     };
320 |   }
321 | 
322 |   getEditor(): Quill {
323 |     if (!this.editor) throw new Error('Accessing non-instantiated editor');
324 |     return this.editor;
325 |   }
326 | 
327 |   /**
328 |   Creates an editor on the given element. The editor will be passed the
329 |   configuration, have its events bound,
330 |   */
331 |   createEditor(element: Element, config: QuillOptions) {
332 |     const editor = new Quill(element, config);
333 |     if (config.tabIndex != null) {
334 |       this.setEditorTabIndex(editor, config.tabIndex);
335 |     }
336 |     this.hookEditor(editor);
337 |     return editor;
338 |   }
339 | 
340 |   hookEditor(editor: Quill) {
341 |     // Expose the editor on change events via a weaker, unprivileged proxy
342 |     // object that does not allow accidentally modifying editor state.
343 |     this.unprivilegedEditor = this.makeUnprivilegedEditor(editor);
344 |     // Using `editor-change` allows picking up silent updates, like selection
345 |     // changes on typing.
346 |     editor.on('editor-change', this.onEditorChange);
347 |   }
348 | 
349 |   unhookEditor(editor: Quill) {
350 |     editor.off('editor-change', this.onEditorChange);
351 |   }
352 | 
353 |   getEditorContents(): Value {
354 |     return this.value;
355 |   }
356 | 
357 |   getEditorSelection(): Range {
358 |     return this.selection;
359 |   }
360 | 
361 |   /*
362 |   True if the value is a Delta instance or a Delta look-alike.
363 |   */
364 |   isDelta(value: any): boolean {
365 |     return value && value.ops;
366 |   }
367 | 
368 |   /*
369 |   Special comparison function that knows how to compare Deltas.
370 |   */
371 |   isEqualValue(value: any, nextValue: any): boolean {
372 |     if (this.isDelta(value) && this.isDelta(nextValue)) {
373 |       return isEqual(value.ops, nextValue.ops);
374 |     } else {
375 |       return isEqual(value, nextValue);
376 |     }
377 |   }
378 | 
379 |   /*
380 |   Replace the contents of the editor, but keep the previous selection hanging
381 |   around so that the cursor won't move.
382 |   */
383 |   setEditorContents(editor: Quill, value: Value) {
384 |     this.value = value;
385 |     const sel = this.getEditorSelection();
386 |     if (typeof value === 'string') {
387 |       editor.setContents(editor.clipboard.convert(value));
388 |     } else {
389 |       editor.setContents(value);
390 |     }
391 |     postpone(() => this.setEditorSelection(editor, sel));
392 |   }
393 | 
394 |   setEditorSelection(editor: Quill, range: Range) {
395 |     this.selection = range;
396 |     if (range) {
397 |       // Validate bounds before applying.
398 |       const length = editor.getLength();
399 |       range.index = Math.max(0, Math.min(range.index, length-1));
400 |       range.length = Math.max(0, Math.min(range.length, (length-1) - range.index));
401 |       editor.setSelection(range);
402 |     }
403 |   }
404 | 
405 |   setEditorTabIndex(editor: Quill, tabIndex: number) {
406 |     if (editor?.scroll?.domNode) {
407 |       (editor.scroll.domNode as HTMLElement).tabIndex = tabIndex;
408 |     }
409 |   }
410 | 
411 |   setEditorReadOnly(editor: Quill, value: boolean) {
412 |     if (value) {
413 |       editor.disable();
414 |     } else {
415 |       editor.enable();
416 |     }
417 |   }
418 | 
419 |   /*
420 |   Returns a weaker, unprivileged proxy object that only exposes read-only
421 |   accessors found on the editor instance, without any state-modifying methods.
422 |   */
423 |   makeUnprivilegedEditor(editor: Quill) {
424 |     const e = editor;
425 |     return {
426 |       getHTML:      () => e.root.innerHTML,
427 |       getLength:    e.getLength.bind(e),
428 |       getText:      e.getText.bind(e),
429 |       getContents:  e.getContents.bind(e),
430 |       getSelection: e.getSelection.bind(e),
431 |       getBounds:    e.getBounds.bind(e),
432 |     };
433 |   }
434 | 
435 |   getEditingArea(): Element {
436 |     if (!this.editingArea) {
437 |       throw new Error('Instantiating on missing editing area');
438 |     }
439 |     const element = ReactDOM.findDOMNode(this.editingArea);
440 |     if (!element) {
441 |       throw new Error('Cannot find element for editing area');
442 |     }
443 |     if (element.nodeType === 3) {
444 |       throw new Error('Editing area cannot be a text node');
445 |     }
446 |     return element as Element;
447 |   }
448 | 
449 |   /*
450 |   Renders an editor area, unless it has been provided one to clone.
451 |   */
452 |   renderEditingArea(): JSX.Element {
453 |     const {children, preserveWhitespace} = this.props;
454 |     const {generation} = this.state;
455 | 
456 |     const properties = {
457 |       key: generation,
458 |       ref: (instance: React.ReactInstance | null) => {
459 |         this.editingArea = instance
460 |       },
461 |     };
462 | 
463 |     if (React.Children.count(children)) {
464 |       return React.cloneElement(
465 |         React.Children.only(children)!,
466 |         properties
467 |       );
468 |     }
469 | 
470 |     return preserveWhitespace ?
471 |       <pre {...properties}/> :
472 |       <div {...properties}/>;
473 |   }
474 | 
475 |   render() {
476 |     return (
477 |       <div
478 |         id={this.props.id}
479 |         style={this.props.style}
480 |         key={this.state.generation}
481 |         className={`quill ${this.props.className ?? ''}`}
482 |         onKeyPress={this.props.onKeyPress}
483 |         onKeyDown={this.props.onKeyDown}
484 |         onKeyUp={this.props.onKeyUp}
485 |       >
486 |         {this.renderEditingArea()}
487 |       </div>
488 |     );
489 |   }
490 | 
491 |   onEditorChange = (
492 |     eventName: 'text-change' | 'selection-change',
493 |     rangeOrDelta: Range | DeltaStatic,
494 |     oldRangeOrDelta: Range | DeltaStatic,
495 |     source: Sources,
496 |   ) => {
497 |     if (eventName === 'text-change') {
498 |       this.onEditorChangeText?.(
499 |         this.editor!.root.innerHTML,
500 |         rangeOrDelta as DeltaStatic,
501 |         source,
502 |         this.unprivilegedEditor!
503 |       );
504 |     } else if (eventName === 'selection-change') {
505 |       this.onEditorChangeSelection?.(
506 |         rangeOrDelta as RangeStatic,
507 |         source,
508 |         this.unprivilegedEditor!
509 |       );
510 |     }
511 |   };
512 | 
513 |   onEditorChangeText(
514 |     value: string,
515 |     delta: DeltaStatic,
516 |     source: Sources,
517 |     editor: UnprivilegedEditor,
518 |   ): void {
519 |     if (!this.editor) return;
520 | 
521 |     // We keep storing the same type of value as what the user gives us,
522 |     // so that value comparisons will be more stable and predictable.
523 |     const nextContents = this.isDelta(this.value)
524 |       ? editor.getContents()
525 |       : editor.getHTML();
526 | 
527 |     if (nextContents !== this.getEditorContents()) {
528 |       // Taint this `delta` object, so we can recognize whether the user
529 |       // is trying to send it back as `value`, preventing a likely loop.
530 |       this.lastDeltaChangeSet = delta;
531 | 
532 |       this.value = nextContents;
533 |       this.props.onChange?.(value, delta, source, editor);
534 |     }
535 |   }
536 | 
537 |   onEditorChangeSelection(
538 |     nextSelection: RangeStatic,
539 |     source: Sources,
540 |     editor: UnprivilegedEditor,
541 |   ): void {
542 |     if (!this.editor) return;
543 |     const currentSelection = this.getEditorSelection();
544 |     const hasGainedFocus = !currentSelection && nextSelection;
545 |     const hasLostFocus = currentSelection && !nextSelection;
546 | 
547 |     if (isEqual(nextSelection, currentSelection)) return;
548 | 
549 |     this.selection = nextSelection;
550 |     this.props.onChangeSelection?.(nextSelection, source, editor);
551 | 
552 |     if (hasGainedFocus) {
553 |       this.props.onFocus?.(nextSelection, source, editor);
554 |     } else if (hasLostFocus) {
555 |       this.props.onBlur?.(currentSelection, source, editor);
556 |     }
557 |   }
558 | 
559 |   focus(): void {
560 |     if (!this.editor) return;
561 |     this.editor.focus();
562 |   }
563 | 
564 |   blur(): void {
565 |     if (!this.editor) return;
566 |     this.selection = null;
567 |     this.editor.blur();
568 |   }
569 | }
570 | 
571 | /*
572 | Small helper to execute a function in the next micro-tick.
573 | */
574 | function postpone(fn: (value: void) => void) {
575 |   Promise.resolve().then(fn);
576 | }
577 | 
578 | // Compatibility Export to avoid `require(...).default` on CommonJS.
579 | // See: https://github.com/Microsoft/TypeScript/issues/2719
580 | export = ReactQuill;
581 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ReactQuill [![Build Status](https://travis-ci.org/zenoamaro/react-quill.svg?branch=master)](https://travis-ci.org/zenoamaro/react-quill) [![npm](https://img.shields.io/npm/v/react-quill.svg)](https://www.npmjs.com/package/react-quill)
  2 | [![npm downloads](https://img.shields.io/npm/dt/react-quill.svg?maxAge=2592000)](http://www.npmtrends.com/react-quill)
  3 | ==============================================================================
  4 | 
  5 | A [Quill] component for [React].
  6 | 
  7 | See a [live demo] or [Codepen](http://codepen.io/alexkrolick/pen/xgyOXQ/left?editors=0010#0).
  8 | 
  9 | [quill]: https://quilljs.com
 10 | [react]: https://facebook.github.io/react/
 11 | [live demo]: https://zenoamaro.github.io/react-quill/
 12 | 
 13 | - [Quick Start](#quick-start)
 14 |   - [With webpack or create-react-app](#with-webpack-or-create-react-app)
 15 |   - [With the browser bundle](#with-the-browser-bundle)
 16 | - [Usage](#usage)
 17 |   - [Controlled mode caveats](#controlled-mode-caveats)
 18 |   - [Using Deltas](#using-deltas)
 19 |   - [Themes](#themes)
 20 |   - [Custom Toolbar](#custom-toolbar)
 21 |     - [Default Toolbar Elements](#default-toolbar-elements)
 22 |     - [HTML Toolbar](#html-toolbar)
 23 |   - [Custom Formats](#custom-formats)
 24 |   - [Custom editing area](#custom-editing-area)
 25 | - [Upgrading to ReactQuill v2](#upgrading-to-reactquill-v2)
 26 |   - [Deprecated props](#deprecated-props)
 27 |   - [ReactQuill Mixin](#reactquill-mixin)
 28 |   - [Toolbar component](#toolbar-component)
 29 | - [API reference](#api-reference)
 30 |   - [Exports](#exports)
 31 |   - [Props](#props)
 32 |   - [Methods](#methods)
 33 |   - [The unprivileged editor](#the-unprivileged-editor)
 34 | - [Building and testing](#building-and-testing)
 35 | - [Browser support](#browser-support)
 36 | - [Changelog](#changelog)
 37 | - [Contributors](#contributors)
 38 | - [License](#license)
 39 | 
 40 | ---
 41 | 
 42 | This is the documentation for ReactQuill v2 — Previous releases: [v1](/../../tree/v1)
 43 | 
 44 | ---
 45 | 
 46 | 💯 **ReactQuill v2**
 47 | 
 48 | ReactQuill 2 is here, baby! And it brings a full port to TypeScript and React 16+, a refactored build system, and a general tightening of the internal logic.
 49 | 
 50 | We worked hard to avoid introducing any behavioral changes. For the vast majority of the cases, no migration is necessary at all. However, support for long-deprecated props, the ReactQuill Mixin, and the Toolbar component have been removed. Be sure to read the [migration guide](#upgrading-to-reactquill-v2).
 51 | 
 52 | We expect this release to be a drop-in upgrade – if that isn't the case, please [file an issue](/../../issues/new) with the `v2` label.
 53 | 
 54 | ---
 55 | 
 56 | ## Quick Start
 57 | 
 58 | ### With webpack or create-react-app
 59 | 
 60 | Make sure you have `react` and `react-dom`, and some way to load styles, like [style-loader](https://www.npmjs.com/package/style-loader). See the documentation on [themes](#themes) for more information.
 61 | 
 62 | ```sh
 63 | npm install react-quill --save
 64 | ```
 65 | 
 66 | ```jsx
 67 | import React, { useState } from 'react';
 68 | import ReactQuill from 'react-quill';
 69 | import 'react-quill/dist/quill.snow.css';
 70 | 
 71 | function MyComponent() {
 72 |   const [value, setValue] = useState('');
 73 | 
 74 |   return <ReactQuill theme="snow" value={value} onChange={setValue} />;
 75 | }
 76 | ```
 77 | 
 78 | ### With the browser bundle
 79 | 
 80 | ```html
 81 | <link
 82 |   rel="stylesheet"
 83 |   href="https://unpkg.com/react-quill@1.3.3/dist/quill.snow.css"
 84 | />
 85 | ```
 86 | 
 87 | ```html
 88 | <script
 89 |   src="https://unpkg.com/react@16/umd/react.development.js"
 90 |   crossorigin
 91 | ></script>
 92 | <script
 93 |   src="https://unpkg.com/react-dom@16/umd/react-dom.development.js"
 94 |   crossorigin
 95 | ></script>
 96 | <script src="https://unpkg.com/react-quill@1.3.3/dist/react-quill.js"></script>
 97 | <script src="https://unpkg.com/babel-standalone@6/babel.min.js"></script>
 98 | <script type="text/babel" src="/my-scripts.js"></script>
 99 | ```
100 | 
101 | ## Usage
102 | 
103 | ### Controlled mode caveats
104 | 
105 | In controlled mode, components are supposed to prevent local stateful changes, and instead only have them happen through `onChange` and `value`.
106 | 
107 | Because Quill handles its own changes, and does not allow preventing edits, ReactQuill has to settle for a hybrid between controlled and uncontrolled mode. It can't prevent the change, but will still override the content whenever `value` differs from current state.
108 | 
109 | If you frequently need to manipulate the DOM or use the [Quill API](https://quilljs.com/docs/api/)s imperatively, you might consider switching to fully uncontrolled mode. ReactQuill will initialize the editor using `defaultValue`, but won't try to reset it after that. The `onChange` callback will still work as expected.
110 | 
111 | Read more about uncontrolled components in the [React docs](https://facebook.github.io/react/docs/uncontrolled-components.html#default-values).
112 | 
113 | ### Using Deltas
114 | 
115 | You can pass a [Quill Delta](https://quilljs.com/docs/delta/), instead of an HTML string, as the `value` and `defaultValue` properties. Deltas have a number of advantages over HTML strings, so you might want use them instead. Be aware, however, that comparing Deltas for changes is more expensive than comparing HTML strings, so it might be worth to profile your usage patterns.
116 | 
117 | Note that switching `value` from an HTML string to a Delta, or vice-versa, will trigger a change, regardless of whether they represent the same document, so you might want to stick to a format and keep using it consistently throughout.
118 | 
119 | ⚠️ Do not use the `delta` object you receive from the `onChange` event as `value`. This object does not contain the full document, but only the last modifications, and doing so will most likely trigger an infinite loop where the same changes are applied over and over again. Use `editor.getContents()` during the event to obtain a Delta of the full document instead. ReactQuill will prevent you from making such a mistake, however if you are absolutely sure that this is what you want, you can pass the object through `new Delta()` again to un-taint it.
120 | 
121 | ### Themes
122 | 
123 | The Quill editor supports [themes](http://quilljs.com/docs/themes/). It includes a full-fledged theme, called _snow_, that is Quill's standard appearance, and a _bubble_ theme that is similar to the inline editor on Medium. At the very least, the _core_ theme must be included for modules like toolbars or tooltips to work.
124 | 
125 | To activate a theme, pass the name of the theme to the `theme` [prop](#props). Pass a falsy value (eg. `null`) to use the core theme.
126 | 
127 | ```jsx
128 | <ReactQuill theme="snow" .../>
129 | ```
130 | 
131 | Then, import the stylesheet for the themes you want to use.
132 | 
133 | This may vary depending how application is structured, directories or otherwise. For example, if you use a CSS pre-processor like SASS, you may want to import that stylesheet inside your own. These stylesheets can be found in the Quill distribution, but for convenience they are also linked in ReactQuill's `dist` folder.
134 | 
135 | Here's an example using [style-loader](https://www.npmjs.com/package/style-loader) for Webpack, or `create-react-app`, that will automatically inject the styles on the page:
136 | 
137 | ```jsx
138 | import 'react-quill/dist/quill.snow.css';
139 | ```
140 | 
141 | The styles are also available via CDN:
142 | 
143 | ```html
144 | <link
145 |   rel="stylesheet"
146 |   href="https://unpkg.com/react-quill@1.3.3/dist/quill.snow.css"
147 | />
148 | ```
149 | 
150 | ### Custom Toolbar
151 | 
152 | #### Default Toolbar Elements
153 | 
154 | The [Quill Toolbar Module](http://quilljs.com/docs/modules/toolbar/) API provides an easy way to configure the default toolbar icons using an array of format names.
155 | 
156 | <details>
157 | <summary>Example Code</summary>
158 | 
159 | ```jsx
160 | class MyComponent extends Component {
161 |   constructor(props) {
162 |     super(props);
163 |     this.state = {
164 |       text: "",
165 |     }
166 |   }
167 | 
168 |   modules = {
169 |     toolbar: [
170 |       [{ 'header': [1, 2, false] }],
171 |       ['bold', 'italic', 'underline','strike', 'blockquote'],
172 |       [{'list': 'ordered'}, {'list': 'bullet'}, {'indent': '-1'}, {'indent': '+1'}],
173 |       ['link', 'image'],
174 |       ['clean']
175 |     ],
176 |   },
177 | 
178 |   formats = [
179 |     'header',
180 |     'bold', 'italic', 'underline', 'strike', 'blockquote',
181 |     'list', 'bullet', 'indent',
182 |     'link', 'image'
183 |   ],
184 | 
185 |   render() {
186 |     return (
187 |       <div className="text-editor">
188 |         <ReactQuill theme="snow"
189 |                     modules={this.modules}
190 |                     formats={this.formats}>
191 |         </ReactQuill>
192 |       </div>
193 |     );
194 |   }
195 | }
196 | 
197 | export default MyComponent;
198 | ```
199 | 
200 | </details>
201 | 
202 | #### HTML Toolbar
203 | 
204 | You can also supply your own HTML/JSX toolbar with custom elements that are not part of the Quill theme.
205 | 
206 | See this example live on Codepen: [Custom Toolbar Example](https://codepen.io/alexkrolick/pen/gmroPj?editors=0010)
207 | 
208 | <details>
209 | <summary>Example Code</summary>
210 | 
211 | ```jsx
212 | /*
213 |  * Custom "star" icon for the toolbar using an Octicon
214 |  * https://octicons.github.io
215 |  */
216 | const CustomButton = () => <span className="octicon octicon-star" />;
217 | 
218 | /*
219 |  * Event handler to be attached using Quill toolbar module
220 |  * http://quilljs.com/docs/modules/toolbar/
221 |  */
222 | function insertStar() {
223 |   const cursorPosition = this.quill.getSelection().index;
224 |   this.quill.insertText(cursorPosition, '★');
225 |   this.quill.setSelection(cursorPosition + 1);
226 | }
227 | 
228 | /*
229 |  * Custom toolbar component including insertStar button and dropdowns
230 |  */
231 | const CustomToolbar = () => (
232 |   <div id="toolbar">
233 |     <select
234 |       className="ql-header"
235 |       defaultValue={''}
236 |       onChange={(e) => e.persist()}
237 |     >
238 |       <option value="1"></option>
239 |       <option value="2"></option>
240 |       <option selected></option>
241 |     </select>
242 |     <button className="ql-bold"></button>
243 |     <button className="ql-italic"></button>
244 |     <select className="ql-color">
245 |       <option value="red"></option>
246 |       <option value="green"></option>
247 |       <option value="blue"></option>
248 |       <option value="orange"></option>
249 |       <option value="violet"></option>
250 |       <option value="#d0d1d2"></option>
251 |       <option selected></option>
252 |     </select>
253 |     <button className="ql-insertStar">
254 |       <CustomButton />
255 |     </button>
256 |   </div>
257 | );
258 | 
259 | /*
260 |  * Editor component with custom toolbar and content containers
261 |  */
262 | class Editor extends React.Component {
263 |   constructor(props) {
264 |     super(props);
265 |     this.state = { editorHtml: '' };
266 |     this.handleChange = this.handleChange.bind(this);
267 |   }
268 | 
269 |   handleChange(html) {
270 |     this.setState({ editorHtml: html });
271 |   }
272 | 
273 |   render() {
274 |     return (
275 |       <div className="text-editor">
276 |         <CustomToolbar />
277 |         <ReactQuill
278 |           onChange={this.handleChange}
279 |           placeholder={this.props.placeholder}
280 |           modules={Editor.modules}
281 |         />
282 |       </div>
283 |     );
284 |   }
285 | }
286 | 
287 | /*
288 |  * Quill modules to attach to editor
289 |  * See http://quilljs.com/docs/modules/ for complete options
290 |  */
291 | Editor.modules = {
292 |   toolbar: {
293 |     container: '#toolbar',
294 |     handlers: {
295 |       insertStar: insertStar,
296 |     },
297 |   },
298 | };
299 | 
300 | /*
301 |  * Quill editor formats
302 |  * See http://quilljs.com/docs/formats/
303 |  */
304 | Editor.formats = [
305 |   'header',
306 |   'font',
307 |   'size',
308 |   'bold',
309 |   'italic',
310 |   'underline',
311 |   'strike',
312 |   'blockquote',
313 |   'list',
314 |   'bullet',
315 |   'indent',
316 |   'link',
317 |   'image',
318 |   'color',
319 | ];
320 | 
321 | /*
322 |  * PropType validation
323 |  */
324 | Editor.propTypes = {
325 |   placeholder: React.PropTypes.string,
326 | };
327 | 
328 | /*
329 |  * Render component on page
330 |  */
331 | ReactDOM.render(
332 |   <Editor placeholder={'Write something or insert a star ★'} />,
333 |   document.querySelector('.app')
334 | );
335 | ```
336 | 
337 | </details>
338 | 
339 | ### Custom Formats
340 | 
341 | The component has two types of formats:
342 | 
343 | 1. The default [Quill formats](http://quilljs.com/docs/formats/) that are enabled/disabled using the [`formats` prop](#props). All formats are enabled by default.
344 | 2. Custom formats created using Parchment and registered with your component's Quill instance
345 | 
346 | <details>
347 | <summary>Example Code</summary>
348 | 
349 | ```js
350 | import ReactQuill, { Quill } from 'react-quill'; // ES6
351 | const ReactQuill = require('react-quill'); // CommonJS
352 | ```
353 | 
354 | ```jsx
355 | /*
356 |  * Example Parchment format from
357 |  * https://quilljs.com/guides/cloning-medium-with-parchment/
358 |  * See the video example in the guide for a complex format
359 |  */
360 | let Inline = Quill.import('blots/inline');
361 | class BoldBlot extends Inline {}
362 | BoldBlot.blotName = 'bold';
363 | BoldBlot.tagName = 'strong';
364 | Quill.register('formats/bold', BoldBlot);
365 | 
366 | const formats = ['bold']; // add custom format name + any built-in formats you need
367 | 
368 | /*
369 |  * Editor component with default and custom formats
370 |  */
371 | class MyComponent extends React.Component {
372 |   constructor(props) {
373 |     this.formats = formats;
374 |     this.state = { text: '' };
375 |   }
376 | 
377 |   handleChange(value) {
378 |     this.setState({ text: value });
379 |   }
380 | 
381 |   render() {
382 |     return (
383 |       <ReactQuill
384 |         value={this.state.text}
385 |         onChange={this.handleChange}
386 |         formats={this.formats}
387 |       />
388 |     );
389 |   }
390 | }
391 | ```
392 | 
393 | </details>
394 | 
395 | ### Custom editing area
396 | 
397 | If you instantiate ReactQuill without children, it will create a `<div>` for you, to be used as the editing area for Quill. If you prefer, you can specify your own element for ReactQuill to use. Note that `<textarea>`s are not supported by Quill at this time.
398 | 
399 | Note: Custom editing areas lose focus when using React 16 as a peer dep at this time ([bug](https://github.com/zenoamaro/react-quill/issues/309)).
400 | 
401 | <details>
402 | 
403 | ```jsx
404 | class MyComponent extends React.Component {
405 | 
406 |   render() {
407 |     return (
408 |       <ReactQuill>
409 |         <div className="my-editing-area"/>
410 |       </ReactQuill>
411 |     );
412 |   }
413 | 
414 | });
415 | ```
416 | 
417 | </details>
418 | 
419 | ## Upgrading to ReactQuill v2
420 | 
421 | Upgrading to ReactQuill v2 should be as simple as updating your dependency. However, it also removes support for long-deprecated props, the ReactQuill Mixin, and the Toolbar component.
422 | 
423 | ### Deprecated props
424 | 
425 | Support for the `toolbar`, `styles`, `pollInterval` Quill options has long disabled. Starting from this release, ReactQuill will not warn you anymore if you try using them.
426 | 
427 | ### ReactQuill Mixin
428 | 
429 | The ReactQuill Mixin allowed injecting the core functionality that made ReactQuill tick into your own components, and create deeply customized versions.
430 | 
431 | The Mixin has been considered an anti-pattern for a long time now, so we have decided to finalize its deprecation.
432 | 
433 | There is no upgrade path. If you have a use case that relied on the Mixin, you're encouraged to open an issue, and we will try to provide you with a new feature to make it possible, or dedicated support to migrate out of it.
434 | 
435 | ### Toolbar component
436 | 
437 | Quill has long provided built-in support for custom toolbars, which replaced ReactQuill's (quite inflexible) Toolbar component.
438 | 
439 | Use the [Toolbar Module](#default-toolbar-elements) or the [HTML Toolbar](#html-toolbar) feature instead.
440 | 
441 | ## API reference
442 | 
443 | ### Exports
444 | 
445 | ```jsx
446 | // ES6
447 | import ReactQuill, { Quill } from 'react-quill';
448 | 
449 | // CommonJS
450 | const ReactQuill = require('react-quill');
451 | const { Quill } = ReactQuill;
452 | ```
453 | 
454 | `Quill`
455 | : The `Quill` namespace on which you can call `register`.
456 | 
457 | ### Props
458 | 
459 | `id`
460 | : ID to be applied to the DOM element.
461 | 
462 | `className`
463 | : Classes to be applied to the DOM element.
464 | 
465 | `value`
466 | : Value for the editor as a controlled component. Can be a string containing HTML, a [Quill Delta](https://quilljs.com/docs/delta/) instance, or a plain object representing a Delta.
467 | Note that due to limitations in Quill, this is actually a _semi-controlled_ mode, meaning that the edit is not prevented, but changing `value` will still replace the contents.
468 | Also note that passing a Quill Delta here, and then an HTML string, or vice-versa, will always trigger a change, regardless of whether they represent the same document.
469 | ⚠️ Do not pass the `delta` object from the `onChange` event as `value`, as it will cause a loop. See [Using Deltas](#using-deltas) for details.
470 | 
471 | `defaultValue`
472 | : Initial value for the editor as an uncontrolled component. Can be a string containing HTML, a [Quill Delta](https://quilljs.com/docs/delta/), or a plain object representing a Delta.
473 | 
474 | `readOnly`
475 | : If true, the editor won't allow changing its contents. Wraps the Quill [`disable` API](https://quilljs.com/docs/api/#enable).
476 | 
477 | `placeholder`
478 | : The default value for the empty editor. Note: The Quill API does not support changing this value dynamically. Use refs and data-attributes instead (see [#340](https://github.com/zenoamaro/react-quill/issues/340#issuecomment-376176878)).
479 | 
480 | `modules`
481 | : An object specifying which modules are enabled, and their configuration. The editor toolbar is a commonly customized module. See the [modules section](http://quilljs.com/docs/modules/) over the Quill documentation for more information on what modules are available.
482 | 
483 | `formats`
484 | : An array of formats to be enabled during editing. All implemented formats are enabled by default. See [Formats](http://quilljs.com/docs/formats/) for a list.
485 | Custom formats should not be included in the array as of version 1.0.0. Instead they should be created through [Parchment](https://github.com/quilljs/parchment) and registered with the module's [Quill export](#exports).
486 | 
487 | `style`
488 | : An object with custom CSS rules to apply on the editor's container. Rules should be in React's "camelCased" naming style.
489 | 
490 | `theme`
491 | : The name of the theme to apply to the editor. Defaults to `snow`, Quill's standard theme. Pass `null` to use the minimal core theme. See the [docs on themes](#themes) for more information on including the required stylesheets.
492 | 
493 | `tabIndex`
494 | : The order in which the editor becomes focused, among other controls in the page, during keyboard navigation.
495 | 
496 | `bounds`
497 | : Selector or DOM element used by Quill to constrain position of popups. Defaults to `document.body`.
498 | 
499 | `children`
500 | : A single React element that will be used as the editing area for Quill in place of the default, which is a `<div>`. Note that you cannot use a `<textarea>`, as it is not a supported target. Also note that updating children is costly, as it will cause the Quill editor to be recreated. Set the `value` prop if you want to control the html contents of the editor.
501 | 
502 | `onChange(content, delta, source, editor)`
503 | : Called back with the new contents of the editor after change. It will be passed the HTML contents of the editor, a delta object expressing the change, the source of the change, and finally a read-only proxy to [editor accessors](#the-unprivileged-editor) such as `getHTML()`.
504 | ⚠️ Do not use this `delta` object as `value`, as it will cause a loop. Use `editor.getContents()` instead. See [Using Deltas](#using-deltas) for details.
505 | 
506 | `onChangeSelection(range, source, editor)`
507 | : Called back with the new selected range, or null when unfocused. It will be passed the selection range, the source of the change, and finally a read-only proxy to editor accessors such as `getBounds()`.
508 | 
509 | `onFocus(range, source, editor)`
510 | : Called when the editor becomes focused. It will receive the new selection range.
511 | 
512 | `onBlur(previousRange, source, editor)`
513 | : Called when the editor loses focus. It will receive the selection range it had right before losing focus.
514 | 
515 | `onKeyPress(event)`
516 | : Called after a key has been pressed and released.
517 | : Note that, like its native counterpart, this won't be called for special keys such as <kbd>shift</kbd> or <kbd>enter</kbd>. If you need those, hook onto `onKeyDown` or `onKeyUp`.
518 | 
519 | `onKeyDown(event)`
520 | : Called after a key has been pressed, but before it is released.
521 | : Note that, due to how Quill works, it's possible that you won't receive events for keys such as <kbd>enter</kbd>, <kbd>backspace</kbd> or <kbd>delete</kbd>. If that's the case, try hooking onto `onKeyUp` instead.
522 | 
523 | `onKeyUp(event)`
524 | : Called after a key has been released.
525 | 
526 | `preserveWhitespace`
527 | : If true, a `pre` tag is used for the editor area instead of the default `div` tag. This prevents Quill from
528 | collapsing continuous whitespaces on paste. [Related issue](https://github.com/quilljs/quill/issues/1751).
529 | 
530 | ### Methods
531 | 
532 | If you have [a ref](https://facebook.github.io/react/docs/more-about-refs.html) to a ReactQuill node, you will be able to invoke the following methods:
533 | 
534 | `focus()`
535 | : Focuses the editor.
536 | 
537 | `blur()`
538 | : Removes focus from the editor.
539 | 
540 | `getEditor()`
541 | : Returns the Quill instance that backs the editor. While you can freely use this to access methods such as `getText()`, please avoid from imperatively manipulating the instance, to avoid getting ReactQuill and Quill out-of-sync. A much-safer [unprivileged editor](#the-unprivileged-editor) is available as replacement.
542 | 
543 | <details>
544 | <summary>Example</summary>
545 | 
546 | [View this example on Codepen](https://codepen.io/alexkrolick/pen/YNmGar?editors=0011)
547 | 
548 | ```jsx
549 | class Editor extends React.Component {
550 |   constructor(props) {
551 |     super(props);
552 |     this.quillRef = null; // Quill instance
553 |     this.reactQuillRef = null; // ReactQuill component
554 |   }
555 | 
556 |   componentDidMount() {
557 |     this.attachQuillRefs();
558 |   }
559 | 
560 |   componentDidUpdate() {
561 |     this.attachQuillRefs();
562 |   }
563 | 
564 |   attachQuillRefs = () => {
565 |     if (typeof this.reactQuillRef.getEditor !== 'function') return;
566 |     this.quillRef = this.reactQuillRef.getEditor();
567 |   };
568 | 
569 |   insertText = () => {
570 |     var range = this.quillRef.getSelection();
571 |     let position = range ? range.index : 0;
572 |     this.quillRef.insertText(position, 'Hello, World! ');
573 |   };
574 | 
575 |   render() {
576 |     return (
577 |       <div>
578 |         <ReactQuill
579 |           ref={(el) => {
580 |             this.reactQuillRef = el;
581 |           }}
582 |           theme={'snow'}
583 |         />
584 |         <button onClick={this.insertText}>Insert Text</button>
585 |       </div>
586 |     );
587 |   }
588 | }
589 | ```
590 | 
591 | </details>
592 | 
593 | `makeUnprivilegedEditor`
594 | : Creates an [unprivileged editor](#unprivileged-editor). Pass this method a reference to the Quill instance from `getEditor`. Normally you do not need to use this method since the editor exposed to event handlers is already unprivileged.
595 | 
596 | <details>
597 | <summary>Example</summary>
598 | 
599 | ```jsx
600 | const editor = this.reactQuillRef.getEditor();
601 | const unprivilegedEditor = this.reactQuillRef.makeUnprivilegedEditor(editor);
602 | // You may now use the unprivilegedEditor proxy methods
603 | unprivilegedEditor.getText();
604 | ```
605 | 
606 | </details>
607 | 
608 | ### The unprivileged editor
609 | 
610 | During events, ReactQuill will make a restricted subset of the Quill API available as the `editor` argument. This prevents access to destructive methods, which might cause ReactQuill to get out-of-sync with the component. It provides the following methods, which are mostly proxies of existing [Quill methods](https://quilljs.com/docs/api/):
611 | 
612 | `getLength()`
613 | : Returns the length of the editor contents, in characters, not including any HTML tag.
614 | 
615 | `getText()`
616 | : Returns the string contents of the editor, not including any HTML tag.
617 | 
618 | `getHTML()`
619 | : Returns the full HTML contents of the editor.
620 | 
621 | `getContents()`
622 | : Returns a [Quill Delta](https://quilljs.com/docs/delta/) of the complete document.
623 | 
624 | `getSelection()`
625 | : Returns the current selection range, or `null` if the editor is unfocused.
626 | 
627 | `getBounds()`
628 | : Returns the pixel position, relative to the editor container, and dimensions, of a selection, at a given location.
629 | 
630 | ## Building and testing
631 | 
632 | You can build libs, types and bundles:
633 | 
634 | ```sh
635 | npm build  # or watch
636 | ```
637 | 
638 | You can also run the automated test suite:
639 | 
640 | ```sh
641 | npm test
642 | ```
643 | 
644 | More tasks are available as package scripts:
645 | 
646 | | Script          | Description                                 |
647 | | --------------- | ------------------------------------------- |
648 | | `npm run build` | Builds lib and browser bundle               |
649 | | `npm run watch` | Rebuilds on source code changes             |
650 | | `npm run test`  | Runs unit tests and coverage                |
651 | | `npm run clean` | Cleans build artifacts                      |
652 | | `npm run demo`  | Serves a simple ReactQuill test application |
653 | 
654 | ## Browser support
655 | 
656 | Please check the browser support table for the upstream [Quill](https://github.com/quilljs/quill) dependency. The ReactQuill distributable itself is ES5-compatible.
657 | 
658 | ## Changelog
659 | 
660 | [Full changelog](CHANGELOG.md)
661 | 
662 | ## Contributors
663 | 
664 | ReactQuill would not be where it is today without the contributions of many people, which we are incredibly grateful for:
665 | 
666 | - @zenoamaro (maintainer)
667 | - @alexkrolick (maintainer)
668 | - @g12i
669 | - @clemmy
670 | - @asiniy
671 | - @webcarrot
672 | - @druti
673 | - @e-jigsaw
674 | - @zhang-z
675 | - @Sajam
676 | - @0bird512
677 | - @jacktrades
678 | - @1000hz
679 | - @kkerr1
680 | - @csk157
681 | - @Janekk
682 | - @AndyTheGiant
683 | - @chrismcv
684 | - @wouterh
685 | - @tdg5
686 | - @jrmmnr
687 | - @l3kn
688 | - @rpellerin
689 | - @sandbochs
690 | - @wouterh
691 | - @MattKunze
692 | 
693 | ## License
694 | 
695 | The MIT License (MIT)
696 | 
697 | Copyright (c) 2020, zenoamaro <zenoamaro@gmail.com>
698 | 
699 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
700 | 
701 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
702 | 
703 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
704 | 


--------------------------------------------------------------------------------