@quadrats/react 0.6.7 → 0.7.1

package/core/components/DefaultLeaf.d.ts

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

package/core/components/Editable.d.ts

@@ -1,9 +1,9 @@
-/// <reference types="react" />
+import React from 'react';
 import { EditableProps as SlateEditableProps } from 'slate-react/dist/components/editable';
 import { RenderElementProps, RenderLeafProps } from '../typings/renderer';
-export declare type EditableProps = Omit<SlateEditableProps, 'renderLeaf' | 'renderElement'> & {
+export type EditableProps = Omit<SlateEditableProps, 'renderLeaf' | 'renderElement'> & {
     renderLeaf?: (props: RenderLeafProps) => JSX.Element;
     renderElement?: (props: RenderElementProps) => JSX.Element;
 };
-declare function Editable(props: EditableProps): JSX.Element;
+declare function Editable(props: EditableProps): React.JSX.Element;
 export default Editable;

package/core/components/Editable.js

@@ -5,49 +5,48 @@ import clsx from 'clsx';
 import { isAncestorEmpty, Editor } from '@quadrats/core';
 import { useLocale, useTheme } from '@quadrats/react/configs';
 import DefaultLeaf from './DefaultLeaf.js';
+import { PLACEHOLDER_KEY } from '../index.js';
 
-const PLACEHOLDER_KEY = '__quadrats-placeholder__';
-function Editable(props) {
-    const locale = useLocale();
-    const { className, decorate: decorateProp, onCompositionEnd: onCompositionEndProp, onCompositionStart: onCompositionStartProp, placeholder = locale.editor.placeholder, renderLeaf: renderLeafProp, style } = props, slateEditableProps = __rest(props, ["className", "decorate", "onCompositionEnd", "onCompositionStart", "placeholder", "renderLeaf", "style"]);
-    const { props: themeProps } = useTheme();
-    const editor = useSlate();
-    const isEditorEmpty = isAncestorEmpty(editor);
-    const [placeholderShowable, setPlaceholderShowable] = useState(isEditorEmpty);
-    const decorate = useCallback((entry) => {
-        const result = decorateProp ? decorateProp(entry) : [];
-        const [node] = entry;
-        if (isEditorEmpty && Editor.isEditor(node)) {
-            const start = Editor.start(node, []);
-            result.push({
-                [PLACEHOLDER_KEY]: true,
-                anchor: start,
-                focus: start,
-            });
-        }
-        return result;
-    }, [decorateProp, isEditorEmpty]);
-    const onCompositionEnd = useCallback((event) => {
-        onCompositionEndProp === null || onCompositionEndProp === void 0 ? void 0 : onCompositionEndProp(event);
-        setPlaceholderShowable(true);
-    }, [onCompositionEndProp]);
-    const onCompositionStart = useCallback((event) => {
-        onCompositionStartProp === null || onCompositionStartProp === void 0 ? void 0 : onCompositionStartProp(event);
-        if (isEditorEmpty) {
-            setPlaceholderShowable(false);
-        }
-    }, [onCompositionStartProp, isEditorEmpty]);
-    const renderLeaf = useCallback((props) => {
-        const children = renderLeafProp ? renderLeafProp(props) : React.createElement(DefaultLeaf, Object.assign({}, props));
-        const { leaf } = props;
-        if (placeholderShowable && leaf[PLACEHOLDER_KEY]) {
-            return (React.createElement(React.Fragment, null,
-                React.createElement("span", { className: "qdr-editable__placeholder", contentEditable: false }, placeholder),
-                children));
-        }
-        return children;
-    }, [renderLeafProp, placeholder, placeholderShowable]);
-    return (React.createElement(Editable$1, Object.assign({}, slateEditableProps, { className: clsx('qdr-editable', themeProps.className, className), decorate: decorate, onCompositionStart: onCompositionStart, onCompositionEnd: onCompositionEnd, renderLeaf: renderLeaf, style: Object.assign(Object.assign({}, themeProps.style), style) })));
+function Editable(props) {
+    const locale = useLocale();
+    const { className, decorate: decorateProp, onCompositionEnd: onCompositionEndProp, onCompositionStart: onCompositionStartProp, placeholder = locale.editor.placeholder, renderLeaf: renderLeafProp, style } = props, slateEditableProps = __rest(props, ["className", "decorate", "onCompositionEnd", "onCompositionStart", "placeholder", "renderLeaf", "style"]);
+    const { props: themeProps } = useTheme();
+    const editor = useSlate();
+    const isEditorEmpty = isAncestorEmpty(editor);
+    const [placeholderShowable, setPlaceholderShowable] = useState(isEditorEmpty);
+    const decorate = useCallback((entry) => {
+        const result = decorateProp ? decorateProp(entry) : [];
+        const [node] = entry;
+        if (isEditorEmpty && Editor.isEditor(node)) {
+            const start = Editor.start(node, []);
+            result.push({
+                [PLACEHOLDER_KEY]: true,
+                anchor: start,
+                focus: start,
+            });
+        }
+        return result;
+    }, [decorateProp, isEditorEmpty]);
+    const onCompositionEnd = useCallback((event) => {
+        onCompositionEndProp === null || onCompositionEndProp === void 0 ? void 0 : onCompositionEndProp(event);
+        setPlaceholderShowable(true);
+    }, [onCompositionEndProp]);
+    const onCompositionStart = useCallback((event) => {
+        onCompositionStartProp === null || onCompositionStartProp === void 0 ? void 0 : onCompositionStartProp(event);
+        if (isEditorEmpty) {
+            setPlaceholderShowable(false);
+        }
+    }, [onCompositionStartProp, isEditorEmpty]);
+    const renderLeaf = useCallback((props) => {
+        const children = renderLeafProp ? renderLeafProp(props) : React.createElement(DefaultLeaf, Object.assign({}, props));
+        if (placeholderShowable && props.leaf[PLACEHOLDER_KEY]) {
+            return (React.createElement(React.Fragment, null,
+                React.createElement("span", { className: "qdr-editable__placeholder", contentEditable: false }, placeholder),
+                children));
+        }
+        return children;
+    }, [renderLeafProp, placeholder, placeholderShowable]);
+    return (React.createElement(Editable$1, Object.assign({}, slateEditableProps, { className: clsx('qdr-editable', themeProps.className, className), decorate: decorate, onCompositionStart: onCompositionStart, onCompositionEnd: onCompositionEnd, renderLeaf: renderLeaf, style: Object.assign(Object.assign({}, themeProps.style), style) })));
 }
 
 export { Editable as default };

package/core/components/Quadrats.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="react" />
+import React from 'react';
 import { Slate } from 'slate-react';
 import { ConfigsProviderProps } from '@quadrats/react/configs';
 import { Descendant } from '..';
-export declare type QuadratsProps = Pick<Parameters<typeof Slate>[0], 'children' | 'editor'> & Omit<ConfigsProviderProps, 'children'> & {
+export type QuadratsProps = Pick<Parameters<typeof Slate>[0], 'children' | 'editor'> & Omit<ConfigsProviderProps, 'children'> & {
     onChange: (value: Descendant[]) => void;
     value: Descendant[];
 };
 /**
  * Provide configs of quadrats and control the value.
  */
-declare function Quadrats(props: QuadratsProps): JSX.Element;
+declare function Quadrats(props: QuadratsProps): React.JSX.Element;
 export default Quadrats;

package/core/components/Quadrats.js

@@ -2,13 +2,13 @@ import React from 'react';
 import { Slate } from 'slate-react';
 import { ConfigsProvider } from '@quadrats/react/configs';
 
-/**
- * Provide configs of quadrats and control the value.
- */
-function Quadrats(props) {
-    const { children, editor, locale, onChange, theme, value, } = props;
-    return (React.createElement(ConfigsProvider, { theme: theme, locale: locale },
-        React.createElement(Slate, { editor: editor, onChange: onChange, value: value }, children)));
+/**
+ * Provide configs of quadrats and control the value.
+ */
+function Quadrats(props) {
+    const { children, editor, locale, onChange, theme, value, } = props;
+    return (React.createElement(ConfigsProvider, { theme: theme, locale: locale },
+        React.createElement(Slate, { editor: editor, onChange: onChange, value: value }, children)));
 }
 
 export { Quadrats as default };

package/core/composeHandlers.js

@@ -1,33 +1,33 @@
-function createEventHandler(editor, handlers) {
-    const [handler, ...restHandlers] = handlers;
-    return event => handler(event, editor, () => {
-        const next = restHandlers.length > 0 ? createEventHandler(editor, restHandlers) : () => { };
-        next(event);
-    });
-}
-/**
- * To compose sequential `event handlers` to single for each event types.
- */
-function composeHandlers(handlersList) {
-    const handlersListRecord = handlersList.reduce((acc, handlers) => {
-        Object.entries(handlers).forEach(([key, value]) => {
-            const name = key;
-            const handler = value;
-            const origin = acc[name];
-            if (origin) {
-                origin.push(handler);
-            }
-            else {
-                acc[name] = [handler];
-            }
-        });
-        return acc;
-    }, {});
-    const handlersEntries = Object.entries(handlersListRecord);
-    return editor => handlersEntries.reduce((acc, [name, handlers]) => {
-        acc[name] = createEventHandler(editor, handlers);
-        return acc;
-    }, {});
+function createEventHandler(editor, handlers) {
+    const [handler, ...restHandlers] = handlers;
+    return event => handler(event, editor, () => {
+        const next = restHandlers.length > 0 ? createEventHandler(editor, restHandlers) : () => { };
+        next(event);
+    });
+}
+/**
+ * To compose sequential `event handlers` to single for each event types.
+ */
+function composeHandlers(handlersList) {
+    const handlersListRecord = handlersList.reduce((acc, handlers) => {
+        Object.entries(handlers).forEach(([key, value]) => {
+            const name = key;
+            const handler = value;
+            const origin = acc[name];
+            if (origin) {
+                origin.push(handler);
+            }
+            else {
+                acc[name] = [handler];
+            }
+        });
+        return acc;
+    }, {});
+    const handlersEntries = Object.entries(handlersListRecord);
+    return editor => handlersEntries.reduce((acc, [name, handlers]) => {
+        acc[name] = createEventHandler(editor, handlers);
+        return acc;
+    }, {});
 }
 
 export { composeHandlers };

package/core/composeRenderElements.d.ts

@@ -3,4 +3,4 @@ import { RenderElementProps } from './typings/renderer';
 /**
  * To compose sequential `renderElement`s to single.
  */
-export declare function composeRenderElements(renderElements: ((props: RenderElementProps) => JSX.Element | null | undefined)[]): (props: RenderElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element;
+export declare function composeRenderElements(renderElements: ((props: RenderElementProps) => JSX.Element | null | undefined)[]): (props: RenderElementProps) => JSX.Element;

package/core/composeRenderElements.js

@@ -2,11 +2,11 @@ import React from 'react';
 import { composeRenderElementsBase } from '@quadrats/react/_internal';
 import DefaultElement from './components/DefaultElement.js';
 
-/**
- * To compose sequential `renderElement`s to single.
- */
-function composeRenderElements(renderElements) {
-    return composeRenderElementsBase(props => React.createElement(DefaultElement, Object.assign({}, props)), renderElements);
+/**
+ * To compose sequential `renderElement`s to single.
+ */
+function composeRenderElements(renderElements) {
+    return composeRenderElementsBase(props => React.createElement(DefaultElement, Object.assign({}, props)), renderElements);
 }
 
 export { composeRenderElements };

package/core/composeRenderLeafs.js

@@ -2,11 +2,11 @@ import React from 'react';
 import { composeRenderLeafsBase } from '@quadrats/react/_internal';
 import DefaultLeaf from './components/DefaultLeaf.js';
 
-/**
- * To compose sequential `renderLeaf`s or `renderMark`s to single.
- */
-function composeRenderLeafs(renderLeafs) {
-    return composeRenderLeafsBase(props => React.createElement(DefaultLeaf, Object.assign({}, props)), renderLeafs);
+/**
+ * To compose sequential `renderLeaf`s or `renderMark`s to single.
+ */
+function composeRenderLeafs(renderLeafs) {
+    return composeRenderLeafsBase(props => React.createElement(DefaultLeaf, Object.assign({}, props)), renderLeafs);
 }
 
 export { composeRenderLeafs };

package/core/createReactEditor.js

@@ -1,8 +1,8 @@
 import { withReact } from 'slate-react';
 import { createEditor } from '@quadrats/core';
 
-function createReactEditor() {
-    return withReact(createEditor());
+function createReactEditor() {
+    return withReact(createEditor());
 }
 
 export { createReactEditor };

package/core/createRenderElement.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="react" />
 import { CreateRenderElementOptions, RenderElementProps } from './typings/renderer';
-export declare function createRenderElement<P extends RenderElementProps>(options: CreateRenderElementOptions<P>): (props: RenderElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element | null | undefined;
+export declare function createRenderElement<P extends RenderElementProps>(options: CreateRenderElementOptions<P>): (props: RenderElementProps) => JSX.Element | null | undefined;

package/core/createRenderElement.js

@@ -1,7 +1,7 @@
 import { createRenderElementBase } from '@quadrats/react/_internal';
 
-function createRenderElement(options) {
-    return createRenderElementBase(options);
+function createRenderElement(options) {
+    return createRenderElementBase(options);
 }
 
 export { createRenderElement };

package/core/createRenderElements.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="react" />
 import { CreateRenderElementOptions, RenderElementProps } from './typings/renderer';
-export declare function createRenderElements<P extends RenderElementProps>(options: CreateRenderElementOptions<P>[]): (props: RenderElementProps<import("@quadrats/core").QuadratsElement>) => JSX.Element | null | undefined;
+export declare function createRenderElements<P extends RenderElementProps>(options: CreateRenderElementOptions<P>[]): (props: RenderElementProps) => JSX.Element | null | undefined;

package/core/createRenderElements.js

@@ -1,7 +1,7 @@
 import { createRenderElementsBase } from '@quadrats/react/_internal';
 
-function createRenderElements(options) {
-    return createRenderElementsBase(options);
+function createRenderElements(options) {
+    return createRenderElementsBase(options);
 }
 
 export { createRenderElements };

package/core/createRenderMark.js

@@ -1,7 +1,7 @@
 import { createRenderMarkBase } from '@quadrats/react/_internal';
 
-function createRenderMark(options) {
-    return createRenderMarkBase(options);
+function createRenderMark(options) {
+    return createRenderMarkBase(options);
 }
 
 export { createRenderMark };

package/core/index.d.ts

@@ -1,11 +1,11 @@
 import { QuadratsEditor, QuadratsElement, QuadratsText } from '@quadrats/core';
 import { ReactEditor } from 'slate-react';
 export { useSlateStatic, useFocused, useReadOnly, useSelected, useSlate as useQuadrats, ReactEditor, } from 'slate-react';
-export { Editor } from '@quadrats/core';
 export * from './typings/handler';
 export * from './typings/renderer';
 export * from './typings/with';
 export * from './typings/descendant';
+export { Editor } from '@quadrats/core';
 export { default as Editable, EditableProps } from './components/Editable';
 export { default as DefaultElement } from './components/DefaultElement';
 export { default as DefaultLeaf } from './components/DefaultLeaf';
@@ -17,12 +17,14 @@ export { createReactEditor } from './createReactEditor';
 export { createRenderElement } from './createRenderElement';
 export { createRenderElements } from './createRenderElements';
 export { createRenderMark } from './createRenderMark';
-export interface QuadratsReactEditor extends QuadratsEditor, ReactEditor {
-}
+export type QuadratsReactEditor = QuadratsEditor & ReactEditor;
+export declare const PLACEHOLDER_KEY = "__quadrats-placeholder__";
 declare module '@quadrats/core' {
     interface CustomTypes {
         Editor: QuadratsReactEditor;
         Element: QuadratsElement;
-        Text: QuadratsText;
+        Text: QuadratsText & {
+            [PLACEHOLDER_KEY]?: boolean;
+        };
     }
 }

package/core/index.js

@@ -0,0 +1,11 @@
+export { ReactEditor, useFocused, useSlate as useQuadrats, useReadOnly, useSelected, useSlateStatic } from 'slate-react';
+export { Editor } from '@quadrats/core';
+import 'tslib';
+import 'react';
+import 'clsx';
+import '@quadrats/react/configs';
+import '@quadrats/react/_internal';
+
+const PLACEHOLDER_KEY = '__quadrats-placeholder__';
+
+export { PLACEHOLDER_KEY };

package/core/typings/descendant.d.ts

@@ -1,2 +1,2 @@
 import { QuadratsElement, QuadratsText } from '@quadrats/core';
-export declare type Descendant = QuadratsElement | QuadratsText;
+export type Descendant = QuadratsElement | QuadratsText;

package/core/typings/handler.d.ts

@@ -1,13 +1,13 @@
-import { Editor } from '@quadrats/core';
+import { Editor } from 'slate';
 import { DOMAttributes, EventHandler } from 'react';
-export declare type EventHandlerName = {
+export type EventHandlerName = {
     [K in keyof Required<DOMAttributes<HTMLElement>>]: NonNullable<DOMAttributes<HTMLElement>[K]> extends EventHandler<any> ? K : never;
 }[keyof DOMAttributes<HTMLElement>];
-export declare type EventHandlers = Pick<DOMAttributes<HTMLElement>, EventHandlerName>;
-export declare type GetEventHandlerByName<H extends EventHandlerName> = NonNullable<EventHandlers[H]>;
-export declare type GetEventByName<H extends EventHandlerName> = GetEventHandlerByName<H> extends (event: infer E) => void ? E : never;
-export declare type Handler<H extends EventHandlerName> = (event: GetEventByName<H>, editor: Editor, next: VoidFunction) => void;
-export declare type Handlers = {
+export type EventHandlers = Pick<DOMAttributes<HTMLElement>, EventHandlerName>;
+export type GetEventHandlerByName<H extends EventHandlerName> = NonNullable<EventHandlers[H]>;
+export type GetEventByName<H extends EventHandlerName> = GetEventHandlerByName<H> extends (event: infer E) => void ? E : never;
+export type Handler<H extends EventHandlerName> = (event: GetEventByName<H>, editor: Editor, next: VoidFunction) => void;
+export type Handlers = {
     [H in EventHandlerName]?: Handler<H>;
 };
 export interface WithCreateHandlers<P extends any[] = []> {

package/core/typings/renderer.d.ts

@@ -2,11 +2,11 @@
 import { RenderElementProps as SlateReactRenderElementProps, RenderLeafProps as SlateRenderLeafProps } from 'slate-react';
 import { QuadratsElement } from '@quadrats/core';
 import { CreateRenderElementOptionsBase, CreateRenderMarkOptionsBase, RenderElementPropsBase, RenderLeafPropsBase, RenderMarkPropsBase } from '@quadrats/react/_internal';
-export declare type RenderLeafProps = RenderLeafPropsBase & Pick<SlateRenderLeafProps, 'attributes'>;
-export declare type RenderMarkProps<M> = RenderMarkPropsBase<M>;
-export declare type RenderElementProps<E extends QuadratsElement = QuadratsElement> = RenderElementPropsBase<E> & Pick<SlateReactRenderElementProps, 'attributes'>;
-export declare type CreateRenderMarkOptions<M> = CreateRenderMarkOptionsBase<M, RenderMarkProps<M>>;
-export declare type CreateRenderElementOptions<P extends RenderElementProps<QuadratsElement>> = CreateRenderElementOptionsBase<P>;
+export type RenderLeafProps = RenderLeafPropsBase & Pick<SlateRenderLeafProps, 'attributes'>;
+export type RenderMarkProps<M> = RenderMarkPropsBase<M>;
+export type RenderElementProps<E extends QuadratsElement = QuadratsElement> = RenderElementPropsBase<E> & Pick<SlateReactRenderElementProps, 'attributes'>;
+export type CreateRenderMarkOptions<M> = CreateRenderMarkOptionsBase<M, RenderMarkProps<M>>;
+export type CreateRenderElementOptions<P extends RenderElementProps<QuadratsElement>> = CreateRenderElementOptionsBase<P>;
 export interface WithCreateRenderLeaf<P extends any[] = []> {
     createRenderLeaf: (...params: P) => (props: RenderLeafProps) => JSX.Element;
 }

package/core/typings/with.d.ts

@@ -1,4 +1,4 @@
-import { QuadratsReactEditor } from '..';
+import { Editor } from 'slate';
 export interface ReactWithable<R = undefined> {
-    with: <T extends QuadratsReactEditor>(editor: T) => R extends undefined ? T : T & R;
+    with: <T extends Editor>(editor: T) => R extends undefined ? T : T & R;
 }

package/divider/createReactDivider.d.ts

@@ -1,4 +1,4 @@
 import { CreateDividerOptions } from '@quadrats/common/divider';
 import { ReactDivider } from './typings';
-export declare type CreateReactDividerOptions = CreateDividerOptions;
+export type CreateReactDividerOptions = CreateDividerOptions;
 export declare function createReactDivider(options?: CreateReactDividerOptions): ReactDivider;

package/divider/createReactDivider.js

@@ -2,10 +2,10 @@ import { createDivider } from '@quadrats/common/divider';
 import { createRenderElement } from '@quadrats/react';
 import { defaultRenderDividerElement } from './defaultRenderDividerElement.js';
 
-function createReactDivider(options = {}) {
-    const core = createDivider(options);
-    const { type } = core;
-    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderDividerElement } = {}) => createRenderElement({ type, render }) });
+function createReactDivider(options = {}) {
+    const core = createDivider(options);
+    const { type } = core;
+    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderDividerElement } = {}) => createRenderElement({ type, render }) });
 }
 
 export { createReactDivider };

package/divider/defaultRenderDividerElement.d.ts

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

package/divider/defaultRenderDividerElement.js

@@ -1,7 +1,7 @@
 import React from 'react';
 
-const defaultRenderDividerElement = ({ attributes, children }) => (React.createElement("div", Object.assign({}, attributes, { className: "qdr-divider", contentEditable: false }),
-    React.createElement("hr", null),
+const defaultRenderDividerElement = ({ attributes, children }) => (React.createElement("div", Object.assign({}, attributes, { className: "qdr-divider", contentEditable: false }),
+    React.createElement("hr", null),
     children));
 
 export { defaultRenderDividerElement };

package/divider/index.cjs.js

@@ -1,23 +1,17 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var divider = require('@quadrats/common/divider');
 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 defaultRenderDividerElement = ({ attributes, children }) => (React__default.createElement("div", Object.assign({}, attributes, { className: "qdr-divider", contentEditable: false }),
-    React__default.createElement("hr", null),
+const defaultRenderDividerElement = ({ attributes, children }) => (React.createElement("div", Object.assign({}, attributes, { className: "qdr-divider", contentEditable: false }),
+    React.createElement("hr", null),
     children));
 
-function createReactDivider(options = {}) {
-    const core = divider.createDivider(options);
-    const { type } = core;
-    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderDividerElement } = {}) => react.createRenderElement({ type, render }) });
+function createReactDivider(options = {}) {
+    const core = divider.createDivider(options);
+    const { type } = core;
+    return Object.assign(Object.assign({}, core), { createRenderElement: ({ render = defaultRenderDividerElement } = {}) => react.createRenderElement({ type, render }) });
 }
 
 exports.createReactDivider = createReactDivider;

package/divider/jsx-serializer/createJsxSerializeDivider.d.ts

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

package/divider/jsx-serializer/createJsxSerializeDivider.js

@@ -2,9 +2,9 @@ import { DIVIDER_TYPE } from '@quadrats/common/divider';
 import { createJsxSerializeElement } from '@quadrats/react/jsx-serializer';
 import { defaultRenderDividerElement } from './defaultRenderDividerElement.js';
 
-function createJsxSerializeDivider(options = {}) {
-    const { type = DIVIDER_TYPE, render = defaultRenderDividerElement } = options;
-    return createJsxSerializeElement({ type, render });
+function createJsxSerializeDivider(options = {}) {
+    const { type = DIVIDER_TYPE, render = defaultRenderDividerElement } = options;
+    return createJsxSerializeElement({ type, render });
 }
 
 export { createJsxSerializeDivider };

package/divider/jsx-serializer/defaultRenderDividerElement.d.ts

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

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

@@ -1,20 +1,14 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var divider = require('@quadrats/common/divider');
 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 defaultRenderDividerElement = () => React__default.createElement("hr", null);
+const defaultRenderDividerElement = () => React.createElement("hr", null);
 
-function createJsxSerializeDivider(options = {}) {
-    const { type = divider.DIVIDER_TYPE, render = defaultRenderDividerElement } = options;
-    return jsxSerializer.createJsxSerializeElement({ type, render });
+function createJsxSerializeDivider(options = {}) {
+    const { type = divider.DIVIDER_TYPE, render = defaultRenderDividerElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
 }
 
 exports.createJsxSerializeDivider = createJsxSerializeDivider;

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

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

package/divider/toolbar/DividerToolbarIcon.d.ts

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

package/divider/toolbar/DividerToolbarIcon.js

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