@quadrats/react 0.6.6 → 0.7.0

package/jsx-serializer/index.cjs.js

@@ -1,69 +1,63 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var _internal = require('@quadrats/react/_internal');
 var React = require('react');
 var serializers = require('@quadrats/core/serializers');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function createJsxSerializeElement(options) {
-    return _internal.createRenderElementBase(options);
+function createJsxSerializeElement(options) {
+    return _internal.createRenderElementBase(options);
 }
 
-function createJsxSerializeElements(options) {
-    return _internal.createRenderElementsBase(options);
+function createJsxSerializeElements(options) {
+    return _internal.createRenderElementsBase(options);
 }
 
-function createJsxSerializeMark(options) {
-    return _internal.createRenderMarkBase(options);
+function createJsxSerializeMark(options) {
+    return _internal.createRenderMarkBase(options);
 }
 
-let key = 0;
-function addKey(element) {
-    key += 1;
-    return React.cloneElement(element, { key });
-}
-function createJsxSerializer(options) {
-    const { defaultElement: defaultSerializeElement = ({ children }) => React__default.createElement("div", null, children), defaultLeaf: defaultSerializeLeaf = ({ children }) => React__default.createElement("span", null, children), elements: serializeElements = [], leafs: serializeLeafs = [], } = options;
-    const serializeElement = _internal.composeRenderElementsBase(defaultSerializeElement, serializeElements);
-    const serializeLeaf = _internal.composeRenderLeafsBase(defaultSerializeLeaf, serializeLeafs);
-    const leafStyle = {
-        whiteSpace: 'pre-wrap',
-    };
-    function serializeNode(node) {
-        const { parent } = node;
-        let result;
-        if (!serializers.isText(node)) {
-            result = serializeElement({
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                children: serializeNodes(node.children, node),
-                element: Object.assign(Object.assign({}, node), { parent }),
-            });
-        }
-        else if (node.text) {
-            result = serializeLeaf({
-                leaf: node,
-                children: (React__default.createElement("span", { style: leafStyle }, node.text
-                    .split('\n')
-                    .map(t => t || ' ')
-                    .join('\n'))),
-            });
-        }
-        else {
-            result = React__default.createElement("span", null, "\uFEFF");
-        }
-        return addKey(result);
-    }
-    function serializeNodes(nodes, parent) {
-        return React__default.createElement(React__default.Fragment, null, nodes.map(node => serializeNode(Object.assign(Object.assign({}, node), { parent }))));
-    }
-    return {
-        serialize: (nodes) => serializeNodes(nodes, undefined),
-    };
+let key = 0;
+function addKey(element) {
+    key += 1;
+    return React.cloneElement(element, { key });
+}
+function createJsxSerializer(options) {
+    const { defaultElement: defaultSerializeElement = ({ children }) => React.createElement("div", null, children), defaultLeaf: defaultSerializeLeaf = ({ children }) => React.createElement("span", null, children), elements: serializeElements = [], leafs: serializeLeafs = [], } = options;
+    const serializeElement = _internal.composeRenderElementsBase(defaultSerializeElement, serializeElements);
+    const serializeLeaf = _internal.composeRenderLeafsBase(defaultSerializeLeaf, serializeLeafs);
+    const leafStyle = {
+        whiteSpace: 'pre-wrap',
+    };
+    function serializeNode(node) {
+        const { parent } = node;
+        let result;
+        if (!serializers.isText(node)) {
+            result = serializeElement({
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                children: serializeNodes(node.children, node),
+                element: Object.assign(Object.assign({}, node), { parent }),
+            });
+        }
+        else if (node.text) {
+            result = serializeLeaf({
+                leaf: node,
+                children: (React.createElement("span", { style: leafStyle }, node.text
+                    .split('\n')
+                    .map(t => t || ' ')
+                    .join('\n'))),
+            });
+        }
+        else {
+            result = React.createElement("span", null, "\uFEFF");
+        }
+        return addKey(result);
+    }
+    function serializeNodes(nodes, parent) {
+        return React.createElement(React.Fragment, null, nodes.map(node => serializeNode(Object.assign(Object.assign({}, node), { parent }))));
+    }
+    return {
+        serialize: (nodes) => serializeNodes(nodes, undefined),
+    };
 }
 
 exports.createJsxSerializeElement = createJsxSerializeElement;

package/jsx-serializer/typings.d.ts

@@ -1,8 +1,8 @@
 import { QuadratsElement } from '@quadrats/core';
 import { WithElementParent } from '@quadrats/core/serializers';
 import { CreateRenderElementOptionsBase, CreateRenderMarkOptionsBase, RenderElementPropsBase, RenderLeafPropsBase, RenderMarkPropsBase } from '@quadrats/react/_internal';
-export declare type JsxSerializeLeafProps = RenderLeafPropsBase;
-export declare type JsxSerializeMarkProps<M> = RenderMarkPropsBase<M>;
-export declare type JsxSerializeElementProps<E extends QuadratsElement = QuadratsElement> = RenderElementPropsBase<E & WithElementParent>;
-export declare type CreateJsxSerializeMarkOptions<M> = CreateRenderMarkOptionsBase<M, JsxSerializeMarkProps<M>>;
-export declare type CreateJsxSerializeElementOptions<P extends JsxSerializeElementProps> = CreateRenderElementOptionsBase<P>;
+export type JsxSerializeLeafProps = RenderLeafPropsBase;
+export type JsxSerializeMarkProps<M> = RenderMarkPropsBase<M>;
+export type JsxSerializeElementProps<E extends QuadratsElement = QuadratsElement> = RenderElementPropsBase<E & WithElementParent>;
+export type CreateJsxSerializeMarkOptions<M> = CreateRenderMarkOptionsBase<M, JsxSerializeMarkProps<M>>;
+export type CreateJsxSerializeElementOptions<P extends JsxSerializeElementProps> = CreateRenderElementOptionsBase<P>;

package/line-break/commonBreak.js

@@ -1,31 +1,31 @@
 import { createOnKeyDownBreak } from './createOnKeyDownBreak.js';
 
-const COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = 'mod+enter';
-const COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = 'mod+shift+enter';
-const COMMON_EXIT_BREAK_ON_BEFORE_RULE = {
-    hotkey: COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY,
-};
-const COMMON_EXIT_BREAK_ON_AFTER_RULE = {
-    hotkey: COMMON_EXIT_BREAK_ON_AFTER_HOTKEY,
-    before: true,
-};
-const COMMON_EXIT_BREAK_RULES = [COMMON_EXIT_BREAK_ON_AFTER_RULE, COMMON_EXIT_BREAK_ON_BEFORE_RULE];
-const COMMON_SOFT_BREAK_HOTKEY = 'shift+enter';
-const COMMON_SOFT_BREAK_RULE = {
-    hotkey: COMMON_SOFT_BREAK_HOTKEY,
-};
-/**
- * Common behavior of exit.
- *
- * Using `shift+enter` for soft break and `mod+enter` for exit break.
- */
-const COMMON_ON_KEY_DOWN_BREAK = createOnKeyDownBreak({
-    exitBreak: {
-        rules: COMMON_EXIT_BREAK_RULES,
-    },
-    softBreak: {
-        rules: [COMMON_SOFT_BREAK_RULE],
-    },
+const COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = 'mod+enter';
+const COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = 'mod+shift+enter';
+const COMMON_EXIT_BREAK_ON_BEFORE_RULE = {
+    hotkey: COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY,
+};
+const COMMON_EXIT_BREAK_ON_AFTER_RULE = {
+    hotkey: COMMON_EXIT_BREAK_ON_AFTER_HOTKEY,
+    before: true,
+};
+const COMMON_EXIT_BREAK_RULES = [COMMON_EXIT_BREAK_ON_AFTER_RULE, COMMON_EXIT_BREAK_ON_BEFORE_RULE];
+const COMMON_SOFT_BREAK_HOTKEY = 'shift+enter';
+const COMMON_SOFT_BREAK_RULE = {
+    hotkey: COMMON_SOFT_BREAK_HOTKEY,
+};
+/**
+ * Common behavior of exit.
+ *
+ * Using `shift+enter` for soft break and `mod+enter` for exit break.
+ */
+const COMMON_ON_KEY_DOWN_BREAK = createOnKeyDownBreak({
+    exitBreak: {
+        rules: COMMON_EXIT_BREAK_RULES,
+    },
+    softBreak: {
+        rules: [COMMON_SOFT_BREAK_RULE],
+    },
 });
 
 export { COMMON_EXIT_BREAK_ON_AFTER_HOTKEY, COMMON_EXIT_BREAK_ON_AFTER_RULE, COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY, COMMON_EXIT_BREAK_ON_BEFORE_RULE, COMMON_EXIT_BREAK_RULES, COMMON_ON_KEY_DOWN_BREAK, COMMON_SOFT_BREAK_HOTKEY, COMMON_SOFT_BREAK_RULE };

package/line-break/createOnKeyDownBreak.js

@@ -2,47 +2,47 @@ import { __rest } from 'tslib';
 import isHotkey from 'is-hotkey';
 import { getAboveBlock, isNodeMatch, isSelectionAtBlockEdge, Path, Transforms, insertSoftBreak, PARAGRAPH_TYPE } from '@quadrats/core';
 
-function createOnKeyDownBreak({ exitBreak, softBreak }) {
-    return (event, editor, next) => {
-        const { selection } = editor;
-        if (selection) {
-            /**
-             * Take vscode as reference. Won't delete fragment and only use `selection.focus` as the anchor of exit break.
-             */
-            const entry = getAboveBlock(editor, { at: selection.focus });
-            if (exitBreak) {
-                const { rules } = exitBreak;
-                for (const rule of rules) {
-                    const { hotkey } = rule, _a = rule.match, _b = _a === void 0 ? {} : _a, { onlyAtEdge = false } = _b, match = __rest(_b, ["onlyAtEdge"]), { before = false, defaultType = PARAGRAPH_TYPE } = rule;
-                    if (isHotkey(hotkey, event)
-                        && isNodeMatch(entry, match)
-                        && (!onlyAtEdge || isSelectionAtBlockEdge(editor))) {
-                        let [, at] = entry;
-                        if (!before) {
-                            at = Path.next(at);
-                        }
-                        event.preventDefault();
-                        Transforms.insertNodes(editor, { type: defaultType, children: [{ text: '' }] }, {
-                            at,
-                            select: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            if (softBreak) {
-                const { rules } = softBreak;
-                for (const { hotkey, match } of rules) {
-                    if (isHotkey(hotkey, event) && (!match || isNodeMatch(entry, match))) {
-                        event.preventDefault();
-                        insertSoftBreak(editor);
-                        return;
-                    }
-                }
-            }
-        }
-        next();
-    };
+function createOnKeyDownBreak({ exitBreak, softBreak }) {
+    return (event, editor, next) => {
+        const { selection } = editor;
+        if (selection) {
+            /**
+             * Take vscode as reference. Won't delete fragment and only use `selection.focus` as the anchor of exit break.
+             */
+            const entry = getAboveBlock(editor, { at: selection.focus });
+            if (exitBreak) {
+                const { rules } = exitBreak;
+                for (const rule of rules) {
+                    const { hotkey } = rule, _a = rule.match, _b = _a === void 0 ? {} : _a, { onlyAtEdge = false } = _b, match = __rest(_b, ["onlyAtEdge"]), { before = false, defaultType = PARAGRAPH_TYPE } = rule;
+                    if (isHotkey(hotkey, event)
+                        && isNodeMatch(entry, match)
+                        && (!onlyAtEdge || isSelectionAtBlockEdge(editor))) {
+                        let [, at] = entry;
+                        if (!before) {
+                            at = Path.next(at);
+                        }
+                        event.preventDefault();
+                        Transforms.insertNodes(editor, { type: defaultType, children: [{ text: '' }] }, {
+                            at,
+                            select: true,
+                        });
+                        return;
+                    }
+                }
+            }
+            if (softBreak) {
+                const { rules } = softBreak;
+                for (const { hotkey, match } of rules) {
+                    if (isHotkey(hotkey, event) && (!match || isNodeMatch(entry, match))) {
+                        event.preventDefault();
+                        insertSoftBreak(editor);
+                        return;
+                    }
+                }
+            }
+        }
+        next();
+    };
 }
 
 export { createOnKeyDownBreak };

package/line-break/createReactLineBreak.d.ts

@@ -1,4 +1,4 @@
 import { CreateLineBreakOptions } from '@quadrats/core';
 import { ReactBreak } from './typings';
-export declare type CreateReactLineBreakOptions = CreateLineBreakOptions;
+export type CreateReactLineBreakOptions = CreateLineBreakOptions;
 export declare function createReactLineBreak(options?: CreateReactLineBreakOptions): ReactBreak;

package/line-break/createReactLineBreak.js

@@ -3,12 +3,12 @@ import { createRenderElement } from '@quadrats/react';
 import { COMMON_ON_KEY_DOWN_BREAK } from './commonBreak.js';
 import { defaultRenderLineBreakElement } from './defaultRenderLineBreakElement.js';
 
-function createReactLineBreak(options = {}) {
-    const core = createLineBreak(options);
-    const { type } = core;
-    return Object.assign(Object.assign({}, core), { createHandlers: () => ({
-            onKeyDown: COMMON_ON_KEY_DOWN_BREAK,
-        }), createRenderElement: ({ render = defaultRenderLineBreakElement } = {}) => createRenderElement({ type, render }) });
+function createReactLineBreak(options = {}) {
+    const core = createLineBreak(options);
+    const { type } = core;
+    return Object.assign(Object.assign({}, core), { createHandlers: () => ({
+            onKeyDown: COMMON_ON_KEY_DOWN_BREAK,
+        }), createRenderElement: ({ render = defaultRenderLineBreakElement } = {}) => createRenderElement({ type, render }) });
 }
 
 export { createReactLineBreak };

package/line-break/defaultRenderLineBreakElement.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="react" />
+import React from 'react';
 import { RenderLineBreakElementProps } from './typings';
-export declare const defaultRenderLineBreakElement: ({ attributes, children }: RenderLineBreakElementProps) => JSX.Element;
+export declare const defaultRenderLineBreakElement: ({ attributes, children }: RenderLineBreakElementProps) => React.JSX.Element;

package/line-break/index.cjs.js

@@ -1,100 +1,93 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var tslib = require('tslib');
 var isHotkey = require('is-hotkey');
 var core = require('@quadrats/core');
 var react = require('@quadrats/react');
 var React = require('react');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var isHotkey__default = /*#__PURE__*/_interopDefaultLegacy(isHotkey);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-function createOnKeyDownBreak({ exitBreak, softBreak }) {
-    return (event, editor, next) => {
-        const { selection } = editor;
-        if (selection) {
-            /**
-             * Take vscode as reference. Won't delete fragment and only use `selection.focus` as the anchor of exit break.
-             */
-            const entry = core.getAboveBlock(editor, { at: selection.focus });
-            if (exitBreak) {
-                const { rules } = exitBreak;
-                for (const rule of rules) {
-                    const { hotkey } = rule, _a = rule.match, _b = _a === void 0 ? {} : _a, { onlyAtEdge = false } = _b, match = tslib.__rest(_b, ["onlyAtEdge"]), { before = false, defaultType = core.PARAGRAPH_TYPE } = rule;
-                    if (isHotkey__default(hotkey, event)
-                        && core.isNodeMatch(entry, match)
-                        && (!onlyAtEdge || core.isSelectionAtBlockEdge(editor))) {
-                        let [, at] = entry;
-                        if (!before) {
-                            at = core.Path.next(at);
-                        }
-                        event.preventDefault();
-                        core.Transforms.insertNodes(editor, { type: defaultType, children: [{ text: '' }] }, {
-                            at,
-                            select: true,
-                        });
-                        return;
-                    }
-                }
-            }
-            if (softBreak) {
-                const { rules } = softBreak;
-                for (const { hotkey, match } of rules) {
-                    if (isHotkey__default(hotkey, event) && (!match || core.isNodeMatch(entry, match))) {
-                        event.preventDefault();
-                        core.insertSoftBreak(editor);
-                        return;
-                    }
-                }
-            }
-        }
-        next();
-    };
+function createOnKeyDownBreak({ exitBreak, softBreak }) {
+    return (event, editor, next) => {
+        const { selection } = editor;
+        if (selection) {
+            /**
+             * Take vscode as reference. Won't delete fragment and only use `selection.focus` as the anchor of exit break.
+             */
+            const entry = core.getAboveBlock(editor, { at: selection.focus });
+            if (exitBreak) {
+                const { rules } = exitBreak;
+                for (const rule of rules) {
+                    const { hotkey } = rule, _a = rule.match, _b = _a === void 0 ? {} : _a, { onlyAtEdge = false } = _b, match = tslib.__rest(_b, ["onlyAtEdge"]), { before = false, defaultType = core.PARAGRAPH_TYPE } = rule;
+                    if (isHotkey(hotkey, event)
+                        && core.isNodeMatch(entry, match)
+                        && (!onlyAtEdge || core.isSelectionAtBlockEdge(editor))) {
+                        let [, at] = entry;
+                        if (!before) {
+                            at = core.Path.next(at);
+                        }
+                        event.preventDefault();
+                        core.Transforms.insertNodes(editor, { type: defaultType, children: [{ text: '' }] }, {
+                            at,
+                            select: true,
+                        });
+                        return;
+                    }
+                }
+            }
+            if (softBreak) {
+                const { rules } = softBreak;
+                for (const { hotkey, match } of rules) {
+                    if (isHotkey(hotkey, event) && (!match || core.isNodeMatch(entry, match))) {
+                        event.preventDefault();
+                        core.insertSoftBreak(editor);
+                        return;
+                    }
+                }
+            }
+        }
+        next();
+    };
 }
 
-const COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = 'mod+enter';
-const COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = 'mod+shift+enter';
-const COMMON_EXIT_BREAK_ON_BEFORE_RULE = {
-    hotkey: COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY,
-};
-const COMMON_EXIT_BREAK_ON_AFTER_RULE = {
-    hotkey: COMMON_EXIT_BREAK_ON_AFTER_HOTKEY,
-    before: true,
-};
-const COMMON_EXIT_BREAK_RULES = [COMMON_EXIT_BREAK_ON_AFTER_RULE, COMMON_EXIT_BREAK_ON_BEFORE_RULE];
-const COMMON_SOFT_BREAK_HOTKEY = 'shift+enter';
-const COMMON_SOFT_BREAK_RULE = {
-    hotkey: COMMON_SOFT_BREAK_HOTKEY,
-};
-/**
- * Common behavior of exit.
- *
- * Using `shift+enter` for soft break and `mod+enter` for exit break.
- */
-const COMMON_ON_KEY_DOWN_BREAK = createOnKeyDownBreak({
-    exitBreak: {
-        rules: COMMON_EXIT_BREAK_RULES,
-    },
-    softBreak: {
-        rules: [COMMON_SOFT_BREAK_RULE],
-    },
+const COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = 'mod+enter';
+const COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = 'mod+shift+enter';
+const COMMON_EXIT_BREAK_ON_BEFORE_RULE = {
+    hotkey: COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY,
+};
+const COMMON_EXIT_BREAK_ON_AFTER_RULE = {
+    hotkey: COMMON_EXIT_BREAK_ON_AFTER_HOTKEY,
+    before: true,
+};
+const COMMON_EXIT_BREAK_RULES = [COMMON_EXIT_BREAK_ON_AFTER_RULE, COMMON_EXIT_BREAK_ON_BEFORE_RULE];
+const COMMON_SOFT_BREAK_HOTKEY = 'shift+enter';
+const COMMON_SOFT_BREAK_RULE = {
+    hotkey: COMMON_SOFT_BREAK_HOTKEY,
+};
+/**
+ * Common behavior of exit.
+ *
+ * Using `shift+enter` for soft break and `mod+enter` for exit break.
+ */
+const COMMON_ON_KEY_DOWN_BREAK = createOnKeyDownBreak({
+    exitBreak: {
+        rules: COMMON_EXIT_BREAK_RULES,
+    },
+    softBreak: {
+        rules: [COMMON_SOFT_BREAK_RULE],
+    },
 });
 
-const defaultRenderLineBreakElement = ({ attributes, children }) => (React__default.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break" }), children));
+const defaultRenderLineBreakElement = ({ attributes, children }) => (React.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break" }), children));
 
-function createReactLineBreak(options = {}) {
-    const core$1 = core.createLineBreak(options);
-    const { type } = core$1;
-    return Object.assign(Object.assign({}, core$1), { createHandlers: () => ({
-            onKeyDown: COMMON_ON_KEY_DOWN_BREAK,
-        }), createRenderElement: ({ render = defaultRenderLineBreakElement } = {}) => react.createRenderElement({ type, render }) });
+function createReactLineBreak(options = {}) {
+    const core$1 = core.createLineBreak(options);
+    const { type } = core$1;
+    return Object.assign(Object.assign({}, core$1), { createHandlers: () => ({
+            onKeyDown: COMMON_ON_KEY_DOWN_BREAK,
+        }), createRenderElement: ({ render = defaultRenderLineBreakElement } = {}) => react.createRenderElement({ type, render }) });
 }
 
-const renderLineBreakElementWithSymbol = ({ attributes, children }) => (React__default.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break qdr-line-break__with-symbol" }), children));
+const renderLineBreakElementWithSymbol = ({ attributes, children }) => (React.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break qdr-line-break__with-symbol" }), children));
 
 exports.COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = COMMON_EXIT_BREAK_ON_AFTER_HOTKEY;
 exports.COMMON_EXIT_BREAK_ON_AFTER_RULE = COMMON_EXIT_BREAK_ON_AFTER_RULE;

package/line-break/jsx-serializer/createJsxSerializeLineBreak.d.ts

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

package/line-break/jsx-serializer/createJsxSerializeLineBreak.js

@@ -2,10 +2,10 @@ import { createJsxSerializeElement } from '@quadrats/react/jsx-serializer';
 import { defaultRenderLineBreakElement } from './defaultRenderLineBreakElement.js';
 import { LINE_BREAK_TYPE } from '@quadrats/core';
 
-/* eslint-disable max-len */
-function createJsxSerializeLineBreak(options = {}) {
-    const { type = LINE_BREAK_TYPE, render = defaultRenderLineBreakElement } = options;
-    return createJsxSerializeElement({ type, render });
+/* eslint-disable max-len */
+function createJsxSerializeLineBreak(options = {}) {
+    const { type = LINE_BREAK_TYPE, render = defaultRenderLineBreakElement } = options;
+    return createJsxSerializeElement({ type, render });
 }
 
 export { createJsxSerializeLineBreak };

package/line-break/jsx-serializer/defaultRenderLineBreakElement.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const defaultRenderLineBreakElement: () => JSX.Element;
+import React from 'react';
+export declare const defaultRenderLineBreakElement: () => React.JSX.Element;

package/line-break/jsx-serializer/defaultRenderLineBreakElement.js

@@ -1,6 +1,6 @@
 import React from 'react';
 
-const defaultRenderLineBreakElement = () => (React.createElement("span", { style: { userSelect: 'none' }, contentEditable: false },
+const defaultRenderLineBreakElement = () => (React.createElement("span", { style: { userSelect: 'none' }, contentEditable: false },
     React.createElement("br", null)));
 
 export { defaultRenderLineBreakElement };

package/line-break/jsx-serializer/index.cjs.js

@@ -1,22 +1,16 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var jsxSerializer = require('@quadrats/react/jsx-serializer');
 var core = require('@quadrats/core');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-const defaultRenderLineBreakElement = () => (React__default.createElement("span", { style: { userSelect: 'none' }, contentEditable: false },
-    React__default.createElement("br", null)));
+const defaultRenderLineBreakElement = () => (React.createElement("span", { style: { userSelect: 'none' }, contentEditable: false },
+    React.createElement("br", null)));
 
-/* eslint-disable max-len */
-function createJsxSerializeLineBreak(options = {}) {
-    const { type = core.LINE_BREAK_TYPE, render = defaultRenderLineBreakElement } = options;
-    return jsxSerializer.createJsxSerializeElement({ type, render });
+/* eslint-disable max-len */
+function createJsxSerializeLineBreak(options = {}) {
+    const { type = core.LINE_BREAK_TYPE, render = defaultRenderLineBreakElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
 }
 
 exports.createJsxSerializeLineBreak = createJsxSerializeLineBreak;

package/line-break/jsx-serializer/typings.d.ts

@@ -1,3 +1,3 @@
 import { LineBreakElement } from '@quadrats/core';
 import { JsxSerializeElementProps } from '@quadrats/react/jsx-serializer';
-export declare type JsxSerializeLineBreakElementProps = JsxSerializeElementProps<LineBreakElement>;
+export type JsxSerializeLineBreakElementProps = JsxSerializeElementProps<LineBreakElement>;

package/line-break/renderLineBreakElementWithSymbol.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="react" />
+import React from 'react';
 import { RenderLineBreakElementProps } from './typings';
-export declare const renderLineBreakElementWithSymbol: ({ attributes, children }: RenderLineBreakElementProps) => JSX.Element;
+export declare const renderLineBreakElementWithSymbol: ({ attributes, children }: RenderLineBreakElementProps) => React.JSX.Element;

package/line-break/typings.d.ts

@@ -24,7 +24,7 @@ export interface SoftBreakRule {
     hotkey: string;
     match?: IsNodeMatchOptions;
 }
-export declare type RenderLineBreakElementProps = RenderElementProps<LineBreakElement>;
+export type RenderLineBreakElementProps = RenderElementProps<LineBreakElement>;
 export interface ReactLineBreakCreateRenderElementOptions {
     render?: (props: RenderLineBreakElementProps) => JSX.Element | null | undefined;
 }

package/link/createReactLink.js

@@ -2,28 +2,28 @@ import { createLink } from '@quadrats/common/link';
 import { createRenderElement } from '@quadrats/react';
 import { defaultRenderLinkElement } from './defaultRenderLinkElement.js';
 
-function createReactLink(options = {}) {
-    const { pastedUrlToLink = true } = options;
-    const core = createLink(options);
-    const { type, isUrl } = core;
-    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderLinkElement } = {}) => createRenderElement({ type, render }), with(editor) {
-            const { insertData, insertText } = editor;
-            editor.insertData = (data) => {
-                const text = data.getData('text/plain');
-                if (text) {
-                    if (core.isSelectionInLink(editor)) {
-                        insertText(text);
-                        return;
-                    }
-                    if (pastedUrlToLink && isUrl(text)) {
-                        core.upsertLink(editor, text);
-                        return;
-                    }
-                }
-                insertData(data);
-            };
-            return core.with(editor);
-        } });
+function createReactLink(options = {}) {
+    const { pastedUrlToLink = true } = options;
+    const core = createLink(options);
+    const { type, isUrl } = core;
+    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderLinkElement } = {}) => createRenderElement({ type, render }), with(editor) {
+            const { insertData, insertText } = editor;
+            editor.insertData = (data) => {
+                const text = data.getData('text/plain');
+                if (text) {
+                    if (core.isSelectionInLink(editor)) {
+                        insertText(text);
+                        return;
+                    }
+                    if (pastedUrlToLink && isUrl(text)) {
+                        core.upsertLink(editor, text);
+                        return;
+                    }
+                }
+                insertData(data);
+            };
+            return core.with(editor);
+        } });
 }
 
 export { createReactLink };