@payloadcms/richtext-lexical 0.1.0-beta.0

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

@@ -0,0 +1,131 @@
+"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_UPLOAD_WITH_DRAWER_COMMAND: function() {
+        return INSERT_UPLOAD_WITH_DRAWER_COMMAND;
+    },
+    UploadDrawer: function() {
+        return UploadDrawer;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _lexical = require("lexical");
+const _elements = require("payload/components/elements");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _EnabledRelationshipsCondition = require("../../Relationship/utils/EnabledRelationshipsCondition");
+const _UploadNode = require("../nodes/UploadNode");
+const _plugin = require("../plugin");
+require("./index.scss");
+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 baseClass = 'lexical-upload-drawer';
+const INSERT_UPLOAD_WITH_DRAWER_COMMAND = (0, _lexical.createCommand)('INSERT_UPLOAD_WITH_DRAWER_COMMAND');
+const insertUpload = ({ id, editor, relationTo, replaceNodeKey })=>{
+    if (!replaceNodeKey) {
+        editor.dispatchCommand(_plugin.INSERT_UPLOAD_COMMAND, {
+            id,
+            relationTo
+        });
+    } else {
+        editor.update(()=>{
+            const node = (0, _lexical.$getNodeByKey)(replaceNodeKey);
+            if (node) {
+                node.replace((0, _UploadNode.$createUploadNode)({
+                    fields: {
+                        relationTo,
+                        value: {
+                            id
+                        }
+                    }
+                }));
+            }
+        });
+    }
+};
+const UploadDrawerComponent = ({ enabledCollectionSlugs })=>{
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const [replaceNodeKey, setReplaceNodeKey] = (0, _react.useState)(null);
+    const [ListDrawer, ListDrawerToggler, { closeDrawer, openDrawer }] = (0, _elements.useListDrawer)({
+        collectionSlugs: enabledCollectionSlugs,
+        uploads: true
+    });
+    (0, _react.useEffect)(()=>{
+        return editor.registerCommand(INSERT_UPLOAD_WITH_DRAWER_COMMAND, (payload)=>{
+            setReplaceNodeKey(payload?.replace ? payload?.replace.nodeKey : null);
+            openDrawer();
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR);
+    }, [
+        editor,
+        openDrawer
+    ]);
+    const onSelect = (0, _react.useCallback)(({ collectionConfig, docID })=>{
+        insertUpload({
+            id: docID,
+            editor,
+            relationTo: collectionConfig.slug,
+            replaceNodeKey
+        });
+        closeDrawer();
+    }, [
+        editor,
+        closeDrawer,
+        replaceNodeKey
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(ListDrawer, {
+        onSelect: onSelect
+    });
+};
+const UploadDrawer = (props)=>{
+    return /*#__PURE__*/ _react.default.createElement(_EnabledRelationshipsCondition.EnabledRelationshipsCondition, {
+        ...props,
+        uploads: true
+    }, /*#__PURE__*/ _react.default.createElement(UploadDrawerComponent, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import type { Field } from 'payload/types';
+import type { FeatureProvider } from '../types';
+import './index.scss';
+export type UploadFeatureProps = {
+    collections: {
+        [collection: string]: {
+            fields: Field[];
+        };
+    };
+};
+export declare const UploadFeature: (props?: UploadFeatureProps) => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/Upload/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAE1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAM/C,OAAO,cAAc,CAAA;AAIrB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE;QACX,CAAC,UAAU,EAAE,MAAM,GAAG;YACpB,MAAM,EAAE,KAAK,EAAE,CAAA;SAChB,CAAA;KACF,CAAA;CACF,CAAA;AAED,eAAO,MAAM,aAAa,WAAY,kBAAkB,KAAG,eAwC1D,CAAA"}

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UploadFeature", {
+    enumerable: true,
+    get: function() {
+        return UploadFeature;
+    }
+});
+const _LexicalMenu = require("../../lexical/plugins/SlashMenu/LexicalTypeaheadMenuPlugin/LexicalMenu");
+const _Upload = require("../../lexical/ui/icons/Upload");
+const _afterReadPromise = require("./afterReadPromise");
+const _drawer = require("./drawer");
+require("./index.scss");
+const _UploadNode = require("./nodes/UploadNode");
+const _plugin = require("./plugin");
+const UploadFeature = (props)=>{
+    return {
+        feature: ({ resolvedFeatures, unsanitizedEditorConfig })=>{
+            return {
+                nodes: [
+                    {
+                        afterReadPromises: [
+                            (0, _afterReadPromise.uploadAfterReadPromiseHOC)(props)
+                        ],
+                        node: _UploadNode.UploadNode,
+                        type: _UploadNode.UploadNode.getType()
+                    }
+                ],
+                plugins: [
+                    {
+                        Component: _plugin.UploadPlugin,
+                        position: 'normal'
+                    }
+                ],
+                props: props,
+                slashMenu: {
+                    options: [
+                        {
+                            options: [
+                                new _LexicalMenu.SlashMenuOption('Upload', {
+                                    Icon: _Upload.UploadIcon,
+                                    keywords: [
+                                        'upload',
+                                        'image',
+                                        'file',
+                                        'img',
+                                        'picture',
+                                        'photo',
+                                        'media'
+                                    ],
+                                    onSelect: ({ editor })=>{
+                                        editor.dispatchCommand(_drawer.INSERT_UPLOAD_WITH_DRAWER_COMMAND, {
+                                            replace: false
+                                        });
+                                    }
+                                })
+                            ],
+                            title: 'Basic'
+                        }
+                    ]
+                }
+            };
+        },
+        key: 'upload'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Upload/nodes/UploadNode.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+import type { SerializedDecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import type { ElementFormatType, NodeKey } from 'lexical';
+import { DecoratorBlockNode } from '@lexical/react/LexicalDecoratorBlockNode';
+import { type DOMConversionMap, type DOMExportOutput, type LexicalNode, type Spread } from 'lexical';
+export interface RawUploadPayload {
+    id: string;
+    relationTo: string;
+}
+export type UploadFields = {
+    [key: string]: unknown;
+    relationTo: string;
+    value: {
+        [key: string]: unknown;
+        id: string;
+    };
+};
+export type SerializedUploadNode = Spread<{
+    fields: UploadFields;
+}, SerializedDecoratorBlockNode>;
+export declare class UploadNode extends DecoratorBlockNode {
+    __fields: UploadFields;
+    constructor({ fields, format, key, }: {
+        fields: UploadFields;
+        format?: ElementFormatType;
+        key?: NodeKey;
+    });
+    static clone(node: UploadNode): UploadNode;
+    static getType(): string;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedUploadNode): UploadNode;
+    static isInline(): false;
+    decorate(): JSX.Element;
+    exportDOM(): DOMExportOutput;
+    exportJSON(): SerializedUploadNode;
+    getFields(): UploadFields;
+    setFields(fields: UploadFields): void;
+    updateDOM(): false;
+}
+export declare function $createUploadNode({ fields }: {
+    fields: UploadFields;
+}): UploadNode;
+export declare function $isUploadNode(node: LexicalNode | null | undefined): node is UploadNode;
+//# sourceMappingURL=UploadNode.d.ts.map

package/dist/field/features/Upload/nodes/UploadNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploadNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Upload/nodes/UploadNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAA;AAC7E,OAAO,EAEL,KAAK,gBAAgB,EAErB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,MAAM,EACZ,MAAM,SAAS,CAAA;AAQhB,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,YAAY,GAAG;IAEzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE;QAEL,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;QACtB,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF,CAAA;AAYD,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC;IACE,MAAM,EAAE,YAAY,CAAA;CACrB,EACD,4BAA4B,CAC7B,CAAA;AAED,qBAAa,UAAW,SAAQ,kBAAkB;IAChD,QAAQ,EAAE,YAAY,CAAA;gBAEV,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,YAAY,CAAA;QACpB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU;IAQ1C,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAS3C,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,oBAAoB,GAAG,UAAU;IASnE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAIxB,QAAQ,IAAI,GAAG,CAAC,OAAO;IAMvB,SAAS,IAAI,eAAe;IAO5B,UAAU,IAAI,oBAAoB;IASlC,SAAS,IAAI,YAAY;IAIzB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAMrC,SAAS,IAAI,KAAK;CAGnB;AAED,wBAAgB,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,GAAG,UAAU,CAElF;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,UAAU,CAEtF"}

package/dist/field/features/Upload/nodes/UploadNode.js

@@ -0,0 +1,153 @@
+"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, {
+    UploadNode: function() {
+        return UploadNode;
+    },
+    $createUploadNode: function() {
+        return $createUploadNode;
+    },
+    $isUploadNode: function() {
+        return $isUploadNode;
+    }
+});
+const _LexicalDecoratorBlockNode = require("@lexical/react/LexicalDecoratorBlockNode");
+const _lexical = require("lexical");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+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;
+}
+// @ts-expect-error TypeScript being dumb
+const RawUploadComponent = /*#__PURE__*/ _react.lazy(async ()=>await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../component"))));
+function convertUploadElement(domNode) {
+    if (domNode instanceof HTMLImageElement) {
+    // const { alt: altText, src } = domNode;
+    // const node = $createImageNode({ altText, src });
+    // return { node };
+    // TODO: Auto-upload functionality here!
+    }
+    return null;
+}
+class UploadNode extends _LexicalDecoratorBlockNode.DecoratorBlockNode {
+    __fields;
+    constructor({ fields, format, key }){
+        super(format, key);
+        this.__fields = fields;
+    }
+    static clone(node) {
+        return new UploadNode({
+            fields: node.__fields,
+            format: node.__format,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'upload';
+    }
+    static importDOM() {
+        return {
+            img: (node)=>({
+                    conversion: convertUploadElement,
+                    priority: 0
+                })
+        };
+    }
+    static importJSON(serializedNode) {
+        const node = $createUploadNode({
+            fields: serializedNode.fields
+        });
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate() {
+        return /*#__PURE__*/ _react.createElement(RawUploadComponent, {
+            fields: this.__fields,
+            format: this.__format,
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('img');
+        // element.setAttribute('src', this.__src);
+        // element.setAttribute('alt', this.__altText); //TODO
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            fields: this.getFields(),
+            type: this.getType(),
+            version: 1
+        };
+    }
+    getFields() {
+        return this.getLatest().__fields;
+    }
+    setFields(fields) {
+        const writable = this.getWritable();
+        writable.__fields = fields;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    updateDOM() {
+        return false;
+    }
+}
+function $createUploadNode({ fields }) {
+    return (0, _lexical.$applyNodeReplacement)(new UploadNode({
+        fields
+    }));
+}
+function $isUploadNode(node) {
+    return node instanceof UploadNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/Upload/plugin/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { type LexicalCommand } from 'lexical';
+import type { RawUploadPayload } from '../nodes/UploadNode';
+export type InsertUploadPayload = Readonly<RawUploadPayload>;
+export declare const INSERT_UPLOAD_COMMAND: LexicalCommand<InsertUploadPayload>;
+export declare function UploadPlugin(): JSX.Element | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/field/features/Upload/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/Upload/plugin/index.tsx"],"names":[],"mappings":";AAEA,OAAO,EAA2B,KAAK,cAAc,EAAiB,MAAM,SAAS,CAAA;AAIrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAK3D,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAA;AAE5D,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,mBAAmB,CAC9B,CAAA;AAExC,wBAAgB,YAAY,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAkCjD"}

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

@@ -0,0 +1,97 @@
+"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_UPLOAD_COMMAND: function() {
+        return INSERT_UPLOAD_COMMAND;
+    },
+    UploadPlugin: function() {
+        return UploadPlugin;
+    }
+});
+const _LexicalComposerContext = require("@lexical/react/LexicalComposerContext");
+const _utils = require("@lexical/utils");
+const _lexical = require("lexical");
+const _utilities = require("payload/components/utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _drawer = require("../drawer");
+const _UploadNode = require("../nodes/UploadNode");
+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_UPLOAD_COMMAND = (0, _lexical.createCommand)('INSERT_UPLOAD_COMMAND');
+function UploadPlugin() {
+    const [editor] = (0, _LexicalComposerContext.useLexicalComposerContext)();
+    const { collections } = (0, _utilities.useConfig)();
+    (0, _react.useEffect)(()=>{
+        if (!editor.hasNodes([
+            _UploadNode.UploadNode
+        ])) {
+            throw new Error('UploadPlugin: UploadNode not registered on editor');
+        }
+        return (0, _utils.mergeRegister)(editor.registerCommand(INSERT_UPLOAD_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const uploadNode = (0, _UploadNode.$createUploadNode)({
+                    fields: {
+                        relationTo: payload.relationTo,
+                        value: {
+                            id: payload.id
+                        }
+                    }
+                });
+                (0, _utils.$insertNodeToNearestRoot)(uploadNode);
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_drawer.UploadDrawer, {
+        enabledCollectionSlugs: collections.map(({ slug })=>slug)
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/align/floatingSelectToolbarAlignDropdownSection.d.ts

@@ -0,0 +1,4 @@
+import type { FloatingToolbarSection, FloatingToolbarSectionEntry } from '../../lexical/plugins/FloatingSelectToolbar/types';
+import './index.scss';
+export declare const AlignDropdownSectionWithEntries: (entries: FloatingToolbarSectionEntry[]) => FloatingToolbarSection;
+//# sourceMappingURL=floatingSelectToolbarAlignDropdownSection.d.ts.map

package/dist/field/features/align/floatingSelectToolbarAlignDropdownSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floatingSelectToolbarAlignDropdownSection.d.ts","sourceRoot":"","sources":["../../../../src/field/features/align/floatingSelectToolbarAlignDropdownSection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,mDAAmD,CAAA;AAG1D,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,+BAA+B,YACjC,2BAA2B,EAAE,KACrC,sBAQF,CAAA"}

package/dist/field/features/align/floatingSelectToolbarAlignDropdownSection.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AlignDropdownSectionWithEntries", {
+    enumerable: true,
+    get: function() {
+        return AlignDropdownSectionWithEntries;
+    }
+});
+const _AlignLeft = require("../../lexical/ui/icons/AlignLeft");
+require("./index.scss");
+const AlignDropdownSectionWithEntries = (entries)=>{
+    return {
+        ChildComponent: _AlignLeft.AlignLeftIcon,
+        entries,
+        key: 'dropdown-align',
+        order: 2,
+        type: 'dropdown'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9hbGlnbi9mbG9hdGluZ1NlbGVjdFRvb2xiYXJBbGlnbkRyb3Bkb3duU2VjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb24sXG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSxcbn0gZnJvbSAnLi4vLi4vbGV4aWNhbC9wbHVnaW5zL0Zsb2F0aW5nU2VsZWN0VG9vbGJhci90eXBlcydcblxuaW1wb3J0IHsgQWxpZ25MZWZ0SWNvbiB9IGZyb20gJy4uLy4uL2xleGljYWwvdWkvaWNvbnMvQWxpZ25MZWZ0J1xuaW1wb3J0ICcuL2luZGV4LnNjc3MnXG5cbmV4cG9ydCBjb25zdCBBbGlnbkRyb3Bkb3duU2VjdGlvbldpdGhFbnRyaWVzID0gKFxuICBlbnRyaWVzOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uRW50cnlbXSxcbik6IEZsb2F0aW5nVG9vbGJhclNlY3Rpb24gPT4ge1xuICByZXR1cm4ge1xuICAgIENoaWxkQ29tcG9uZW50OiBBbGlnbkxlZnRJY29uLFxuICAgIGVudHJpZXMsXG4gICAga2V5OiAnZHJvcGRvd24tYWxpZ24nLFxuICAgIG9yZGVyOiAyLFxuICAgIHR5cGU6ICdkcm9wZG93bicsXG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJBbGlnbkRyb3Bkb3duU2VjdGlvbldpdGhFbnRyaWVzIiwiZW50cmllcyIsIkNoaWxkQ29tcG9uZW50IiwiQWxpZ25MZWZ0SWNvbiIsImtleSIsIm9yZGVyIiwidHlwZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFRYUE7OztlQUFBQTs7OzJCQUhpQjtRQUN2QjtBQUVBLE1BQU1BLGtDQUFrQyxDQUM3Q0M7SUFFQSxPQUFPO1FBQ0xDLGdCQUFnQkMsd0JBQWE7UUFDN0JGO1FBQ0FHLEtBQUs7UUFDTEMsT0FBTztRQUNQQyxNQUFNO0lBQ1I7QUFDRiJ9

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

@@ -0,0 +1,4 @@
+import type { FeatureProvider } from '../types';
+import './index.scss';
+export declare const AlignFeature: () => FeatureProvider;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/field/features/align/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/C,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,YAAY,QAAO,eAiD/B,CAAA"}