@quadrats/react 0.6.7 → 0.7.1

package/footnote/toolbar/FootnoteToolbarIcon.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
 import { ReactFootnote } from '@quadrats/react/footnote';
 import { UseFootnoteToolOptions } from './useFootnoteTool';
@@ -6,5 +6,5 @@ export interface FootnoteToolbarIconProps extends Omit<ToolbarIconProps, 'active
     controller: ReactFootnote;
     options?: UseFootnoteToolOptions;
 }
-declare function FootnoteToolbarIcon(props: FootnoteToolbarIconProps): JSX.Element;
+declare function FootnoteToolbarIcon(props: FootnoteToolbarIconProps): React.JSX.Element;
 export default FootnoteToolbarIcon;

package/footnote/toolbar/FootnoteToolbarIcon.js

@@ -3,10 +3,10 @@ import React from 'react';
 import { ToolbarIcon } from '@quadrats/react/toolbar';
 import { useFootnoteTool } from './useFootnoteTool.js';
 
-function FootnoteToolbarIcon(props) {
-    const { controller, options = {} } = props, rest = __rest(props, ["controller", "options"]);
-    const { active, onClick } = useFootnoteTool(controller, options);
-    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function FootnoteToolbarIcon(props) {
+    const { controller, options = {} } = props, rest = __rest(props, ["controller", "options"]);
+    const { active, onClick } = useFootnoteTool(controller, options);
+    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 export { FootnoteToolbarIcon as default };

package/footnote/toolbar/index.cjs.js

@@ -1,35 +1,29 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var react = require('@quadrats/react');
 var toolbar = require('@quadrats/react/toolbar');
 var tslib = require('tslib');
 var React = require('react');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function useFootnoteTool(controller, options = {}) {
-    const editor = react.useQuadrats();
-    const startToolInput = toolbar.useStartToolInput();
-    return {
-        active: controller.isSelectionInFootnote(editor),
-        onClick: () => startToolInput({
-            getPlaceholder: (locale) => locale.editor.footnote.inputPlaceholder,
-            confirm: (footnoteText) => {
-                controller.upsertFootnoteAndUpdateIndex(editor, footnoteText, options);
-            },
-            defaultValue: controller.getFootnoteText(editor),
-        }),
-    };
+function useFootnoteTool(controller, options = {}) {
+    const editor = react.useQuadrats();
+    const startToolInput = toolbar.useStartToolInput();
+    return {
+        active: controller.isSelectionInFootnote(editor),
+        onClick: () => startToolInput({
+            getPlaceholder: (locale) => locale.editor.footnote.inputPlaceholder,
+            confirm: (footnoteText) => {
+                controller.upsertFootnoteAndUpdateIndex(editor, footnoteText, options);
+            },
+            defaultValue: controller.getFootnoteText(editor),
+        }),
+    };
 }
 
-function FootnoteToolbarIcon(props) {
-    const { controller, options = {} } = props, rest = tslib.__rest(props, ["controller", "options"]);
-    const { active, onClick } = useFootnoteTool(controller, options);
-    return React__default.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function FootnoteToolbarIcon(props) {
+    const { controller, options = {} } = props, rest = tslib.__rest(props, ["controller", "options"]);
+    const { active, onClick } = useFootnoteTool(controller, options);
+    return React.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 exports.FootnoteToolbarIcon = FootnoteToolbarIcon;

package/footnote/toolbar/useFootnoteTool.d.ts

@@ -1,6 +1,6 @@
 import { FootnoteUpsertFootnoteOptions } from '@quadrats/common/footnote';
 import { ReactFootnote } from '@quadrats/react/footnote';
-export declare type UseFootnoteToolOptions = FootnoteUpsertFootnoteOptions;
+export type UseFootnoteToolOptions = FootnoteUpsertFootnoteOptions;
 export declare function useFootnoteTool(controller: ReactFootnote, options?: UseFootnoteToolOptions): {
     active: boolean;
     onClick: () => void;

package/footnote/toolbar/useFootnoteTool.js

@@ -1,19 +1,19 @@
 import { useQuadrats } from '@quadrats/react';
 import { useStartToolInput } from '@quadrats/react/toolbar';
 
-function useFootnoteTool(controller, options = {}) {
-    const editor = useQuadrats();
-    const startToolInput = useStartToolInput();
-    return {
-        active: controller.isSelectionInFootnote(editor),
-        onClick: () => startToolInput({
-            getPlaceholder: (locale) => locale.editor.footnote.inputPlaceholder,
-            confirm: (footnoteText) => {
-                controller.upsertFootnoteAndUpdateIndex(editor, footnoteText, options);
-            },
-            defaultValue: controller.getFootnoteText(editor),
-        }),
-    };
+function useFootnoteTool(controller, options = {}) {
+    const editor = useQuadrats();
+    const startToolInput = useStartToolInput();
+    return {
+        active: controller.isSelectionInFootnote(editor),
+        onClick: () => startToolInput({
+            getPlaceholder: (locale) => locale.editor.footnote.inputPlaceholder,
+            confirm: (footnoteText) => {
+                controller.upsertFootnoteAndUpdateIndex(editor, footnoteText, options);
+            },
+            defaultValue: controller.getFootnoteText(editor),
+        }),
+    };
 }
 
 export { useFootnoteTool };

package/footnote/typings.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { Footnote, FootnoteElement } from '@quadrats/common/footnote';
 import { RenderElementProps, ReactWithable, WithCreateRenderElement, Editor } from '@quadrats/react';
-export declare type RenderFootnoteElementProps = RenderElementProps<FootnoteElement>;
+export type RenderFootnoteElementProps = RenderElementProps<FootnoteElement>;
 export interface ReactFootnoteCreateRenderElementOptions {
     render?: (props: RenderFootnoteElementProps) => JSX.Element | null | undefined;
 }

package/footnote/useFootnotes.js

@@ -1,21 +1,21 @@
 import { getNodes } from '@quadrats/core';
 import { FOOTNOTE_TYPE } from '@quadrats/common/footnote';
 
-function useFootnotes(editor) {
-    const footnoteNodes = Array.from(getNodes(editor, {
-        at: [],
-        match: node => node.type === FOOTNOTE_TYPE,
-    }));
-    const footnotes = footnoteNodes.map((node) => {
-        var _a, _b;
-        const nodeData = node === null || node === void 0 ? void 0 : node[0];
-        return {
-            wrapperText: (_b = (_a = (nodeData === null || nodeData === void 0 ? void 0 : nodeData.children)) === null || _a === void 0 ? void 0 : _a.map(childNode => childNode.text).join('')) !== null && _b !== void 0 ? _b : '',
-            footnote: nodeData === null || nodeData === void 0 ? void 0 : nodeData.footnote,
-            index: nodeData === null || nodeData === void 0 ? void 0 : nodeData.index,
-        };
-    });
-    return footnotes;
+function useFootnotes(editor) {
+    const footnoteNodes = Array.from(getNodes(editor, {
+        at: [],
+        match: node => node.type === FOOTNOTE_TYPE,
+    }));
+    const footnotes = footnoteNodes.map((node) => {
+        var _a, _b;
+        const nodeData = node === null || node === void 0 ? void 0 : node[0];
+        return {
+            wrapperText: (_b = (_a = (nodeData === null || nodeData === void 0 ? void 0 : nodeData.children)) === null || _a === void 0 ? void 0 : _a.map(childNode => childNode.text).join('')) !== null && _b !== void 0 ? _b : '',
+            footnote: nodeData === null || nodeData === void 0 ? void 0 : nodeData.footnote,
+            index: nodeData === null || nodeData === void 0 ? void 0 : nodeData.index,
+        };
+    });
+    return footnotes;
 }
 
 export { useFootnotes as default, useFootnotes };

package/footnote/useFootnotesFromNodes.js

@@ -1,27 +1,27 @@
 import { Node } from '@quadrats/core';
 import { FOOTNOTE_TYPE } from '@quadrats/common/footnote';
 
-function deepSearchFootnoteFromNodes(nodes) {
-    const result = nodes.flatMap((element) => {
-        var _a, _b;
-        const curNode = Node.isNode(element)
-            && element.type === FOOTNOTE_TYPE ? element : null;
-        const child = Node.isNodeList(element === null || element === void 0 ? void 0 : element.children)
-            ? deepSearchFootnoteFromNodes((_a = element === null || element === void 0 ? void 0 : element.children) !== null && _a !== void 0 ? _a : []) : null;
-        return (_b = curNode !== null && curNode !== void 0 ? curNode : child) !== null && _b !== void 0 ? _b : [];
-    });
-    return result;
-}
-function useFootnotesFromNodes(nodes) {
-    const filter = deepSearchFootnoteFromNodes(nodes);
-    return filter.map(element => {
-        var _a;
-        return ({
-            wrapperText: (_a = (element === null || element === void 0 ? void 0 : element.children)) === null || _a === void 0 ? void 0 : _a.map(childNode => childNode.text).join(''),
-            footnote: element.footnote,
-            index: element.index,
-        });
-    });
+function deepSearchFootnoteFromNodes(nodes) {
+    const result = nodes.flatMap((element) => {
+        var _a, _b;
+        const curNode = Node.isNode(element)
+            && element.type === FOOTNOTE_TYPE ? element : null;
+        const child = Node.isNodeList(element === null || element === void 0 ? void 0 : element.children)
+            ? deepSearchFootnoteFromNodes((_a = element === null || element === void 0 ? void 0 : element.children) !== null && _a !== void 0 ? _a : []) : null;
+        return (_b = curNode !== null && curNode !== void 0 ? curNode : child) !== null && _b !== void 0 ? _b : [];
+    });
+    return result;
+}
+function useFootnotesFromNodes(nodes) {
+    const filter = deepSearchFootnoteFromNodes(nodes);
+    return filter.map(element => {
+        var _a;
+        return ({
+            wrapperText: (_a = (element === null || element === void 0 ? void 0 : element.children)) === null || _a === void 0 ? void 0 : _a.map(childNode => childNode.text).join(''),
+            footnote: element.footnote,
+            index: element.index,
+        });
+    });
 }
 
 export { useFootnotesFromNodes as default, useFootnotesFromNodes };

package/heading/constants.js

@@ -1,11 +1,11 @@
-/**
- * Default hotkey for toggling heading.
- *
- * @remarks
- * If the hotkey is `ctrl+opt`, the level 1 hotkey will be `ctrl+opt+1`, and so on.
- *
- * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
- */
+/**
+ * Default hotkey for toggling heading.
+ *
+ * @remarks
+ * If the hotkey is `ctrl+opt`, the level 1 hotkey will be `ctrl+opt+1`, and so on.
+ *
+ * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
+ */
 const HEADING_HOTKEY = 'ctrl+opt';
 
 export { HEADING_HOTKEY };

package/heading/createReactHeading.d.ts

@@ -1,4 +1,4 @@
 import { CreateHeadingOptions, HeadingLevel } from '@quadrats/common/heading';
 import { ReactHeading } from './typings';
-export declare type CreateReactHeadingOptions<L extends HeadingLevel> = CreateHeadingOptions<L>;
+export type CreateReactHeadingOptions<L extends HeadingLevel> = CreateHeadingOptions<L>;
 export declare function createReactHeading<L extends HeadingLevel = HeadingLevel>(options?: CreateReactHeadingOptions<L>): ReactHeading<L>;

package/heading/createReactHeading.js

@@ -5,43 +5,43 @@ import { createOnKeyDownBreak } from '@quadrats/react/line-break';
 import { HEADING_HOTKEY } from './constants.js';
 import { defaultRenderHeadingElement } from './defaultRenderHeadingElement.js';
 
-function createReactHeading(options = {}) {
-    const core = createHeading(options);
-    const { type } = core;
-    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = HEADING_HOTKEY } = {}) => {
-            const onKeyDownBreak = createOnKeyDownBreak({
-                exitBreak: {
-                    rules: [
-                        {
-                            hotkey: 'enter',
-                            match: {
-                                onlyAtEdge: true,
-                                includeTypes: [type],
-                            },
-                        },
-                    ],
-                },
-            });
-            return {
-                onKeyDown(event, editor, next) {
-                    /**
-                     * Only toggle if the hotkey is fired and the key is the same as level.
-                     */
-                    const keyAsNumber = +event.key;
-                    if (!Number.isNaN(keyAsNumber) && isHotkey(hotkey, event)) {
-                        try {
-                            core.toggleHeadingNodes(editor, keyAsNumber);
-                            event.preventDefault();
-                            // eslint-disable-next-line no-empty
-                        }
-                        catch (_a) { }
-                    }
-                    else {
-                        onKeyDownBreak(event, editor, next);
-                    }
-                },
-            };
-        }, createRenderElement: ({ render = defaultRenderHeadingElement } = {}) => createRenderElement({ type, render }) });
+function createReactHeading(options = {}) {
+    const core = createHeading(options);
+    const { type } = core;
+    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = HEADING_HOTKEY } = {}) => {
+            const onKeyDownBreak = createOnKeyDownBreak({
+                exitBreak: {
+                    rules: [
+                        {
+                            hotkey: 'enter',
+                            match: {
+                                onlyAtEdge: true,
+                                includeTypes: [type],
+                            },
+                        },
+                    ],
+                },
+            });
+            return {
+                onKeyDown(event, editor, next) {
+                    /**
+                     * Only toggle if the hotkey is fired and the key is the same as level.
+                     */
+                    const keyAsNumber = +event.key;
+                    if (!Number.isNaN(keyAsNumber) && isHotkey(hotkey, event)) {
+                        try {
+                            core.toggleHeadingNodes(editor, keyAsNumber);
+                            event.preventDefault();
+                            // eslint-disable-next-line no-empty
+                        }
+                        catch (_a) { }
+                    }
+                    else {
+                        onKeyDownBreak(event, editor, next);
+                    }
+                },
+            };
+        }, createRenderElement: ({ render = defaultRenderHeadingElement } = {}) => createRenderElement({ type, render }) });
 }
 
 export { createReactHeading };

package/heading/defaultRenderHeadingElement.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { HeadingElement } from '@quadrats/common/heading';
 import { RenderElementProps } from '@quadrats/react';
 export declare const HEADING_COMPONENTS: {
@@ -19,4 +19,4 @@ export declare const defaultRenderHeadingElement: ({ attributes, children, eleme
     } | undefined;
     children: RenderElementProps['children'];
     element: HeadingElement;
-}) => JSX.Element | null;
+}) => React.JSX.Element | null;

package/heading/defaultRenderHeadingElement.js

@@ -1,19 +1,19 @@
 import React from 'react';
 
-const HEADING_COMPONENTS = {
-    1: 'h1',
-    2: 'h2',
-    3: 'h3',
-    4: 'h4',
-    5: 'h5',
-    6: 'h6',
-};
-const defaultRenderHeadingElement = ({ attributes, children, element, }) => {
-    const Component = HEADING_COMPONENTS[element.level];
-    if (!Component) {
-        return null;
-    }
-    return React.createElement(Component, Object.assign({}, attributes, { className: `qdr-${Component}` }), children);
+const HEADING_COMPONENTS = {
+    1: 'h1',
+    2: 'h2',
+    3: 'h3',
+    4: 'h4',
+    5: 'h5',
+    6: 'h6',
+};
+const defaultRenderHeadingElement = ({ attributes, children, element, }) => {
+    const Component = HEADING_COMPONENTS[element.level];
+    if (!Component) {
+        return null;
+    }
+    return React.createElement(Component, Object.assign({}, attributes, { className: `qdr-${Component}` }), children);
 };
 
 export { HEADING_COMPONENTS, defaultRenderHeadingElement };

package/heading/index.cjs.js

@@ -1,81 +1,74 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var isHotkey = require('is-hotkey');
 var heading = require('@quadrats/common/heading');
 var react = require('@quadrats/react');
 var lineBreak = require('@quadrats/react/line-break');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var isHotkey__default = /*#__PURE__*/_interopDefaultLegacy(isHotkey);
-
-/**
- * Default hotkey for toggling heading.
- *
- * @remarks
- * If the hotkey is `ctrl+opt`, the level 1 hotkey will be `ctrl+opt+1`, and so on.
- *
- * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
- */
+/**
+ * Default hotkey for toggling heading.
+ *
+ * @remarks
+ * If the hotkey is `ctrl+opt`, the level 1 hotkey will be `ctrl+opt+1`, and so on.
+ *
+ * @see [is-hotkey]{@link https://www.npmjs.com/package/is-hotkey}
+ */
 const HEADING_HOTKEY = 'ctrl+opt';
 
-const HEADING_COMPONENTS = {
-    1: 'h1',
-    2: 'h2',
-    3: 'h3',
-    4: 'h4',
-    5: 'h5',
-    6: 'h6',
-};
-const defaultRenderHeadingElement = ({ attributes, children, element, }) => {
-    const Component = HEADING_COMPONENTS[element.level];
-    if (!Component) {
-        return null;
-    }
-    return React__default.createElement(Component, Object.assign({}, attributes, { className: `qdr-${Component}` }), children);
+const HEADING_COMPONENTS = {
+    1: 'h1',
+    2: 'h2',
+    3: 'h3',
+    4: 'h4',
+    5: 'h5',
+    6: 'h6',
+};
+const defaultRenderHeadingElement = ({ attributes, children, element, }) => {
+    const Component = HEADING_COMPONENTS[element.level];
+    if (!Component) {
+        return null;
+    }
+    return React.createElement(Component, Object.assign({}, attributes, { className: `qdr-${Component}` }), children);
 };
 
-function createReactHeading(options = {}) {
-    const core = heading.createHeading(options);
-    const { type } = core;
-    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = HEADING_HOTKEY } = {}) => {
-            const onKeyDownBreak = lineBreak.createOnKeyDownBreak({
-                exitBreak: {
-                    rules: [
-                        {
-                            hotkey: 'enter',
-                            match: {
-                                onlyAtEdge: true,
-                                includeTypes: [type],
-                            },
-                        },
-                    ],
-                },
-            });
-            return {
-                onKeyDown(event, editor, next) {
-                    /**
-                     * Only toggle if the hotkey is fired and the key is the same as level.
-                     */
-                    const keyAsNumber = +event.key;
-                    if (!Number.isNaN(keyAsNumber) && isHotkey__default(hotkey, event)) {
-                        try {
-                            core.toggleHeadingNodes(editor, keyAsNumber);
-                            event.preventDefault();
-                            // eslint-disable-next-line no-empty
-                        }
-                        catch (_a) { }
-                    }
-                    else {
-                        onKeyDownBreak(event, editor, next);
-                    }
-                },
-            };
-        }, createRenderElement: ({ render = defaultRenderHeadingElement } = {}) => react.createRenderElement({ type, render }) });
+function createReactHeading(options = {}) {
+    const core = heading.createHeading(options);
+    const { type } = core;
+    return Object.assign(Object.assign({}, core), { createHandlers: ({ hotkey = HEADING_HOTKEY } = {}) => {
+            const onKeyDownBreak = lineBreak.createOnKeyDownBreak({
+                exitBreak: {
+                    rules: [
+                        {
+                            hotkey: 'enter',
+                            match: {
+                                onlyAtEdge: true,
+                                includeTypes: [type],
+                            },
+                        },
+                    ],
+                },
+            });
+            return {
+                onKeyDown(event, editor, next) {
+                    /**
+                     * Only toggle if the hotkey is fired and the key is the same as level.
+                     */
+                    const keyAsNumber = +event.key;
+                    if (!Number.isNaN(keyAsNumber) && isHotkey(hotkey, event)) {
+                        try {
+                            core.toggleHeadingNodes(editor, keyAsNumber);
+                            event.preventDefault();
+                            // eslint-disable-next-line no-empty
+                        }
+                        catch (_a) { }
+                    }
+                    else {
+                        onKeyDownBreak(event, editor, next);
+                    }
+                },
+            };
+        }, createRenderElement: ({ render = defaultRenderHeadingElement } = {}) => react.createRenderElement({ type, render }) });
 }
 
 exports.HEADING_HOTKEY = HEADING_HOTKEY;

package/heading/jsx-serializer/createJsxSerializeHeading.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
 import { CreateJsxSerializeElementOptions } from '@quadrats/react/jsx-serializer';
 import { JsxSerializeHeadingElementProps } from './typings';
-export declare type CreateJsxSerializeHeadingOptions = Partial<CreateJsxSerializeElementOptions<JsxSerializeHeadingElementProps>>;
-export declare function createJsxSerializeHeading(options?: CreateJsxSerializeHeadingOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element | null | undefined;
+export type CreateJsxSerializeHeadingOptions = Partial<CreateJsxSerializeElementOptions<JsxSerializeHeadingElementProps>>;
+export declare function createJsxSerializeHeading(options?: CreateJsxSerializeHeadingOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps) => JSX.Element | null | undefined;

package/heading/jsx-serializer/createJsxSerializeHeading.js

@@ -2,9 +2,9 @@ import { HEADING_TYPE } from '@quadrats/common/heading';
 import { createJsxSerializeElement } from '@quadrats/react/jsx-serializer';
 import { defaultRenderHeadingElement } from '@quadrats/react/heading';
 
-function createJsxSerializeHeading(options = {}) {
-    const { type = HEADING_TYPE, render = defaultRenderHeadingElement } = options;
-    return createJsxSerializeElement({ type, render });
+function createJsxSerializeHeading(options = {}) {
+    const { type = HEADING_TYPE, render = defaultRenderHeadingElement } = options;
+    return createJsxSerializeElement({ type, render });
 }
 
 export { createJsxSerializeHeading };

package/heading/jsx-serializer/index.cjs.js

@@ -1,14 +1,12 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var heading = require('@quadrats/react/heading');
 var heading$1 = require('@quadrats/common/heading');
 var jsxSerializer = require('@quadrats/react/jsx-serializer');
 
-function createJsxSerializeHeading(options = {}) {
-    const { type = heading$1.HEADING_TYPE, render = heading.defaultRenderHeadingElement } = options;
-    return jsxSerializer.createJsxSerializeElement({ type, render });
+function createJsxSerializeHeading(options = {}) {
+    const { type = heading$1.HEADING_TYPE, render = heading.defaultRenderHeadingElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
 }
 
 exports.defaultRenderHeadingElement = heading.defaultRenderHeadingElement;

package/heading/jsx-serializer/typings.d.ts

@@ -1,3 +1,3 @@
 import { HeadingElement } from '@quadrats/common/heading';
 import { JsxSerializeElementProps } from '@quadrats/react/jsx-serializer';
-export declare type JsxSerializeHeadingElementProps = JsxSerializeElementProps<HeadingElement>;
+export type JsxSerializeHeadingElementProps = JsxSerializeElementProps<HeadingElement>;

package/heading/toolbar/HeadingToolbarIcon.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { HeadingLevel } from '@quadrats/common/heading';
 import { ReactHeading } from '@quadrats/react/heading';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
@@ -6,5 +6,5 @@ export interface HeadingToolbarIconProps<Level extends HeadingLevel, ValidLevel
     controller: ReactHeading<Level>;
     level: ValidLevel;
 }
-declare function HeadingToolbarIcon<Level extends HeadingLevel, ValidLevel extends Level>(props: HeadingToolbarIconProps<Level, ValidLevel>): JSX.Element;
+declare function HeadingToolbarIcon<Level extends HeadingLevel, ValidLevel extends Level>(props: HeadingToolbarIconProps<Level, ValidLevel>): React.JSX.Element;
 export default HeadingToolbarIcon;

package/heading/toolbar/HeadingToolbarIcon.js

@@ -3,10 +3,10 @@ import React from 'react';
 import { ToolbarIcon } from '@quadrats/react/toolbar';
 import { useToggleHeadingTool } from './useToggleHeadingTool.js';
 
-function HeadingToolbarIcon(props) {
-    const { controller, level } = props, rest = __rest(props, ["controller", "level"]);
-    const { active, onClick } = useToggleHeadingTool(controller, level);
-    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function HeadingToolbarIcon(props) {
+    const { controller, level } = props, rest = __rest(props, ["controller", "level"]);
+    const { active, onClick } = useToggleHeadingTool(controller, level);
+    return React.createElement(ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 export { HeadingToolbarIcon as default };

package/heading/toolbar/index.cjs.js

@@ -1,28 +1,22 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var react = require('@quadrats/react');
 var tslib = require('tslib');
 var React = require('react');
 var toolbar = require('@quadrats/react/toolbar');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function useToggleHeadingTool(controller, level) {
-    const editor = react.useQuadrats();
-    return {
-        active: controller.isSelectionInHeading(editor, level),
-        onClick: () => controller.toggleHeadingNodes(editor, level),
-    };
+function useToggleHeadingTool(controller, level) {
+    const editor = react.useQuadrats();
+    return {
+        active: controller.isSelectionInHeading(editor, level),
+        onClick: () => controller.toggleHeadingNodes(editor, level),
+    };
 }
 
-function HeadingToolbarIcon(props) {
-    const { controller, level } = props, rest = tslib.__rest(props, ["controller", "level"]);
-    const { active, onClick } = useToggleHeadingTool(controller, level);
-    return React__default.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function HeadingToolbarIcon(props) {
+    const { controller, level } = props, rest = tslib.__rest(props, ["controller", "level"]);
+    const { active, onClick } = useToggleHeadingTool(controller, level);
+    return React.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
 exports.HeadingToolbarIcon = HeadingToolbarIcon;