@quadrats/react 1.1.8 → 1.1.10

package/jsx-serializer/index.js

@@ -0,0 +1,4 @@
+export { createJsxSerializeElement } from './createJsxSerializeElement.js';
+export { createJsxSerializeElements } from './createJsxSerializeElements.js';
+export { createJsxSerializeMark } from './createJsxSerializeMark.js';
+export { createJsxSerializer } from './createJsxSerializer.js';

package/jsx-serializer/package.json

@@ -1,9 +1,7 @@
 {
   "name": "@quadrats/react/jsx-serializer",
   "sideEffects": false,
-  "quadratsConfig": {
-    "deps": [
-      "_internal"
-    ]
-  }
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
 }

package/jsx-serializer/typings.d.ts

@@ -0,0 +1,8 @@
+import { QuadratsElement } from '@quadrats/core';
+import { WithElementParent } from '@quadrats/core/serializers';
+import { CreateRenderElementOptionsBase, CreateRenderMarkOptionsBase, RenderElementPropsBase, RenderLeafPropsBase, RenderMarkPropsBase } from '@quadrats/react/_internal';
+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.d.ts

@@ -0,0 +1,14 @@
+import { ExitBreakRule, SoftBreakRule } from './typings';
+export declare const COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = "mod+enter";
+export declare const COMMON_EXIT_BREAK_ON_AFTER_HOTKEY = "mod+shift+enter";
+export declare const COMMON_EXIT_BREAK_ON_BEFORE_RULE: ExitBreakRule;
+export declare const COMMON_EXIT_BREAK_ON_AFTER_RULE: ExitBreakRule;
+export declare const COMMON_EXIT_BREAK_RULES: ExitBreakRule[];
+export declare const COMMON_SOFT_BREAK_HOTKEY = "shift+enter";
+export declare const COMMON_SOFT_BREAK_RULE: SoftBreakRule;
+/**
+ * Common behavior of exit.
+ *
+ * Using `shift+enter` for soft break and `mod+enter` for exit break.
+ */
+export declare const COMMON_ON_KEY_DOWN_BREAK: import("@quadrats/react").Handler<"onKeyDown">;

package/line-break/commonBreak.js

@@ -0,0 +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],
+    },
+});
+
+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.d.ts

@@ -0,0 +1,11 @@
+import { Handler } from '@quadrats/react';
+import { ExitBreakRule, SoftBreakRule } from './typings';
+export interface CreateOnKeyDownBreakOptions {
+    exitBreak?: {
+        rules: ExitBreakRule[];
+    };
+    softBreak?: {
+        rules: SoftBreakRule[];
+    };
+}
+export declare function createOnKeyDownBreak({ exitBreak, softBreak }: CreateOnKeyDownBreakOptions): Handler<'onKeyDown'>;

package/line-break/createOnKeyDownBreak.js

@@ -0,0 +1,48 @@
+import { __rest } from 'tslib';
+import isHotkey from 'is-hotkey';
+import { getAboveBlock, PARAGRAPH_TYPE, isNodeMatch, isSelectionAtBlockEdge, Path, Transforms } 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();
+                        editor.insertText('\n');
+                        return;
+                    }
+                }
+            }
+        }
+        next();
+    };
+}
+
+export { createOnKeyDownBreak };

package/line-break/createReactLineBreak.d.ts

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

package/line-break/createReactLineBreak.js

@@ -0,0 +1,14 @@
+import { createLineBreak } from '@quadrats/core';
+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 }) });
+}
+
+export { createReactLineBreak };

package/line-break/defaultRenderLineBreakElement.d.ts

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

package/line-break/defaultRenderLineBreakElement.js

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const defaultRenderLineBreakElement = ({ attributes, children }) => (React.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break" }), children));
+
+export { defaultRenderLineBreakElement };

package/line-break/index.cjs.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var tslib = require('tslib');
+var isHotkey = require('is-hotkey');
+var core = require('@quadrats/core');
+var react = require('@quadrats/react');
+var React = require('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(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();
+                        editor.insertText('\n');
+                        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 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 }) });
+}
+
+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;
+exports.COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY = COMMON_EXIT_BREAK_ON_BEFORE_HOTKEY;
+exports.COMMON_EXIT_BREAK_ON_BEFORE_RULE = COMMON_EXIT_BREAK_ON_BEFORE_RULE;
+exports.COMMON_EXIT_BREAK_RULES = COMMON_EXIT_BREAK_RULES;
+exports.COMMON_ON_KEY_DOWN_BREAK = COMMON_ON_KEY_DOWN_BREAK;
+exports.COMMON_SOFT_BREAK_HOTKEY = COMMON_SOFT_BREAK_HOTKEY;
+exports.COMMON_SOFT_BREAK_RULE = COMMON_SOFT_BREAK_RULE;
+exports.createOnKeyDownBreak = createOnKeyDownBreak;
+exports.createReactLineBreak = createReactLineBreak;
+exports.renderLineBreakElementWithSymbol = renderLineBreakElementWithSymbol;

package/line-break/index.js

@@ -0,0 +1,4 @@
+export { createOnKeyDownBreak } from './createOnKeyDownBreak.js';
+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 } from './commonBreak.js';
+export { createReactLineBreak } from './createReactLineBreak.js';
+export { renderLineBreakElementWithSymbol } from './renderLineBreakElementWithSymbol.js';

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

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

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

@@ -0,0 +1,11 @@
+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 });
+}
+
+export { createJsxSerializeLineBreak };

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

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

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

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

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

@@ -0,0 +1,17 @@
+'use strict';
+
+var React = require('react');
+var jsxSerializer = require('@quadrats/react/jsx-serializer');
+var core = require('@quadrats/core');
+
+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 });
+}
+
+exports.createJsxSerializeLineBreak = createJsxSerializeLineBreak;
+exports.defaultRenderLineBreakElement = defaultRenderLineBreakElement;

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

@@ -0,0 +1,2 @@
+export { defaultRenderLineBreakElement } from './defaultRenderLineBreakElement.js';
+export { createJsxSerializeLineBreak } from './createJsxSerializeLineBreak.js';

package/line-break/jsx-serializer/package.json

@@ -1,10 +1,7 @@
 {
   "name": "@quadrats/react/line-break/jsx-serializer",
   "sideEffects": false,
-  "quadratsConfig": {
-    "deps": [
-      "jsx-serializer",
-      "line-break"
-    ]
-  }
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
 }

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

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

package/line-break/line-break.css

@@ -0,0 +1 @@
+.qdr-line-break__with-symbol{position:relative}.qdr-line-break__with-symbol::after{content:"";display:block;width:16px;height:16px;background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAACXBIWXMAABYlAAAWJQFJUiTwAAAAxElEQVRoge2ZwQlCMRBEZ2xAS7ADLeGXklJSiiVpB5agFax8iCAfxMsuY2Ae7CWEzD42p4QRgZnZTd29Bf4AC6ixgBoLqLGAmjIBkp1kjOpVOZ6AGguosYAaC6ixgBoLqLGAGguomV4g9XWa5BXA6ce2W0Sc0zKTBQ4A7gD2X7Y8ARwj4pGVmXqFRmPLaHTLurZkNv8OTS8AbT16U60kq+LQIdE/BHpVTukXE8nLmHIry/AfmRgLqLGAGguosYAaC0gB8ALxmTRWAs9XmwAAAABJRU5ErkJggg==");background-size:16px;background-position:center;background-repeat:no-repeat;position:absolute;right:-16px;top:0;opacity:.5}

package/line-break/package.json

@@ -4,12 +4,7 @@
     "**/*.css",
     "**/*.scss"
   ],
-  "quadratsConfig": {
-    "deps": [
-      "__ROOT__"
-    ],
-    "styles": {
-      "line-break": "line-break"
-    }
-  }
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
 }

package/line-break/renderLineBreakElementWithSymbol.d.ts

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

package/line-break/renderLineBreakElementWithSymbol.js

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const renderLineBreakElementWithSymbol = ({ attributes, children }) => (React.createElement("span", Object.assign({}, attributes, { className: "qdr-line-break qdr-line-break__with-symbol" }), children));
+
+export { renderLineBreakElementWithSymbol };

package/line-break/typings.d.ts

@@ -0,0 +1,32 @@
+import { JSX } from 'react';
+import { IsNodeMatchOptions, LineBreak, LineBreakElement } from '@quadrats/core';
+import { WithCreateRenderElement, RenderElementProps, WithCreateHandlers } from '@quadrats/react';
+export interface ExitBreakRule {
+    hotkey: string;
+    /**
+     * @default ParagraphType
+     */
+    defaultType?: string;
+    match?: IsNodeMatchOptions & {
+        /**
+         * Only match at if selection on edge of block.
+         * @default false
+         */
+        onlyAtEdge?: boolean;
+    };
+    /**
+     * Exit before the selected block if true.
+     * @default false
+     */
+    before?: boolean;
+}
+export interface SoftBreakRule {
+    hotkey: string;
+    match?: IsNodeMatchOptions;
+}
+export type RenderLineBreakElementProps = RenderElementProps<LineBreakElement>;
+export interface ReactLineBreakCreateRenderElementOptions {
+    render?: (props: RenderLineBreakElementProps) => JSX.Element | null | undefined;
+}
+export interface ReactBreak extends LineBreak, WithCreateHandlers, WithCreateRenderElement<[ReactLineBreakCreateRenderElementOptions?]> {
+}

package/link/createReactLink.d.ts

@@ -0,0 +1,11 @@
+import { CreateLinkOptions } from '@quadrats/common/link';
+import { ReactLink } from './typings';
+export interface CreateReactLinkOptions extends CreateLinkOptions {
+    /**
+     * If `true`, transform pasted url text to link.
+     *
+     * @default true
+     */
+    pastedUrlToLink?: boolean;
+}
+export declare function createReactLink(options?: CreateReactLinkOptions): ReactLink;

package/link/createReactLink.js

@@ -0,0 +1,29 @@
+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);
+        } });
+}
+
+export { createReactLink };

package/link/defaultRenderLinkElement.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { RenderLinkElementProps } from './typings';
+/**
+ * Set placement of tooltip to `bottom` to avoid conflicting w/ toolbar.
+ */
+export declare const defaultRenderLinkElement: ({ attributes, children, element, placement, target, }: RenderLinkElementProps & {
+    placement?: "top" | "bottom";
+    target?: string;
+}) => React.JSX.Element;

package/link/defaultRenderLinkElement.js

@@ -0,0 +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)));
+};
+
+export { defaultRenderLinkElement };

package/link/index.cjs.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var React = require('react');
+var components = require('@quadrats/react/components');
+var link = require('@quadrats/common/link');
+var react = require('@quadrats/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.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);
+        } });
+}
+
+exports.createReactLink = createReactLink;
+exports.defaultRenderLinkElement = defaultRenderLinkElement;

package/link/index.js

@@ -0,0 +1,2 @@
+export { defaultRenderLinkElement } from './defaultRenderLinkElement.js';
+export { createReactLink } from './createReactLink.js';

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

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

package/link/jsx-serializer/createJsxSerializeLink.js

@@ -0,0 +1,10 @@
+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 });
+}
+
+export { createJsxSerializeLink };

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

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

package/link/jsx-serializer/defaultRenderLinkElement.js

@@ -0,0 +1,5 @@
+import React from 'react';
+
+const defaultRenderLinkElement = ({ children, element }) => (React.createElement("a", { target: "_blank", className: "qdr-link", href: element.url }, children));
+
+export { defaultRenderLinkElement };

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

@@ -0,0 +1,15 @@
+'use strict';
+
+var React = require('react');
+var link = require('@quadrats/common/link');
+var jsxSerializer = require('@quadrats/react/jsx-serializer');
+
+const defaultRenderLinkElement = ({ children, element }) => (React.createElement("a", { target: "_blank", className: "qdr-link", href: element.url }, children));
+
+function createJsxSerializeLink(options = {}) {
+    const { type = link.LINK_TYPE, render = defaultRenderLinkElement } = options;
+    return jsxSerializer.createJsxSerializeElement({ type, render });
+}
+
+exports.createJsxSerializeLink = createJsxSerializeLink;
+exports.defaultRenderLinkElement = defaultRenderLinkElement;

package/link/jsx-serializer/index.js

@@ -0,0 +1,2 @@
+export { defaultRenderLinkElement } from './defaultRenderLinkElement.js';
+export { createJsxSerializeLink } from './createJsxSerializeLink.js';

package/link/jsx-serializer/package.json

@@ -1,10 +1,7 @@
 {
   "name": "@quadrats/react/link/jsx-serializer",
   "sideEffects": false,
-  "quadratsConfig": {
-    "deps": [
-      "jsx-serializer",
-      "link"
-    ]
-  }
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
 }

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

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

package/link/package.json

@@ -1,9 +1,7 @@
 {
   "name": "@quadrats/react/link",
   "sideEffects": false,
-  "quadratsConfig": {
-    "deps": [
-      "__ROOT__"
-    ]
-  }
+  "main": "./index.cjs.js",
+  "module": "./index.js",
+  "typings": "./index.d.ts"
 }

package/link/toolbar/LinkToolbarIcon.d.ts

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