@payloadcms/richtext-lexical 0.1.0-beta.0

package/dist/field/features/Blocks/plugin/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    INSERT_BLOCK_COMMAND: function() {
+        return INSERT_BLOCK_COMMAND;
+    },
+    BlocksPlugin: function() {
+        return BlocksPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _drawer = require("../drawer");
+const _BlocksNode = require("../nodes/BlocksNode");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const INSERT_BLOCK_COMMAND = (0, _lexical.createCommand)('INSERT_BLOCK_COMMAND');
+function BlocksPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _BlocksNode.BlockNode
+        ])) {
+            throw new Error('BlocksPlugin: BlocksNode not registered on editor');
+        }
+        return (0, _utils.mergeRegister)(editor.registerCommand(INSERT_BLOCK_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const uploadNode = (0, _BlocksNode.$createBlockNode)(payload);
+                (0, _utils.$insertNodeToNearestRoot)(uploadNode);
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_drawer.BlocksDrawerComponent, null);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Heading/index.d.ts

@@ -0,0 +1,8 @@
+import type { HeadingTagType } from '@lexical/rich-text';
+import type { FeatureProvider } from '../types';
+type Props = {
+    enabledHeadingSizes?: HeadingTagType[];
+};
+export declare const HeadingFeature: (props: Props) => FeatureProvider;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Heading/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Heading/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAOxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAmB/C,KAAK,KAAK,GAAG;IACX,mBAAmB,CAAC,EAAE,cAAc,EAAE,CAAA;CACvC,CAAA;AAWD,eAAO,MAAM,cAAc,UAAW,KAAK,KAAG,eAmD7C,CAAA"}

package/dist/field/features/Heading/index.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HeadingFeature", {
+    enumerable: true,
+    get: function() {
+        return HeadingFeature;
+    }
+});
+const _richtext = require("@lexical/rich-text");
+const _selection = require("@lexical/selection");
+const _lexical = require("lexical");
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _H1 = require("../../lexical/ui/icons/H1");
+const _H2 = require("../../lexical/ui/icons/H2");
+const _H3 = require("../../lexical/ui/icons/H3");
+const _H4 = require("../../lexical/ui/icons/H4");
+const _H5 = require("../../lexical/ui/icons/H5");
+const _H6 = require("../../lexical/ui/icons/H6");
+const _floatingSelectToolbarTextDropdownSection = require("../common/floatingSelectToolbarTextDropdownSection");
+const _markdownTransformer = require("./markdownTransformer");
+const setHeading = (editor, headingSize)=>{
+    const selection = (0, _lexical.$getSelection)();
+    if ((0, _lexical.$isRangeSelection)(selection) || (0, _lexical.DEPRECATED_$isGridSelection)(selection)) {
+        (0, _selection.$setBlocksType)(selection, ()=>(0, _richtext.$createHeadingNode)(headingSize));
+    }
+};
+const HeadingToIconMap = {
+    h1: _H1.H1Icon,
+    h2: _H2.H2Icon,
+    h3: _H3.H3Icon,
+    h4: _H4.H4Icon,
+    h5: _H5.H5Icon,
+    h6: _H6.H6Icon
+};
+const HeadingFeature = (props)=>{
+    const { enabledHeadingSizes = [
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6'
+    ] } = props;
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                floatingSelectToolbar: {
+                    sections: [
+                        ...enabledHeadingSizes.map((headingSize, i)=>(0, _floatingSelectToolbarTextDropdownSection.TextDropdownSectionWithEntries)([
+                                {
+                                    ChildComponent: HeadingToIconMap[headingSize],
+                                    isActive: ({ editor, selection })=>false,
+                                    key: headingSize,
+                                    label: `Heading ${headingSize.charAt(1)}`,
+                                    onClick: ({ editor })=>{
+                                        editor.update(()=>{
+                                            setHeading(editor, headingSize);
+                                        });
+                                    },
+                                    order: i + 2
+                                }
+                            ]))
+                    ]
+                },
+                markdownTransformers: [
+                    _markdownTransformer.MarkdownTransformer
+                ],
+                nodes: [
+                    {
+                        node: _richtext.HeadingNode,
+                        type: _richtext.HeadingNode.getType()
+                    }
+                ],
+                props,
+                slashMenu: {
+                    options: [
+                        ...enabledHeadingSizes.map((headingSize)=>{
+                            return {
+                                options: [
+                                    new _LexicalMenu.SlashMenuOption(`Heading ${headingSize.charAt(1)}`, {
+                                        Icon: HeadingToIconMap[headingSize],
+                                        keywords: [
+                                            'heading',
+                                            headingSize
+                                        ],
+                                        onSelect: ({ editor })=>{
+                                            setHeading(editor, headingSize);
+                                        }
+                                    })
+                                ],
+                                title: 'Basic'
+                            };
+                        })
+                    ]
+                }
+            };
+        },
+        key: 'heading'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Heading/markdownTransformer.d.ts

@@ -0,0 +1,3 @@
+import type { ElementTransformer } from '@lexical/markdown';
+export declare const MarkdownTransformer: ElementTransformer;
+//# sourceMappingURL=markdownTransformer.d.ts.map

package/dist/field/features/Heading/markdownTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Heading/markdownTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAO3D,eAAO,MAAM,mBAAmB,EAAE,kBAejC,CAAA"}

package/dist/field/features/Heading/markdownTransformer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MarkdownTransformer", {
+    enumerable: true,
+    get: function() {
+        return MarkdownTransformer;
+    }
+});
+const _richtext = require("@lexical/rich-text");
+const _createBlockNode = require("../../lexical/utils/markdown/createBlockNode");
+const MarkdownTransformer = {
+    dependencies: [
+        _richtext.HeadingNode
+    ],
+    export: (node, exportChildren)=>{
+        if (!(0, _richtext.$isHeadingNode)(node)) {
+            return null;
+        }
+        const level = Number(node.getTag().slice(1));
+        return '#'.repeat(level) + ' ' + exportChildren(node);
+    },
+    regExp: /^(#{1,6})\s/,
+    replace: (0, _createBlockNode.createBlockNode)((match)=>{
+        const tag = 'h' + match[1].length;
+        return (0, _richtext.$createHeadingNode)(tag);
+    }),
+    type: 'element'
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Link/afterReadPromise.d.ts

@@ -0,0 +1,5 @@
+import type { LinkFeatureProps } from '.';
+import type { AfterReadPromise } from '../types';
+import type { SerializedLinkNode } from './nodes/LinkNode';
+export declare const linkAfterReadPromiseHOC: (props: LinkFeatureProps) => AfterReadPromise<SerializedLinkNode>;
+//# sourceMappingURL=afterReadPromise.d.ts.map

package/dist/field/features/Link/afterReadPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"afterReadPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Link/afterReadPromise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,GAAG,CAAA;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAK1D,eAAO,MAAM,uBAAuB,UAC3B,gBAAgB,KACtB,iBAAiB,kBAAkB,CAkDrC,CAAA"}

package/dist/field/features/Link/afterReadPromise.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "linkAfterReadPromiseHOC", {
+    enumerable: true,
+    get: function() {
+        return linkAfterReadPromiseHOC;
+    }
+});
+const _populate = require("../../../populate/populate");
+const _recurseNestedFields = require("../../../populate/recurseNestedFields");
+const linkAfterReadPromiseHOC = (props)=>{
+    const linkAfterReadPromise = ({ afterReadPromises, currentDepth, depth, field, node, overrideAccess, req, showHiddenFields })=>{
+        const promises = [];
+        if (node?.fields?.doc?.value && node?.fields?.doc?.relationTo) {
+            const collection = req.payload.collections[node?.fields?.doc?.relationTo];
+            if (collection) {
+                promises.push((0, _populate.populate)({
+                    id: node?.fields?.doc.value,
+                    collection,
+                    currentDepth,
+                    data: node?.fields?.doc,
+                    depth,
+                    field,
+                    key: 'value',
+                    overrideAccess,
+                    req,
+                    showHiddenFields
+                }));
+            }
+        }
+        if (Array.isArray(props.fields)) {
+            (0, _recurseNestedFields.recurseNestedFields)({
+                afterReadPromises,
+                currentDepth,
+                data: node.fields || {},
+                depth,
+                fields: props.fields,
+                overrideAccess,
+                promises,
+                req,
+                showHiddenFields
+            });
+        }
+        return promises;
+    };
+    return linkAfterReadPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Link/drawer/baseFields.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from 'payload/config';
+import type { Field } from 'payload/types';
+export declare const getBaseFields: (config: Config) => Field[];
+//# sourceMappingURL=baseFields.d.ts.map

package/dist/field/features/Link/drawer/baseFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseFields.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Link/drawer/baseFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAe1C,eAAO,MAAM,aAAa,WAAY,MAAM,KAAG,KAAK,EAqEnD,CAAA"}

package/dist/field/features/Link/drawer/baseFields.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBaseFields", {
+    enumerable: true,
+    get: function() {
+        return getBaseFields;
+    }
+});
+const _utilities = require("payload/utilities");
+const translations = (0, _utilities.extractTranslations)([
+    'fields:textToDisplay',
+    'fields:linkType',
+    'fields:chooseBetweenCustomTextOrDocument',
+    'fields:customURL',
+    'fields:internalLink',
+    'fields:enterURL',
+    'fields:chooseDocumentToLink',
+    'fields:openInNewTab'
+]);
+const getBaseFields = (config)=>[
+        {
+            name: 'text',
+            label: translations['fields:textToDisplay'],
+            required: true,
+            type: 'text'
+        },
+        {
+            name: 'fields',
+            admin: {
+                style: {
+                    borderBottom: 0,
+                    borderTop: 0,
+                    margin: 0,
+                    padding: 0
+                }
+            },
+            fields: [
+                {
+                    name: 'linkType',
+                    admin: {
+                        description: translations['fields:chooseBetweenCustomTextOrDocument']
+                    },
+                    defaultValue: 'custom',
+                    label: translations['fields:linkType'],
+                    options: [
+                        {
+                            label: translations['fields:customURL'],
+                            value: 'custom'
+                        },
+                        {
+                            label: translations['fields:internalLink'],
+                            value: 'internal'
+                        }
+                    ],
+                    required: true,
+                    type: 'radio'
+                },
+                {
+                    name: 'url',
+                    admin: {
+                        condition: ({ fields })=>fields?.linkType !== 'internal'
+                    },
+                    label: translations['fields:enterURL'],
+                    required: true,
+                    type: 'text'
+                },
+                {
+                    name: 'doc',
+                    admin: {
+                        condition: ({ fields })=>{
+                            return fields?.linkType === 'internal';
+                        }
+                    },
+                    label: translations['fields:chooseDocumentToLink'],
+                    relationTo: config.collections.filter(({ admin: { enableRichTextLink } })=>enableRichTextLink).map(({ slug })=>slug),
+                    required: true,
+                    type: 'relationship'
+                },
+                {
+                    name: 'newTab',
+                    label: translations['fields:openInNewTab'],
+                    type: 'checkbox'
+                }
+            ],
+            type: 'group'
+        }
+    ];
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Link/drawer/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import './index.scss';
+import { type Props } from './types';
+export declare const LinkDrawer: React.FC<Props>;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Link/drawer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Link/drawer/index.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAIpC,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAoBtC,CAAA"}

package/dist/field/features/Link/drawer/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LinkDrawer", {
+    enumerable: true,
+    get: function() {
+        return LinkDrawer;
+    }
+});
+const _elements = require("payload/components/elements");
+const _forms = require("payload/components/forms");
+const _config = require("payload/config");
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+const _reacti18next = require("react-i18next");
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const baseClass = 'lexical-link-edit-drawer';
+const LinkDrawer = ({ drawerSlug, fieldSchema, handleModalSubmit, initialState })=>{
+    const { t } = (0, _reacti18next.useTranslation)('fields');
+    return /*#__PURE__*/ _react.default.createElement(_elements.Drawer, {
+        className: baseClass,
+        slug: drawerSlug,
+        title: t('editLink') ?? ''
+    }, /*#__PURE__*/ _react.default.createElement(_forms.Form, {
+        initialState: initialState,
+        onSubmit: handleModalSubmit
+    }, /*#__PURE__*/ _react.default.createElement(_forms.RenderFields, {
+        fieldSchema: fieldSchema,
+        fieldTypes: _config.fieldTypes,
+        forceRender: true,
+        readOnly: false
+    }), /*#__PURE__*/ _react.default.createElement(_forms.FormSubmit, null, t('general:submit'))));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Link/drawer/types.d.ts

@@ -0,0 +1,8 @@
+import { type Field, type Fields } from 'payload/types';
+export interface Props {
+    drawerSlug: string;
+    fieldSchema: Field[];
+    handleModalSubmit: (fields: Fields, data: Record<string, unknown>) => void;
+    initialState?: Fields;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/field/features/Link/drawer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Link/drawer/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAEvD,MAAM,WAAW,KAAK;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,KAAK,EAAE,CAAA;IACpB,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB"}

package/dist/field/features/Link/drawer/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/field/features/Link/index.d.ts

@@ -0,0 +1,14 @@
+import type { i18n } from 'i18next';
+import type { SanitizedConfig } from 'payload/config';
+import type { Field } from 'payload/types';
+import type { FeatureProvider } from '../types';
+import './index.scss';
+export type LinkFeatureProps = {
+    fields?: ((args: {
+        config: SanitizedConfig;
+        defaultFields: Field[];
+        i18n: i18n;
+    }) => Field[]) | Field[];
+};
+export declare const LinkFeature: (props: LinkFeatureProps) => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Link/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Link/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAO1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAO/C,OAAO,cAAc,CAAA;AAQrB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,CAAC,EACH,CAAC,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,eAAe,CAAC;QAAC,aAAa,EAAE,KAAK,EAAE,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,KAAK,EAAE,CAAC,GACpF,KAAK,EAAE,CAAA;CACZ,CAAA;AACD,eAAO,MAAM,WAAW,UAAW,gBAAgB,KAAG,eAkFrD,CAAA"}