@quadrats/react 0.6.6 → 0.7.0

package/image/jsx-serializer/createJsxSerializeImage.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="react" />
 import { ImageCaptionTypeKey, ImageFigureTypeKey, ImageHostingResolvers, ImageTypeKey } from '@quadrats/common/image';
-import { QuadratsElement } from '@quadrats/core';
 import { CreateJsxSerializeElementOptions } from '@quadrats/react/jsx-serializer';
 import { JsxSerializeImageCaptionElementProps, JsxSerializeImageElementProps, JsxSerializeImageFigureElementProps } from './typings';
-export declare type CreateJsxSerializeImageOptions<H extends string> = Partial<Record<ImageFigureTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageFigureElementProps>>> & Record<ImageTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageElementProps>>> & Record<ImageCaptionTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageCaptionElementProps>>> & {
+export type CreateJsxSerializeImageOptions<H extends string> = Partial<Record<ImageFigureTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageFigureElementProps>>> & Record<ImageTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageElementProps>>> & Record<ImageCaptionTypeKey, Partial<CreateJsxSerializeElementOptions<JsxSerializeImageCaptionElementProps>>> & {
     hostingResolvers?: ImageHostingResolvers<H>;
 }>;
-export declare function createJsxSerializeImage<H extends string>(options?: CreateJsxSerializeImageOptions<H>): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps<QuadratsElement>) => JSX.Element | null | undefined;
+export declare function createJsxSerializeImage<H extends string>(options?: CreateJsxSerializeImageOptions<H>): (props: import("@quadrats/react/jsx-serializer").JsxSerializeElementProps) => JSX.Element | null | undefined;

package/image/jsx-serializer/createJsxSerializeImage.js

@@ -3,40 +3,40 @@ import { IMAGE_TYPES, getImageFigureElementCommonProps, getImageElementCommonPro
 import { createJsxSerializeElements } from '@quadrats/react/jsx-serializer';
 import { defaultRenderImageElements } from './defaultRenderImageElements.js';
 
-function createJsxSerializeImage(options = {}) {
-    const { figure = {}, image = {}, caption = {}, hostingResolvers, } = options;
-    const figureType = figure.type || IMAGE_TYPES.figure;
-    const captionType = caption.type || IMAGE_TYPES.caption;
-    const renderFigure = figure.render || defaultRenderImageElements.figure;
-    const renderImage = image.render || defaultRenderImageElements.image;
-    const renderCaption = caption.render || defaultRenderImageElements.caption;
-    return createJsxSerializeElements([
-        {
-            type: figureType,
-            render: (props) => {
-                const { children } = props;
-                const element = props.element;
-                return renderFigure(Object.assign(Object.assign({}, getImageFigureElementCommonProps(element)), { children,
-                    element }));
-            },
-        },
-        {
-            type: image.type || IMAGE_TYPES.image,
-            render: (props) => {
-                var _a;
-                const { children } = props;
-                const element = props.element;
-                const figure = getFirstAncestor(element, node => node.type === figureType);
-                const caption = (_a = figure === null || figure === void 0 ? void 0 : figure.children) === null || _a === void 0 ? void 0 : _a[1];
-                return renderImage(Object.assign(Object.assign({}, getImageElementCommonProps(element, hostingResolvers)), { caption: (caption === null || caption === void 0 ? void 0 : caption.type) === captionType ? getMergedNodeTexts(caption) : '', children,
-                    element }));
-            },
-        },
-        {
-            type: captionType,
-            render: props => renderCaption(Object.assign(Object.assign({}, props), { isEmpty: !getMergedNodeTexts(props.element) })),
-        },
-    ]);
+function createJsxSerializeImage(options = {}) {
+    const { figure = {}, image = {}, caption = {}, hostingResolvers, } = options;
+    const figureType = figure.type || IMAGE_TYPES.figure;
+    const captionType = caption.type || IMAGE_TYPES.caption;
+    const renderFigure = figure.render || defaultRenderImageElements.figure;
+    const renderImage = image.render || defaultRenderImageElements.image;
+    const renderCaption = caption.render || defaultRenderImageElements.caption;
+    return createJsxSerializeElements([
+        {
+            type: figureType,
+            render: (props) => {
+                const { children } = props;
+                const element = props.element;
+                return renderFigure(Object.assign(Object.assign({}, getImageFigureElementCommonProps(element)), { children,
+                    element }));
+            },
+        },
+        {
+            type: image.type || IMAGE_TYPES.image,
+            render: (props) => {
+                var _a;
+                const { children } = props;
+                const element = props.element;
+                const figure = getFirstAncestor(element, node => node.type === figureType);
+                const caption = (_a = figure === null || figure === void 0 ? void 0 : figure.children) === null || _a === void 0 ? void 0 : _a[1];
+                return renderImage(Object.assign(Object.assign({}, getImageElementCommonProps(element, hostingResolvers)), { caption: (caption === null || caption === void 0 ? void 0 : caption.type) === captionType ? getMergedNodeTexts(caption) : '', children,
+                    element }));
+            },
+        },
+        {
+            type: captionType,
+            render: props => renderCaption(Object.assign(Object.assign({}, props), { isEmpty: !getMergedNodeTexts(props.element) })),
+        },
+    ]);
 }
 
 export { createJsxSerializeImage };

package/image/jsx-serializer/defaultRenderImageElements.js

@@ -1,9 +1,9 @@
 import React from 'react';
 
-const defaultRenderImageElements = {
-    figure: ({ children, style }) => React.createElement("figure", { style: style }, children),
-    image: ({ caption, src }) => React.createElement("img", { src: src, alt: caption, style: { width: '100%' } }),
-    caption: ({ children, isEmpty }) => (isEmpty ? React.createElement("span", null) : React.createElement("figcaption", null, children)),
+const defaultRenderImageElements = {
+    figure: ({ children, style }) => React.createElement("figure", { style: style }, children),
+    image: ({ caption, src }) => React.createElement("img", { src: src, alt: caption, style: { width: '100%' } }),
+    caption: ({ children, isEmpty }) => (isEmpty ? React.createElement("span", null) : React.createElement("figcaption", null, children)),
 };
 
 export { defaultRenderImageElements };

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

@@ -1,56 +1,50 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var React = require('react');
 var serializers = require('@quadrats/core/serializers');
 var image = require('@quadrats/common/image');
 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 defaultRenderImageElements = {
-    figure: ({ children, style }) => React__default.createElement("figure", { style: style }, children),
-    image: ({ caption, src }) => React__default.createElement("img", { src: src, alt: caption, style: { width: '100%' } }),
-    caption: ({ children, isEmpty }) => (isEmpty ? React__default.createElement("span", null) : React__default.createElement("figcaption", null, children)),
+const defaultRenderImageElements = {
+    figure: ({ children, style }) => React.createElement("figure", { style: style }, children),
+    image: ({ caption, src }) => React.createElement("img", { src: src, alt: caption, style: { width: '100%' } }),
+    caption: ({ children, isEmpty }) => (isEmpty ? React.createElement("span", null) : React.createElement("figcaption", null, children)),
 };
 
-function createJsxSerializeImage(options = {}) {
-    const { figure = {}, image: image$1 = {}, caption = {}, hostingResolvers, } = options;
-    const figureType = figure.type || image.IMAGE_TYPES.figure;
-    const captionType = caption.type || image.IMAGE_TYPES.caption;
-    const renderFigure = figure.render || defaultRenderImageElements.figure;
-    const renderImage = image$1.render || defaultRenderImageElements.image;
-    const renderCaption = caption.render || defaultRenderImageElements.caption;
-    return jsxSerializer.createJsxSerializeElements([
-        {
-            type: figureType,
-            render: (props) => {
-                const { children } = props;
-                const element = props.element;
-                return renderFigure(Object.assign(Object.assign({}, image.getImageFigureElementCommonProps(element)), { children,
-                    element }));
-            },
-        },
-        {
-            type: image$1.type || image.IMAGE_TYPES.image,
-            render: (props) => {
-                var _a;
-                const { children } = props;
-                const element = props.element;
-                const figure = serializers.getFirstAncestor(element, node => node.type === figureType);
-                const caption = (_a = figure === null || figure === void 0 ? void 0 : figure.children) === null || _a === void 0 ? void 0 : _a[1];
-                return renderImage(Object.assign(Object.assign({}, image.getImageElementCommonProps(element, hostingResolvers)), { caption: (caption === null || caption === void 0 ? void 0 : caption.type) === captionType ? serializers.getMergedNodeTexts(caption) : '', children,
-                    element }));
-            },
-        },
-        {
-            type: captionType,
-            render: props => renderCaption(Object.assign(Object.assign({}, props), { isEmpty: !serializers.getMergedNodeTexts(props.element) })),
-        },
-    ]);
+function createJsxSerializeImage(options = {}) {
+    const { figure = {}, image: image$1 = {}, caption = {}, hostingResolvers, } = options;
+    const figureType = figure.type || image.IMAGE_TYPES.figure;
+    const captionType = caption.type || image.IMAGE_TYPES.caption;
+    const renderFigure = figure.render || defaultRenderImageElements.figure;
+    const renderImage = image$1.render || defaultRenderImageElements.image;
+    const renderCaption = caption.render || defaultRenderImageElements.caption;
+    return jsxSerializer.createJsxSerializeElements([
+        {
+            type: figureType,
+            render: (props) => {
+                const { children } = props;
+                const element = props.element;
+                return renderFigure(Object.assign(Object.assign({}, image.getImageFigureElementCommonProps(element)), { children,
+                    element }));
+            },
+        },
+        {
+            type: image$1.type || image.IMAGE_TYPES.image,
+            render: (props) => {
+                var _a;
+                const { children } = props;
+                const element = props.element;
+                const figure = serializers.getFirstAncestor(element, node => node.type === figureType);
+                const caption = (_a = figure === null || figure === void 0 ? void 0 : figure.children) === null || _a === void 0 ? void 0 : _a[1];
+                return renderImage(Object.assign(Object.assign({}, image.getImageElementCommonProps(element, hostingResolvers)), { caption: (caption === null || caption === void 0 ? void 0 : caption.type) === captionType ? serializers.getMergedNodeTexts(caption) : '', children,
+                    element }));
+            },
+        },
+        {
+            type: captionType,
+            render: props => renderCaption(Object.assign(Object.assign({}, props), { isEmpty: !serializers.getMergedNodeTexts(props.element) })),
+        },
+    ]);
 }
 
 exports.createJsxSerializeImage = createJsxSerializeImage;

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

@@ -13,4 +13,4 @@ export interface JsxSerializeImageElementProps extends JsxSerializeElementProps<
 export interface JsxSerializeImageCaptionElementProps extends JsxSerializeElementProps<ImageCaptionElement> {
     isEmpty: boolean;
 }
-export declare type ImageJsxSerializeElements = Record<ImageFigureTypeKey, (props: JsxSerializeImageFigureElementProps) => JSX.Element | null | undefined> & Record<ImageTypeKey, (props: JsxSerializeImageElementProps) => JSX.Element | null | undefined> & Record<ImageCaptionTypeKey, (props: JsxSerializeImageCaptionElementProps) => JSX.Element | null | undefined>;
+export type ImageJsxSerializeElements = Record<ImageFigureTypeKey, (props: JsxSerializeImageFigureElementProps) => JSX.Element | null | undefined> & Record<ImageTypeKey, (props: JsxSerializeImageElementProps) => JSX.Element | null | undefined> & Record<ImageCaptionTypeKey, (props: JsxSerializeImageCaptionElementProps) => JSX.Element | null | undefined>;

package/image/typings.d.ts

@@ -10,9 +10,9 @@ export interface RenderImageElementProps extends RenderElementProps<ImageElement
     resizeImage: ReactImage<any>['resizeImage'];
     src: string;
 }
-export declare type RenderImageCaptionElementProps = RenderElementProps<ImageCaptionElement>;
-export declare type ImageRenderElements = Record<ImageFigureTypeKey, (props: RenderImageFigureElementProps) => JSX.Element | null | undefined> & Record<ImageTypeKey, (props: RenderImageElementProps) => JSX.Element | null | undefined> & Record<ImageCaptionTypeKey, (props: RenderImageCaptionElementProps) => JSX.Element | null | undefined>;
-export declare type ReactImageCreateRenderElementOptions = {
+export type RenderImageCaptionElementProps = RenderElementProps<ImageCaptionElement>;
+export type ImageRenderElements = Record<ImageFigureTypeKey, (props: RenderImageFigureElementProps) => JSX.Element | null | undefined> & Record<ImageTypeKey, (props: RenderImageElementProps) => JSX.Element | null | undefined> & Record<ImageCaptionTypeKey, (props: RenderImageCaptionElementProps) => JSX.Element | null | undefined>;
+export type ReactImageCreateRenderElementOptions = {
     [K in ImageFigureTypeKey | ImageTypeKey | ImageCaptionTypeKey]?: ImageRenderElements[K];
 };
 export interface ReactImage<Hosting extends string> extends Omit<Image<Hosting, Editor>, 'with'>, WithCreateHandlers, WithCreateRenderElement<[ReactImageCreateRenderElementOptions?]>, ReactWithable {

package/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var configs = require('@quadrats/react/configs');
 var slateReact = require('slate-react');
 var core = require('@quadrats/core');
@@ -10,130 +8,125 @@ var React = require('react');
 var clsx = require('clsx');
 var _internal = require('@quadrats/react/_internal');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
-
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var clsx__default = /*#__PURE__*/_interopDefaultLegacy(clsx);
-
-const DefaultLeaf = ({ attributes, children }) => React__default.createElement("span", Object.assign({}, attributes), children);
-
-const PLACEHOLDER_KEY = '__quadrats-placeholder__';
-function Editable(props) {
-    const locale = configs.useLocale();
-    const { className, decorate: decorateProp, onCompositionEnd: onCompositionEndProp, onCompositionStart: onCompositionStartProp, placeholder = locale.editor.placeholder, renderLeaf: renderLeafProp, style } = props, slateEditableProps = tslib.__rest(props, ["className", "decorate", "onCompositionEnd", "onCompositionStart", "placeholder", "renderLeaf", "style"]);
-    const { props: themeProps } = configs.useTheme();
-    const editor = slateReact.useSlate();
-    const isEditorEmpty = core.isAncestorEmpty(editor);
-    const [placeholderShowable, setPlaceholderShowable] = React.useState(isEditorEmpty);
-    const decorate = React.useCallback((entry) => {
-        const result = decorateProp ? decorateProp(entry) : [];
-        const [node] = entry;
-        if (isEditorEmpty && core.Editor.isEditor(node)) {
-            const start = core.Editor.start(node, []);
-            result.push({
-                [PLACEHOLDER_KEY]: true,
-                anchor: start,
-                focus: start,
-            });
-        }
-        return result;
-    }, [decorateProp, isEditorEmpty]);
-    const onCompositionEnd = React.useCallback((event) => {
-        onCompositionEndProp === null || onCompositionEndProp === void 0 ? void 0 : onCompositionEndProp(event);
-        setPlaceholderShowable(true);
-    }, [onCompositionEndProp]);
-    const onCompositionStart = React.useCallback((event) => {
-        onCompositionStartProp === null || onCompositionStartProp === void 0 ? void 0 : onCompositionStartProp(event);
-        if (isEditorEmpty) {
-            setPlaceholderShowable(false);
-        }
-    }, [onCompositionStartProp, isEditorEmpty]);
-    const renderLeaf = React.useCallback((props) => {
-        const children = renderLeafProp ? renderLeafProp(props) : React__default.createElement(DefaultLeaf, Object.assign({}, props));
-        const { leaf } = props;
-        if (placeholderShowable && leaf[PLACEHOLDER_KEY]) {
-            return (React__default.createElement(React__default.Fragment, null,
-                React__default.createElement("span", { className: "qdr-editable__placeholder", contentEditable: false }, placeholder),
-                children));
-        }
-        return children;
-    }, [renderLeafProp, placeholder, placeholderShowable]);
-    return (React__default.createElement(slateReact.Editable, Object.assign({}, slateEditableProps, { className: clsx__default('qdr-editable', themeProps.className, className), decorate: decorate, onCompositionStart: onCompositionStart, onCompositionEnd: onCompositionEnd, renderLeaf: renderLeaf, style: Object.assign(Object.assign({}, themeProps.style), style) })));
+const DefaultLeaf = ({ attributes, children }) => React.createElement("span", Object.assign({}, attributes), children);
+
+function Editable(props) {
+    const locale = configs.useLocale();
+    const { className, decorate: decorateProp, onCompositionEnd: onCompositionEndProp, onCompositionStart: onCompositionStartProp, placeholder = locale.editor.placeholder, renderLeaf: renderLeafProp, style } = props, slateEditableProps = tslib.__rest(props, ["className", "decorate", "onCompositionEnd", "onCompositionStart", "placeholder", "renderLeaf", "style"]);
+    const { props: themeProps } = configs.useTheme();
+    const editor = slateReact.useSlate();
+    const isEditorEmpty = core.isAncestorEmpty(editor);
+    const [placeholderShowable, setPlaceholderShowable] = React.useState(isEditorEmpty);
+    const decorate = React.useCallback((entry) => {
+        const result = decorateProp ? decorateProp(entry) : [];
+        const [node] = entry;
+        if (isEditorEmpty && core.Editor.isEditor(node)) {
+            const start = core.Editor.start(node, []);
+            result.push({
+                [PLACEHOLDER_KEY]: true,
+                anchor: start,
+                focus: start,
+            });
+        }
+        return result;
+    }, [decorateProp, isEditorEmpty]);
+    const onCompositionEnd = React.useCallback((event) => {
+        onCompositionEndProp === null || onCompositionEndProp === void 0 ? void 0 : onCompositionEndProp(event);
+        setPlaceholderShowable(true);
+    }, [onCompositionEndProp]);
+    const onCompositionStart = React.useCallback((event) => {
+        onCompositionStartProp === null || onCompositionStartProp === void 0 ? void 0 : onCompositionStartProp(event);
+        if (isEditorEmpty) {
+            setPlaceholderShowable(false);
+        }
+    }, [onCompositionStartProp, isEditorEmpty]);
+    const renderLeaf = React.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(slateReact.Editable, 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) })));
 }
 
-const DefaultElement = ({ attributes, children }) => React__default.createElement("div", Object.assign({}, attributes), children);
+const DefaultElement = ({ attributes, children }) => React.createElement("div", Object.assign({}, attributes), children);
 
-/**
- * Provide configs of quadrats and control the value.
- */
-function Quadrats(props) {
-    const { children, editor, locale, onChange, theme, value, } = props;
-    return (React__default.createElement(configs.ConfigsProvider, { theme: theme, locale: locale },
-        React__default.createElement(slateReact.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(configs.ConfigsProvider, { theme: theme, locale: locale },
+        React.createElement(slateReact.Slate, { editor: editor, onChange: onChange, value: value }, children)));
 }
 
-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;
+    }, {});
 }
 
-/**
- * To compose sequential `renderElement`s to single.
- */
-function composeRenderElements(renderElements) {
-    return _internal.composeRenderElementsBase(props => React__default.createElement(DefaultElement, Object.assign({}, props)), renderElements);
+/**
+ * To compose sequential `renderElement`s to single.
+ */
+function composeRenderElements(renderElements) {
+    return _internal.composeRenderElementsBase(props => React.createElement(DefaultElement, Object.assign({}, props)), renderElements);
 }
 
-/**
- * To compose sequential `renderLeaf`s or `renderMark`s to single.
- */
-function composeRenderLeafs(renderLeafs) {
-    return _internal.composeRenderLeafsBase(props => React__default.createElement(DefaultLeaf, Object.assign({}, props)), renderLeafs);
+/**
+ * To compose sequential `renderLeaf`s or `renderMark`s to single.
+ */
+function composeRenderLeafs(renderLeafs) {
+    return _internal.composeRenderLeafsBase(props => React.createElement(DefaultLeaf, Object.assign({}, props)), renderLeafs);
 }
 
-function createReactEditor() {
-    return slateReact.withReact(core.createEditor());
+function createReactEditor() {
+    return slateReact.withReact(core.createEditor());
 }
 
-function createRenderElement(options) {
-    return _internal.createRenderElementBase(options);
+function createRenderElement(options) {
+    return _internal.createRenderElementBase(options);
 }
 
-function createRenderElements(options) {
-    return _internal.createRenderElementsBase(options);
+function createRenderElements(options) {
+    return _internal.createRenderElementsBase(options);
 }
 
-function createRenderMark(options) {
-    return _internal.createRenderMarkBase(options);
+function createRenderMark(options) {
+    return _internal.createRenderMarkBase(options);
 }
 
+const PLACEHOLDER_KEY = '__quadrats-placeholder__';
+
 exports.ReactEditor = slateReact.ReactEditor;
 exports.useFocused = slateReact.useFocused;
 exports.useQuadrats = slateReact.useSlate;
@@ -144,6 +137,7 @@ exports.Editor = core.Editor;
 exports.DefaultElement = DefaultElement;
 exports.DefaultLeaf = DefaultLeaf;
 exports.Editable = Editable;
+exports.PLACEHOLDER_KEY = PLACEHOLDER_KEY;
 exports.Quadrats = Quadrats;
 exports.composeHandlers = composeHandlers;
 exports.composeRenderElements = composeRenderElements;
@@ -152,6 +146,6 @@ exports.createReactEditor = createReactEditor;
 exports.createRenderElement = createRenderElement;
 exports.createRenderElements = createRenderElements;
 exports.createRenderMark = createRenderMark;
-for (var k in configs) {
+Object.keys(configs).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = configs[k];
-}
+});

package/index.js

@@ -1,10 +1,11 @@
 export * from '@quadrats/react/configs';
-export { ReactEditor, useFocused, useSlate as useQuadrats, useReadOnly, useSelected, useSlateStatic } from 'slate-react';
-export { Editor } from '@quadrats/core';
+export { PLACEHOLDER_KEY } from './core/index.js';
 export { default as Editable } from './core/components/Editable.js';
 export { default as DefaultElement } from './core/components/DefaultElement.js';
 export { default as DefaultLeaf } from './core/components/DefaultLeaf.js';
 export { default as Quadrats } from './core/components/Quadrats.js';
+export { ReactEditor, useFocused, useSlate as useQuadrats, useReadOnly, useSelected, useSlateStatic } from 'slate-react';
+export { Editor } from '@quadrats/core';
 export { composeHandlers } from './core/composeHandlers.js';
 export { composeRenderElements } from './core/composeRenderElements.js';
 export { composeRenderLeafs } from './core/composeRenderLeafs.js';

package/input-block/components/InputBlock.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import React from 'react';
 import { RenderInputBlockElementProps } from '../typings';
-declare function InputBlock(props: RenderInputBlockElementProps): JSX.Element;
+declare function InputBlock(props: RenderInputBlockElementProps): React.JSX.Element;
 export default InputBlock;

package/input-block/components/InputBlock.js

@@ -1,25 +1,25 @@
 import React from 'react';
 import { useInputBlock } from '../hooks/useInputBlock.js';
 
-function InputBlock(props) {
-    const { attributes, children } = props;
-    const { inputRef, onBlur, onKeyDown, placeholder, } = useInputBlock(props);
-    return (React.createElement("div", Object.assign({}, attributes, { contentEditable: false, style: {
-            display: 'flex',
-        }, className: "qdr-input-block" }),
-        React.createElement("input", { ref: inputRef, onBlur: onBlur, onKeyDown: onKeyDown, placeholder: placeholder, style: {
-                display: 'block',
-                color: 'currentColor',
-                font: 'inherit',
-                width: '100%',
-                margin: 0,
-                border: 0,
-                padding: 0,
-                background: 'none',
-                outline: 0,
-                boxSizing: 'border-box',
-            } }),
-        children));
+function InputBlock(props) {
+    const { attributes, children } = props;
+    const { inputRef, onBlur, onKeyDown, placeholder, } = useInputBlock(props);
+    return (React.createElement("div", Object.assign({}, attributes, { contentEditable: false, style: {
+            display: 'flex',
+        }, className: "qdr-input-block" }),
+        React.createElement("input", { ref: inputRef, onBlur: onBlur, onKeyDown: onKeyDown, placeholder: placeholder, style: {
+                display: 'block',
+                color: 'currentColor',
+                font: 'inherit',
+                width: '100%',
+                margin: 0,
+                border: 0,
+                padding: 0,
+                background: 'none',
+                outline: 0,
+                boxSizing: 'border-box',
+            } }),
+        children));
 }
 
 export { InputBlock as default };

package/input-block/createReactInputBlock.d.ts

@@ -1,4 +1,4 @@
 import { CreateInputBlockOptions } from '@quadrats/common/input-block';
 import { ReactInputBlock } from './typings';
-export declare type CreateReactInputBlockOptions = CreateInputBlockOptions;
+export type CreateReactInputBlockOptions = CreateInputBlockOptions;
 export declare function createReactInputBlock(options?: CreateInputBlockOptions): ReactInputBlock;

package/input-block/createReactInputBlock.js

@@ -2,16 +2,16 @@ import { createInputBlock } from '@quadrats/common/input-block';
 import { createRenderElement, ReactEditor } from '@quadrats/react';
 import { defaultRenderInputBlockElement } from './defaultRenderInputBlockElement.js';
 
-function createReactInputBlock(options = {}) {
-    const core = createInputBlock(options);
-    const { type } = core;
-    const remove = (editor, element) => core.remove(editor, [element, ReactEditor.findPath(editor, element)], () => ReactEditor.focus(editor));
-    const confirm = (editor, element, value) => core.confirm(element, value, () => remove(editor, element));
-    return Object.assign(Object.assign({}, core), { remove,
-        confirm, createRenderElement: ({ render = defaultRenderInputBlockElement, } = {}) => createRenderElement({
-            type,
-            render: (props) => render(Object.assign(Object.assign({}, props), { remove, confirm })),
-        }) });
+function createReactInputBlock(options = {}) {
+    const core = createInputBlock(options);
+    const { type } = core;
+    const remove = (editor, element) => core.remove(editor, [element, ReactEditor.findPath(editor, element)], () => ReactEditor.focus(editor));
+    const confirm = (editor, element, value) => core.confirm(element, value, () => remove(editor, element));
+    return Object.assign(Object.assign({}, core), { remove,
+        confirm, createRenderElement: ({ render = defaultRenderInputBlockElement, } = {}) => createRenderElement({
+            type,
+            render: (props) => render(Object.assign(Object.assign({}, props), { remove, confirm })),
+        }) });
 }
 
 export { createReactInputBlock };