@quadrats/react 0.6.7 → 0.7.1

package/link/defaultRenderLinkElement.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { RenderLinkElementProps } from './typings';
 /**
  * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
@@ -6,4 +6,4 @@ import { RenderLinkElementProps } from './typings';
 export declare const defaultRenderLinkElement: ({ attributes, children, element, placement, target, }: import("@quadrats/react/_internal").RenderElementPropsBase<import("@quadrats/common/link").LinkElement> & Pick<import("slate-react").RenderElementProps, "attributes"> & {
     placement?: "top" | "bottom" | undefined;
     target?: string | undefined;
-}) => JSX.Element;
+}) => React.JSX.Element;

package/link/defaultRenderLinkElement.js

@@ -1,13 +1,13 @@
 import React from 'react';
 import { Tooltip } from '@quadrats/react/components';
 
-/**
- * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
- */
-const defaultRenderLinkElement = ({ attributes, children, element, placement = 'bottom', target = '_blank', }) => {
-    const { url } = element;
-    return (React.createElement(Tooltip, { placement: placement, popup: url },
-        React.createElement("a", Object.assign({}, attributes, { className: "qdr-link", href: url, target: target }), children)));
+/**
+ * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
+ */
+const defaultRenderLinkElement = ({ attributes, children, element, placement = 'bottom', target = '_blank', }) => {
+    const { url } = element;
+    return (React.createElement(Tooltip, { placement: placement, popup: url },
+        React.createElement("a", Object.assign({}, attributes, { className: "qdr-link", href: url, target: target }), children)));
 };
 
 export { defaultRenderLinkElement };

package/link/index.cjs.js

@@ -1,47 +1,41 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var components = require('@quadrats/react/components');
 var link = require('@quadrats/common/link');
 var react = require('@quadrats/react');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-/**
- * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
- */
-const defaultRenderLinkElement = ({ attributes, children, element, placement = 'bottom', target = '_blank', }) => {
-    const { url } = element;
-    return (React__default.createElement(components.Tooltip, { placement: placement, popup: url },
-        React__default.createElement("a", Object.assign({}, attributes, { className: "qdr-link", href: url, target: target }), children)));
+/**
+ * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
+ */
+const defaultRenderLinkElement = ({ attributes, children, element, placement = 'bottom', target = '_blank', }) => {
+    const { url } = element;
+    return (React.createElement(components.Tooltip, { placement: placement, popup: url },
+        React.createElement("a", Object.assign({}, attributes, { className: "qdr-link", href: url, target: target }), children)));
 };
 
-function createReactLink(options = {}) {
-    const { pastedUrlToLink = true } = options;
-    const core = link.createLink(options);
-    const { type, isUrl } = core;
-    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderLinkElement } = {}) => react.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 = link.createLink(options);
+    const { type, isUrl } = core;
+    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderLinkElement } = {}) => react.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);
+        } });
 }
 
 exports.createReactLink = createReactLink;

package/link/jsx-serializer/createJsxSerializeLink.d.ts

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

package/link/jsx-serializer/createJsxSerializeLink.js

@@ -2,9 +2,9 @@ import { LINK_TYPE } from '@quadrats/common/link';
 import { createJsxSerializeElement } from '@quadrats/react/jsx-serializer';
 import { defaultRenderLinkElement } from './defaultRenderLinkElement.js';
 
-function createJsxSerializeLink(options = {}) {
-    const { type = LINK_TYPE, render = defaultRenderLinkElement } = options;
-    return createJsxSerializeElement({ type, render });
+function createJsxSerializeLink(options = {}) {
+    const { type = LINK_TYPE, render = defaultRenderLinkElement } = options;
+    return createJsxSerializeElement({ type, render });
 }
 
 export { createJsxSerializeLink };

package/link/jsx-serializer/defaultRenderLinkElement.d.ts

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

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

@@ -1,20 +1,14 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var link = require('@quadrats/common/link');
 var jsxSerializer = require('@quadrats/react/jsx-serializer');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-const defaultRenderLinkElement = ({ children, element }) => (React__default.createElement("a", { target: "_blank", href: element.url }, children));
+const defaultRenderLinkElement = ({ children, element }) => (React.createElement("a", { target: "_blank", href: element.url }, children));
 
-function createJsxSerializeLink(options = {}) {
-    const { type = link.LINK_TYPE, render = defaultRenderLinkElement } = options;
-    return jsxSerializer.createJsxSerializeElement({ type, render });
+function createJsxSerializeLink(options = {}) {
+    const { type = link.LINK_TYPE, render = defaultRenderLinkElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
 }
 
 exports.createJsxSerializeLink = createJsxSerializeLink;

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

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

package/link/toolbar/LinkToolbarIcon.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
 import { ReactLink } from '@quadrats/react/link';
 import { UseLinkToolOptions } from './useLinkTool';
@@ -6,5 +6,5 @@ export interface LinkToolbarIconProps extends Omit<ToolbarIconProps, 'active' |
     controller: ReactLink;
     options?: UseLinkToolOptions;
 }
-declare function LinkToolbarIcon(props: LinkToolbarIconProps): JSX.Element;
+declare function LinkToolbarIcon(props: LinkToolbarIconProps): React.JSX.Element;
 export default LinkToolbarIcon;

package/link/toolbar/LinkToolbarIcon.js

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

package/link/toolbar/UnlinkToolbarIcon.d.ts

@@ -1,8 +1,8 @@
-/// <reference types="react" />
+import React from 'react';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
 import { ReactLink } from '@quadrats/react/link';
 export interface UnlinkToolbarIconProps extends Omit<ToolbarIconProps, 'active' | 'onClick'> {
     controller: ReactLink;
 }
-declare function UnlinkToolbarIcon(props: UnlinkToolbarIconProps): JSX.Element;
+declare function UnlinkToolbarIcon(props: UnlinkToolbarIconProps): React.JSX.Element;
 export default UnlinkToolbarIcon;

package/link/toolbar/UnlinkToolbarIcon.js

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

package/link/toolbar/index.cjs.js

@@ -1,49 +1,43 @@
 '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 useLinkTool(controller, options = {}) {
-    const editor = react.useQuadrats();
-    const startToolInput = toolbar.useStartToolInput();
-    return {
-        active: controller.isSelectionInLink(editor),
-        onClick: () => startToolInput({
-            getPlaceholder: (locale) => locale.editor.link.inputPlaceholder,
-            confirm: (url) => {
-                if (controller.isUrl(url)) {
-                    controller.upsertLink(editor, url, options);
-                }
-            },
-        }),
-    };
+function useLinkTool(controller, options = {}) {
+    const editor = react.useQuadrats();
+    const startToolInput = toolbar.useStartToolInput();
+    return {
+        active: controller.isSelectionInLink(editor),
+        onClick: () => startToolInput({
+            getPlaceholder: (locale) => locale.editor.link.inputPlaceholder,
+            confirm: (url) => {
+                if (controller.isUrl(url)) {
+                    controller.upsertLink(editor, url, options);
+                }
+            },
+        }),
+    };
 }
 
-function useUnlinkTool(controller) {
-    const editor = react.useSlateStatic();
-    return {
-        onClick: () => controller.unwrapLink(editor),
-    };
+function useUnlinkTool(controller) {
+    const editor = react.useSlateStatic();
+    return {
+        onClick: () => controller.unwrapLink(editor),
+    };
 }
 
-function LinkToolbarIcon(props) {
-    const { controller, options = {} } = props, rest = tslib.__rest(props, ["controller", "options"]);
-    const { active, onClick } = useLinkTool(controller, options);
-    return React__default.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
+function LinkToolbarIcon(props) {
+    const { controller, options = {} } = props, rest = tslib.__rest(props, ["controller", "options"]);
+    const { active, onClick } = useLinkTool(controller, options);
+    return React.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { active: active, onClick: onClick }));
 }
 
-function UnlinkToolbarIcon(props) {
-    const { controller } = props, rest = tslib.__rest(props, ["controller"]);
-    const { onClick } = useUnlinkTool(controller);
-    return React__default.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { onClick: onClick }));
+function UnlinkToolbarIcon(props) {
+    const { controller } = props, rest = tslib.__rest(props, ["controller"]);
+    const { onClick } = useUnlinkTool(controller);
+    return React.createElement(toolbar.ToolbarIcon, Object.assign({}, rest, { onClick: onClick }));
 }
 
 exports.LinkToolbarIcon = LinkToolbarIcon;

package/link/toolbar/useLinkTool.d.ts

@@ -1,6 +1,6 @@
 import { LinkUpsertLinkOptions } from '@quadrats/common/link';
 import { ReactLink } from '@quadrats/react/link';
-export declare type UseLinkToolOptions = LinkUpsertLinkOptions;
+export type UseLinkToolOptions = LinkUpsertLinkOptions;
 export declare function useLinkTool(controller: ReactLink, options?: UseLinkToolOptions): {
     active: boolean;
     onClick: () => void;

package/link/toolbar/useLinkTool.js

@@ -1,20 +1,20 @@
 import { useQuadrats } from '@quadrats/react';
 import { useStartToolInput } from '@quadrats/react/toolbar';
 
-function useLinkTool(controller, options = {}) {
-    const editor = useQuadrats();
-    const startToolInput = useStartToolInput();
-    return {
-        active: controller.isSelectionInLink(editor),
-        onClick: () => startToolInput({
-            getPlaceholder: (locale) => locale.editor.link.inputPlaceholder,
-            confirm: (url) => {
-                if (controller.isUrl(url)) {
-                    controller.upsertLink(editor, url, options);
-                }
-            },
-        }),
-    };
+function useLinkTool(controller, options = {}) {
+    const editor = useQuadrats();
+    const startToolInput = useStartToolInput();
+    return {
+        active: controller.isSelectionInLink(editor),
+        onClick: () => startToolInput({
+            getPlaceholder: (locale) => locale.editor.link.inputPlaceholder,
+            confirm: (url) => {
+                if (controller.isUrl(url)) {
+                    controller.upsertLink(editor, url, options);
+                }
+            },
+        }),
+    };
 }
 
 export { useLinkTool };

package/link/toolbar/useUnlinkTool.js

@@ -1,10 +1,10 @@
 import { useSlateStatic } from '@quadrats/react';
 
-function useUnlinkTool(controller) {
-    const editor = useSlateStatic();
-    return {
-        onClick: () => controller.unwrapLink(editor),
-    };
+function useUnlinkTool(controller) {
+    const editor = useSlateStatic();
+    return {
+        onClick: () => controller.unwrapLink(editor),
+    };
 }
 
 export { useUnlinkTool };

package/link/typings.d.ts

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

package/list/createReactList.d.ts

@@ -1,4 +1,4 @@
 import { CreateListOptions } from '@quadrats/common/list';
 import { ReactList } from './typings';
-export declare type CreateReactListOptions = CreateListOptions;
+export type CreateReactListOptions = CreateListOptions;
 export declare function createReactList(options?: CreateReactListOptions): ReactList;

package/list/createReactList.js

@@ -2,24 +2,24 @@ import { createList } from '@quadrats/common/list';
 import { createRenderElements } from '@quadrats/react';
 import { defaultRenderListElements } from './defaultRenderListElements.js';
 
-function createReactList(options = {}) {
-    const core = createList(options);
-    return Object.assign(Object.assign({}, core), { createRenderElement: (options = {}) => createRenderElements(['ol', 'ul', 'li'].map(key => ({
-            type: core.types[key],
-            render: options[key] || defaultRenderListElements[key],
-        }))), createHandlers: () => ({
-            onKeyDown: (event, editor, next) => {
-                if (event.key === 'Tab') {
-                    const entries = core.getAboveListAndItem(editor);
-                    if (entries) {
-                        event.preventDefault();
-                        (event.shiftKey ? core.decreaseListItemDepth : core.increaseListItemDepth)(editor, entries);
-                        return;
-                    }
-                }
-                next();
-            },
-        }) });
+function createReactList(options = {}) {
+    const core = createList(options);
+    return Object.assign(Object.assign({}, core), { createRenderElement: (options = {}) => createRenderElements(['ol', 'ul', 'li'].map(key => ({
+            type: core.types[key],
+            render: options[key] || defaultRenderListElements[key],
+        }))), createHandlers: () => ({
+            onKeyDown: (event, editor, next) => {
+                if (event.key === 'Tab') {
+                    const entries = core.getAboveListAndItem(editor);
+                    if (entries) {
+                        event.preventDefault();
+                        (event.shiftKey ? core.decreaseListItemDepth : core.increaseListItemDepth)(editor, entries);
+                        return;
+                    }
+                }
+                next();
+            },
+        }) });
 }
 
 export { createReactList };

package/list/defaultRenderListElements.js

@@ -1,9 +1,9 @@
 import React from 'react';
 
-const defaultRenderListElements = {
-    ol: ({ attributes, children }) => React.createElement("ol", Object.assign({}, attributes, { className: "qdr-ol" }), children),
-    ul: ({ attributes, children }) => React.createElement("ul", Object.assign({}, attributes, { className: "qdr-ul" }), children),
-    li: ({ attributes, children }) => React.createElement("li", Object.assign({}, attributes, { className: "qdr-li" }), children),
+const defaultRenderListElements = {
+    ol: ({ attributes, children }) => React.createElement("ol", Object.assign({}, attributes, { className: "qdr-ol" }), children),
+    ul: ({ attributes, children }) => React.createElement("ul", Object.assign({}, attributes, { className: "qdr-ul" }), children),
+    li: ({ attributes, children }) => React.createElement("li", Object.assign({}, attributes, { className: "qdr-li" }), children),
 };
 
 export { defaultRenderListElements };

package/list/index.cjs.js

@@ -1,39 +1,33 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var list = require('@quadrats/common/list');
 var react = require('@quadrats/react');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-const defaultRenderListElements = {
-    ol: ({ attributes, children }) => React__default.createElement("ol", Object.assign({}, attributes, { className: "qdr-ol" }), children),
-    ul: ({ attributes, children }) => React__default.createElement("ul", Object.assign({}, attributes, { className: "qdr-ul" }), children),
-    li: ({ attributes, children }) => React__default.createElement("li", Object.assign({}, attributes, { className: "qdr-li" }), children),
+const defaultRenderListElements = {
+    ol: ({ attributes, children }) => React.createElement("ol", Object.assign({}, attributes, { className: "qdr-ol" }), children),
+    ul: ({ attributes, children }) => React.createElement("ul", Object.assign({}, attributes, { className: "qdr-ul" }), children),
+    li: ({ attributes, children }) => React.createElement("li", Object.assign({}, attributes, { className: "qdr-li" }), children),
 };
 
-function createReactList(options = {}) {
-    const core = list.createList(options);
-    return Object.assign(Object.assign({}, core), { createRenderElement: (options = {}) => react.createRenderElements(['ol', 'ul', 'li'].map(key => ({
-            type: core.types[key],
-            render: options[key] || defaultRenderListElements[key],
-        }))), createHandlers: () => ({
-            onKeyDown: (event, editor, next) => {
-                if (event.key === 'Tab') {
-                    const entries = core.getAboveListAndItem(editor);
-                    if (entries) {
-                        event.preventDefault();
-                        (event.shiftKey ? core.decreaseListItemDepth : core.increaseListItemDepth)(editor, entries);
-                        return;
-                    }
-                }
-                next();
-            },
-        }) });
+function createReactList(options = {}) {
+    const core = list.createList(options);
+    return Object.assign(Object.assign({}, core), { createRenderElement: (options = {}) => react.createRenderElements(['ol', 'ul', 'li'].map(key => ({
+            type: core.types[key],
+            render: options[key] || defaultRenderListElements[key],
+        }))), createHandlers: () => ({
+            onKeyDown: (event, editor, next) => {
+                if (event.key === 'Tab') {
+                    const entries = core.getAboveListAndItem(editor);
+                    if (entries) {
+                        event.preventDefault();
+                        (event.shiftKey ? core.decreaseListItemDepth : core.increaseListItemDepth)(editor, entries);
+                        return;
+                    }
+                }
+                next();
+            },
+        }) });
 }
 
 exports.createReactList = createReactList;

package/list/jsx-serializer/createJsxSerializeList.d.ts

@@ -2,7 +2,7 @@
 import { ListTypeKey } from '@quadrats/common/list';
 import { CreateJsxSerializeElementOptions } from '@quadrats/react/jsx-serializer';
 import { JsxSerializeListElementProps } from './typings';
-export declare type CreateJsxSerializeListOptions = {
+export type CreateJsxSerializeListOptions = {
     [key in ListTypeKey]?: CreateJsxSerializeElementOptions<JsxSerializeListElementProps>;
 };
-export declare function createJsxSerializeList(options?: CreateJsxSerializeListOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element | null | undefined;
+export declare function createJsxSerializeList(options?: CreateJsxSerializeListOptions): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps) => JSX.Element | null | undefined;

package/list/jsx-serializer/createJsxSerializeList.js

@@ -2,14 +2,14 @@ import { LIST_TYPES } from '@quadrats/common/list';
 import { createJsxSerializeElements } from '@quadrats/react/jsx-serializer';
 import { defaultRenderListElements } from '@quadrats/react/list';
 
-function createJsxSerializeList(options = {}) {
-    return createJsxSerializeElements(['ol', 'ul', 'li'].map((key) => {
-        const { type = LIST_TYPES[key], render = defaultRenderListElements[key] } = options[key] || {};
-        return {
-            type,
-            render,
-        };
-    }));
+function createJsxSerializeList(options = {}) {
+    return createJsxSerializeElements(['ol', 'ul', 'li'].map((key) => {
+        const { type = LIST_TYPES[key], render = defaultRenderListElements[key] } = options[key] || {};
+        return {
+            type,
+            render,
+        };
+    }));
 }
 
 export { createJsxSerializeList };

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

@@ -1,19 +1,17 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var list = require('@quadrats/react/list');
 var list$1 = require('@quadrats/common/list');
 var jsxSerializer = require('@quadrats/react/jsx-serializer');
 
-function createJsxSerializeList(options = {}) {
-    return jsxSerializer.createJsxSerializeElements(['ol', 'ul', 'li'].map((key) => {
-        const { type = list$1.LIST_TYPES[key], render = list.defaultRenderListElements[key] } = options[key] || {};
-        return {
-            type,
-            render,
-        };
-    }));
+function createJsxSerializeList(options = {}) {
+    return jsxSerializer.createJsxSerializeElements(['ol', 'ul', 'li'].map((key) => {
+        const { type = list$1.LIST_TYPES[key], render = list.defaultRenderListElements[key] } = options[key] || {};
+        return {
+            type,
+            render,
+        };
+    }));
 }
 
 exports.defaultRenderListElements = list.defaultRenderListElements;

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

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

package/list/toolbar/ListToolbarIcon.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { ListRootTypeKey } from '@quadrats/common/list';
 import { ToolbarIconProps } from '@quadrats/react/toolbar';
 import { ReactList } from '@quadrats/react/list';
@@ -6,5 +6,5 @@ export interface ListToolbarIconProps extends Omit<ToolbarIconProps, 'active' |
     controller: ReactList;
     listTypeKey: ListRootTypeKey;
 }
-declare function ListToolbarIcon(props: ListToolbarIconProps): JSX.Element;
+declare function ListToolbarIcon(props: ListToolbarIconProps): React.JSX.Element;
 export default ListToolbarIcon;

package/list/toolbar/ListToolbarIcon.js

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