@payloadcms/richtext-lexical 0.7.0 → 3.0.0-alpha.18

package/dist/field/features/blocks/feature.server.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlocksFeature", {
+    enumerable: true,
+    get: function() {
+        return BlocksFeature;
+    }
+});
+const _config = require("payload/config");
+const _utilities = require("payload/utilities");
+const _featureclient = require("./feature.client");
+const _BlocksNode = require("./nodes/BlocksNode");
+const _populationPromise = require("./populationPromise");
+const _validate = require("./validate");
+const BlocksFeature = (props)=>{
+    // Sanitization taken from payload/src/fields/config/sanitize.ts
+    if (props?.blocks?.length) {
+        props.blocks = props.blocks.map((block)=>{
+            return {
+                ...block,
+                fields: block.fields.concat(_config.baseBlockFields),
+                labels: !block.labels ? (0, _utilities.formatLabels)(block.slug) : block.labels
+            };
+        });
+    //  unSanitizedBlock.fields are sanitized in the React component and not here.
+    // That's because we do not have access to the payload config here.
+    }
+    // Build clientProps
+    const clientProps = {
+        reducedBlocks: []
+    };
+    for (const block of props.blocks){
+        clientProps.reducedBlocks.push({
+            slug: block.slug,
+            imageAltText: block.imageAltText,
+            imageURL: block.imageURL,
+            labels: block.labels,
+            subfields: []
+        });
+    }
+    return {
+        feature: ()=>{
+            return {
+                ClientComponent: _featureclient.BlocksFeatureClientComponent,
+                clientFeatureProps: clientProps,
+                generateSchemaMap: ({ config, props })=>{
+                    const validRelationships = config.collections.map((c)=>c.slug) || [];
+                    const schemaMap = {};
+                    for (const block of props.blocks){
+                        const unSanitizedFormSchema = block.fields || [];
+                        const formSchema = (0, _config.sanitizeFields)({
+                            config,
+                            fields: unSanitizedFormSchema,
+                            validRelationships
+                        });
+                        schemaMap[block.slug] = formSchema;
+                    }
+                    return schemaMap;
+                },
+                generatedTypes: {
+                    modifyOutputSchema: ({ currentSchema, field, interfaceNameDefinitions })=>{
+                        const blocksField = {
+                            name: field?.name + '_lexical_blocks',
+                            type: 'blocks',
+                            blocks: props.blocks
+                        };
+                        // This is only done so that interfaceNameDefinitions sets those block's interfaceNames.
+                        // we don't actually use the JSON Schema itself in the generated types yet.
+                        (0, _utilities.fieldsToJSONSchema)({}, [
+                            blocksField
+                        ], interfaceNameDefinitions);
+                        return currentSchema;
+                    }
+                },
+                nodes: [
+                    {
+                        node: _BlocksNode.BlockNode,
+                        populationPromises: [
+                            (0, _populationPromise.blockPopulationPromiseHOC)(props)
+                        ],
+                        validations: [
+                            (0, _validate.blockValidationHOC)(props)
+                        ]
+                    }
+                ],
+                serverFeatureProps: props
+            };
+        },
+        key: 'blocks',
+        serverFeatureProps: props
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/blocks/nodes/BlocksNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlocksNode.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/nodes/BlocksNode.tsx"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAA;AAC5F,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,OAAO,EACP,MAAM,EACP,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAA;AAI7E,MAAM,MAAM,WAAW,GAAG;IACxB,sBAAsB;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AASD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CACtC;IACE,MAAM,EAAE,WAAW,CAAA;CACpB,EACD,4BAA4B,CAC7B,CAAA;AAED,qBAAa,SAAU,SAAQ,kBAAkB;IAC/C,QAAQ,EAAE,WAAW,CAAA;gBAET,EACV,MAAM,EACN,MAAM,EACN,GAAG,GACJ,EAAE;QACD,MAAM,EAAE,WAAW,CAAA;QACnB,MAAM,CAAC,EAAE,iBAAiB,CAAA;QAC1B,GAAG,CAAC,EAAE,OAAO,CAAA;KACd;IAKD,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS;IAQxC,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,SAAS,IAAI,gBAAgB,CAAC,cAAc,CAAC,GAAG,IAAI;IAI3D,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS;IAgBjE,MAAM,CAAC,QAAQ,IAAI,KAAK;IAGxB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO;IAIlE,SAAS,IAAI,eAAe;IAQ5B,UAAU,IAAI,mBAAmB;IASjC,SAAS,IAAI,WAAW;IAIxB,cAAc,IAAI,MAAM;IAIxB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI;CAMrC;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,SAAS,CAO9E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,SAAS,CAEhG"}

package/dist/field/features/blocks/nodes/BlocksNode.js

@@ -0,0 +1,158 @@
+"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, {
+    $createBlockNode: function() {
+        return $createBlockNode;
+    },
+    $isBlockNode: function() {
+        return $isBlockNode;
+    },
+    BlockNode: function() {
+        return BlockNode;
+    }
+});
+const _LexicalDecoratorBlockNode = require("@lexical/react/LexicalDecoratorBlockNode");
+const _bsonobjectid = /*#__PURE__*/ _interop_require_default(require("bson-objectid"));
+const _react = /*#__PURE__*/ _interop_require_default(require("react"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 = {
+        __proto__: null
+    };
+    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 BlockComponent = /*#__PURE__*/ _react.default.lazy(()=>// @ts-expect-error-next-line TypeScript being dumb
+    Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../component"))).then((module)=>({
+            default: module.BlockComponent
+        })));
+class BlockNode extends _LexicalDecoratorBlockNode.DecoratorBlockNode {
+    __fields;
+    constructor({ fields, format, key }){
+        super(format, key);
+        this.__fields = fields;
+    }
+    static clone(node) {
+        return new BlockNode({
+            fields: node.__fields,
+            format: node.__format,
+            key: node.__key
+        });
+    }
+    static getType() {
+        return 'block';
+    }
+    static importDOM() {
+        return {};
+    }
+    static importJSON(serializedNode) {
+        if (serializedNode.version === 1) {
+            // Convert (version 1 had the fields wrapped in another, unnecessary data property)
+            serializedNode = {
+                ...serializedNode,
+                fields: {
+                    ...serializedNode.fields.data
+                },
+                version: 2
+            };
+        }
+        const node = $createBlockNode(serializedNode.fields);
+        node.setFormat(serializedNode.format);
+        return node;
+    }
+    static isInline() {
+        return false;
+    }
+    decorate(editor, config) {
+        return /*#__PURE__*/ _react.default.createElement(BlockComponent, {
+            formData: this.getFields(),
+            nodeKey: this.getKey()
+        });
+    }
+    exportDOM() {
+        const element = document.createElement('div');
+        const text = document.createTextNode(this.getTextContent());
+        element.append(text);
+        return {
+            element
+        };
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: this.getType(),
+            fields: this.getFields(),
+            version: 2
+        };
+    }
+    getFields() {
+        return this.getLatest().__fields;
+    }
+    getTextContent() {
+        return `Block Field`;
+    }
+    setFields(fields) {
+        const fieldsCopy = JSON.parse(JSON.stringify(fields));
+        const writable = this.getWritable();
+        writable.__fields = fieldsCopy;
+    }
+}
+function $createBlockNode(fields) {
+    return new BlockNode({
+        fields: {
+            ...fields,
+            id: fields?.id || new _bsonobjectid.default().toHexString()
+        }
+    });
+}
+function $isBlockNode(node) {
+    return node instanceof BlockNode;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9ibG9ja3Mvbm9kZXMvQmxvY2tzTm9kZS50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTZXJpYWxpemVkRGVjb3JhdG9yQmxvY2tOb2RlIH0gZnJvbSAnQGxleGljYWwvcmVhY3QvTGV4aWNhbERlY29yYXRvckJsb2NrTm9kZSdcbmltcG9ydCB0eXBlIHtcbiAgRE9NQ29udmVyc2lvbk1hcCxcbiAgRE9NRXhwb3J0T3V0cHV0LFxuICBFZGl0b3JDb25maWcsXG4gIEVsZW1lbnRGb3JtYXRUeXBlLFxuICBMZXhpY2FsRWRpdG9yLFxuICBMZXhpY2FsTm9kZSxcbiAgTm9kZUtleSxcbiAgU3ByZWFkLFxufSBmcm9tICdsZXhpY2FsJ1xuXG5pbXBvcnQgeyBEZWNvcmF0b3JCbG9ja05vZGUgfSBmcm9tICdAbGV4aWNhbC9yZWFjdC9MZXhpY2FsRGVjb3JhdG9yQmxvY2tOb2RlJ1xuaW1wb3J0IE9iamVjdElEIGZyb20gJ2Jzb24tb2JqZWN0aWQnXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnXG5cbmV4cG9ydCB0eXBlIEJsb2NrRmllbGRzID0ge1xuICAvKiogQmxvY2sgZm9ybSBkYXRhICovXG4gIFtrZXk6IHN0cmluZ106IGFueVxuICBibG9ja05hbWU6IHN0cmluZ1xuICBibG9ja1R5cGU6IHN0cmluZ1xuICBpZDogc3RyaW5nXG59XG5cbmNvbnN0IEJsb2NrQ29tcG9uZW50ID0gUmVhY3QubGF6eSgoKSA9PlxuICAvLyBAdHMtZXhwZWN0LWVycm9yLW5leHQtbGluZSBUeXBlU2NyaXB0IGJlaW5nIGR1bWJcbiAgaW1wb3J0KCcuLi9jb21wb25lbnQnKS50aGVuKChtb2R1bGUpID0+ICh7XG4gICAgZGVmYXVsdDogbW9kdWxlLkJsb2NrQ29tcG9uZW50LFxuICB9KSksXG4pXG5cbmV4cG9ydCB0eXBlIFNlcmlhbGl6ZWRCbG9ja05vZGUgPSBTcHJlYWQ8XG4gIHtcbiAgICBmaWVsZHM6IEJsb2NrRmllbGRzXG4gIH0sXG4gIFNlcmlhbGl6ZWREZWNvcmF0b3JCbG9ja05vZGVcbj5cblxuZXhwb3J0IGNsYXNzIEJsb2NrTm9kZSBleHRlbmRzIERlY29yYXRvckJsb2NrTm9kZSB7XG4gIF9fZmllbGRzOiBCbG9ja0ZpZWxkc1xuXG4gIGNvbnN0cnVjdG9yKHtcbiAgICBmaWVsZHMsXG4gICAgZm9ybWF0LFxuICAgIGtleSxcbiAgfToge1xuICAgIGZpZWxkczogQmxvY2tGaWVsZHNcbiAgICBmb3JtYXQ/OiBFbGVtZW50Rm9ybWF0VHlwZVxuICAgIGtleT86IE5vZGVLZXlcbiAgfSkge1xuICAgIHN1cGVyKGZvcm1hdCwga2V5KVxuICAgIHRoaXMuX19maWVsZHMgPSBmaWVsZHNcbiAgfVxuXG4gIHN0YXRpYyBjbG9uZShub2RlOiBCbG9ja05vZGUpOiBCbG9ja05vZGUge1xuICAgIHJldHVybiBuZXcgQmxvY2tOb2RlKHtcbiAgICAgIGZpZWxkczogbm9kZS5fX2ZpZWxkcyxcbiAgICAgIGZvcm1hdDogbm9kZS5fX2Zvcm1hdCxcbiAgICAgIGtleTogbm9kZS5fX2tleSxcbiAgICB9KVxuICB9XG5cbiAgc3RhdGljIGdldFR5cGUoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gJ2Jsb2NrJ1xuICB9XG5cbiAgc3RhdGljIGltcG9ydERPTSgpOiBET01Db252ZXJzaW9uTWFwPEhUTUxEaXZFbGVtZW50PiB8IG51bGwge1xuICAgIHJldHVybiB7fVxuICB9XG5cbiAgc3RhdGljIGltcG9ydEpTT04oc2VyaWFsaXplZE5vZGU6IFNlcmlhbGl6ZWRCbG9ja05vZGUpOiBCbG9ja05vZGUge1xuICAgIGlmIChzZXJpYWxpemVkTm9kZS52ZXJzaW9uID09PSAxKSB7XG4gICAgICAvLyBDb252ZXJ0ICh2ZXJzaW9uIDEgaGFkIHRoZSBmaWVsZHMgd3JhcHBlZCBpbiBhbm90aGVyLCB1bm5lY2Vzc2FyeSBkYXRhIHByb3BlcnR5KVxuICAgICAgc2VyaWFsaXplZE5vZGUgPSB7XG4gICAgICAgIC4uLnNlcmlhbGl6ZWROb2RlLFxuICAgICAgICBmaWVsZHM6IHtcbiAgICAgICAgICAuLi4oc2VyaWFsaXplZE5vZGUgYXMgYW55KS5maWVsZHMuZGF0YSxcbiAgICAgICAgfSxcbiAgICAgICAgdmVyc2lvbjogMixcbiAgICAgIH1cbiAgICB9XG4gICAgY29uc3Qgbm9kZSA9ICRjcmVhdGVCbG9ja05vZGUoc2VyaWFsaXplZE5vZGUuZmllbGRzKVxuICAgIG5vZGUuc2V0Rm9ybWF0KHNlcmlhbGl6ZWROb2RlLmZvcm1hdClcbiAgICByZXR1cm4gbm9kZVxuICB9XG5cbiAgc3RhdGljIGlzSW5saW5lKCk6IGZhbHNlIHtcbiAgICByZXR1cm4gZmFsc2VcbiAgfVxuICBkZWNvcmF0ZShlZGl0b3I6IExleGljYWxFZGl0b3IsIGNvbmZpZzogRWRpdG9yQ29uZmlnKTogSlNYLkVsZW1lbnQge1xuICAgIHJldHVybiA8QmxvY2tDb21wb25lbnQgZm9ybURhdGE9e3RoaXMuZ2V0RmllbGRzKCl9IG5vZGVLZXk9e3RoaXMuZ2V0S2V5KCl9IC8+XG4gIH1cblxuICBleHBvcnRET00oKTogRE9NRXhwb3J0T3V0cHV0IHtcbiAgICBjb25zdCBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2JylcblxuICAgIGNvbnN0IHRleHQgPSBkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSh0aGlzLmdldFRleHRDb250ZW50KCkpXG4gICAgZWxlbWVudC5hcHBlbmQodGV4dClcbiAgICByZXR1cm4geyBlbGVtZW50IH1cbiAgfVxuXG4gIGV4cG9ydEpTT04oKTogU2VyaWFsaXplZEJsb2NrTm9kZSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIC4uLnN1cGVyLmV4cG9ydEpTT04oKSxcbiAgICAgIHR5cGU6IHRoaXMuZ2V0VHlwZSgpLFxuICAgICAgZmllbGRzOiB0aGlzLmdldEZpZWxkcygpLFxuICAgICAgdmVyc2lvbjogMixcbiAgICB9XG4gIH1cblxuICBnZXRGaWVsZHMoKTogQmxvY2tGaWVsZHMge1xuICAgIHJldHVybiB0aGlzLmdldExhdGVzdCgpLl9fZmllbGRzXG4gIH1cblxuICBnZXRUZXh0Q29udGVudCgpOiBzdHJpbmcge1xuICAgIHJldHVybiBgQmxvY2sgRmllbGRgXG4gIH1cblxuICBzZXRGaWVsZHMoZmllbGRzOiBCbG9ja0ZpZWxkcyk6IHZvaWQge1xuICAgIGNvbnN0IGZpZWxkc0NvcHkgPSBKU09OLnBhcnNlKEpTT04uc3RyaW5naWZ5KGZpZWxkcykpIGFzIEJsb2NrRmllbGRzXG5cbiAgICBjb25zdCB3cml0YWJsZSA9IHRoaXMuZ2V0V3JpdGFibGUoKVxuICAgIHdyaXRhYmxlLl9fZmllbGRzID0gZmllbGRzQ29weVxuICB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiAkY3JlYXRlQmxvY2tOb2RlKGZpZWxkczogRXhjbHVkZTxCbG9ja0ZpZWxkcywgJ2lkJz4pOiBCbG9ja05vZGUge1xuICByZXR1cm4gbmV3IEJsb2NrTm9kZSh7XG4gICAgZmllbGRzOiB7XG4gICAgICAuLi5maWVsZHMsXG4gICAgICBpZDogZmllbGRzPy5pZCB8fCBuZXcgT2JqZWN0SUQoKS50b0hleFN0cmluZygpLFxuICAgIH0sXG4gIH0pXG59XG5cbmV4cG9ydCBmdW5jdGlvbiAkaXNCbG9ja05vZGUobm9kZTogQmxvY2tOb2RlIHwgTGV4aWNhbE5vZGUgfCBudWxsIHwgdW5kZWZpbmVkKTogbm9kZSBpcyBCbG9ja05vZGUge1xuICByZXR1cm4gbm9kZSBpbnN0YW5jZW9mIEJsb2NrTm9kZVxufVxuIl0sIm5hbWVzIjpbIiRjcmVhdGVCbG9ja05vZGUiLCIkaXNCbG9ja05vZGUiLCJCbG9ja05vZGUiLCJCbG9ja0NvbXBvbmVudCIsIlJlYWN0IiwibGF6eSIsInRoZW4iLCJtb2R1bGUiLCJkZWZhdWx0IiwiRGVjb3JhdG9yQmxvY2tOb2RlIiwiX19maWVsZHMiLCJjb25zdHJ1Y3RvciIsImZpZWxkcyIsImZvcm1hdCIsImtleSIsImNsb25lIiwibm9kZSIsIl9fZm9ybWF0IiwiX19rZXkiLCJnZXRUeXBlIiwiaW1wb3J0RE9NIiwiaW1wb3J0SlNPTiIsInNlcmlhbGl6ZWROb2RlIiwidmVyc2lvbiIsImRhdGEiLCJzZXRGb3JtYXQiLCJpc0lubGluZSIsImRlY29yYXRlIiwiZWRpdG9yIiwiY29uZmlnIiwiZm9ybURhdGEiLCJnZXRGaWVsZHMiLCJub2RlS2V5IiwiZ2V0S2V5IiwiZXhwb3J0RE9NIiwiZWxlbWVudCIsImRvY3VtZW50IiwiY3JlYXRlRWxlbWVudCIsInRleHQiLCJjcmVhdGVUZXh0Tm9kZSIsImdldFRleHRDb250ZW50IiwiYXBwZW5kIiwiZXhwb3J0SlNPTiIsInR5cGUiLCJnZXRMYXRlc3QiLCJzZXRGaWVsZHMiLCJmaWVsZHNDb3B5IiwiSlNPTiIsInBhcnNlIiwic3RyaW5naWZ5Iiwid3JpdGFibGUiLCJnZXRXcml0YWJsZSIsImlkIiwiT2JqZWN0SUQiLCJ0b0hleFN0cmluZyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7SUE4SGdCQSxnQkFBZ0I7ZUFBaEJBOztJQVNBQyxZQUFZO2VBQVpBOztJQWpHSEMsU0FBUztlQUFUQTs7OzJDQTFCc0I7cUVBQ2Q7OERBQ0g7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBVWxCLE1BQU1DLCtCQUFpQkMsY0FBSyxDQUFDQyxJQUFJLENBQUMsSUFDaEMsbURBQW1EO0lBQ25ELG1FQUFBLFFBQU8sa0JBQWdCQyxJQUFJLENBQUMsQ0FBQ0MsU0FBWSxDQUFBO1lBQ3ZDQyxTQUFTRCxPQUFPSixjQUFjO1FBQ2hDLENBQUE7QUFVSyxNQUFNRCxrQkFBa0JPLDZDQUFrQjtJQUMvQ0MsU0FBcUI7SUFFckJDLFlBQVksRUFDVkMsTUFBTSxFQUNOQyxNQUFNLEVBQ05DLEdBQUcsRUFLSixDQUFFO1FBQ0QsS0FBSyxDQUFDRCxRQUFRQztRQUNkLElBQUksQ0FBQ0osUUFBUSxHQUFHRTtJQUNsQjtJQUVBLE9BQU9HLE1BQU1DLElBQWUsRUFBYTtRQUN2QyxPQUFPLElBQUlkLFVBQVU7WUFDbkJVLFFBQVFJLEtBQUtOLFFBQVE7WUFDckJHLFFBQVFHLEtBQUtDLFFBQVE7WUFDckJILEtBQUtFLEtBQUtFLEtBQUs7UUFDakI7SUFDRjtJQUVBLE9BQU9DLFVBQWtCO1FBQ3ZCLE9BQU87SUFDVDtJQUVBLE9BQU9DLFlBQXFEO1FBQzFELE9BQU8sQ0FBQztJQUNWO0lBRUEsT0FBT0MsV0FBV0MsY0FBbUMsRUFBYTtRQUNoRSxJQUFJQSxlQUFlQyxPQUFPLEtBQUssR0FBRztZQUNoQyxtRkFBbUY7WUFDbkZELGlCQUFpQjtnQkFDZixHQUFHQSxjQUFjO2dCQUNqQlYsUUFBUTtvQkFDTixHQUFHLEFBQUNVLGVBQXVCVixNQUFNLENBQUNZLElBQUk7Z0JBQ3hDO2dCQUNBRCxTQUFTO1lBQ1g7UUFDRjtRQUNBLE1BQU1QLE9BQU9oQixpQkFBaUJzQixlQUFlVixNQUFNO1FBQ25ESSxLQUFLUyxTQUFTLENBQUNILGVBQWVULE1BQU07UUFDcEMsT0FBT0c7SUFDVDtJQUVBLE9BQU9VLFdBQWtCO1FBQ3ZCLE9BQU87SUFDVDtJQUNBQyxTQUFTQyxNQUFxQixFQUFFQyxNQUFvQixFQUFlO1FBQ2pFLHFCQUFPLDZCQUFDMUI7WUFBZTJCLFVBQVUsSUFBSSxDQUFDQyxTQUFTO1lBQUlDLFNBQVMsSUFBSSxDQUFDQyxNQUFNOztJQUN6RTtJQUVBQyxZQUE2QjtRQUMzQixNQUFNQyxVQUFVQyxTQUFTQyxhQUFhLENBQUM7UUFFdkMsTUFBTUMsT0FBT0YsU0FBU0csY0FBYyxDQUFDLElBQUksQ0FBQ0MsY0FBYztRQUN4REwsUUFBUU0sTUFBTSxDQUFDSDtRQUNmLE9BQU87WUFBRUg7UUFBUTtJQUNuQjtJQUVBTyxhQUFrQztRQUNoQyxPQUFPO1lBQ0wsR0FBRyxLQUFLLENBQUNBLFlBQVk7WUFDckJDLE1BQU0sSUFBSSxDQUFDeEIsT0FBTztZQUNsQlAsUUFBUSxJQUFJLENBQUNtQixTQUFTO1lBQ3RCUixTQUFTO1FBQ1g7SUFDRjtJQUVBUSxZQUF5QjtRQUN2QixPQUFPLElBQUksQ0FBQ2EsU0FBUyxHQUFHbEMsUUFBUTtJQUNsQztJQUVBOEIsaUJBQXlCO1FBQ3ZCLE9BQU8sQ0FBQyxXQUFXLENBQUM7SUFDdEI7SUFFQUssVUFBVWpDLE1BQW1CLEVBQVE7UUFDbkMsTUFBTWtDLGFBQWFDLEtBQUtDLEtBQUssQ0FBQ0QsS0FBS0UsU0FBUyxDQUFDckM7UUFFN0MsTUFBTXNDLFdBQVcsSUFBSSxDQUFDQyxXQUFXO1FBQ2pDRCxTQUFTeEMsUUFBUSxHQUFHb0M7SUFDdEI7QUFDRjtBQUVPLFNBQVM5QyxpQkFBaUJZLE1BQWtDO0lBQ2pFLE9BQU8sSUFBSVYsVUFBVTtRQUNuQlUsUUFBUTtZQUNOLEdBQUdBLE1BQU07WUFDVHdDLElBQUl4QyxRQUFRd0MsTUFBTSxJQUFJQyxxQkFBUSxHQUFHQyxXQUFXO1FBQzlDO0lBQ0Y7QUFDRjtBQUVPLFNBQVNyRCxhQUFhZSxJQUFnRDtJQUMzRSxPQUFPQSxnQkFBZ0JkO0FBQ3pCIn0=

package/dist/field/features/blocks/plugin/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/plugin/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAEjD,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,kBAAkB,CAC7B,CAAA"}

package/dist/field/features/blocks/plugin/commands.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "INSERT_BLOCK_COMMAND", {
+    enumerable: true,
+    get: function() {
+        return INSERT_BLOCK_COMMAND;
+    }
+});
+const _lexical = require("lexical");
+const INSERT_BLOCK_COMMAND = (0, _lexical.createCommand)('INSERT_BLOCK_COMMAND');
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9ibG9ja3MvcGx1Z2luL2NvbW1hbmRzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTGV4aWNhbENvbW1hbmQgfSBmcm9tICdsZXhpY2FsJ1xuXG5pbXBvcnQgeyBjcmVhdGVDb21tYW5kIH0gZnJvbSAnbGV4aWNhbCdcblxuaW1wb3J0IHR5cGUgeyBJbnNlcnRCbG9ja1BheWxvYWQgfSBmcm9tICcuL2luZGV4J1xuXG5leHBvcnQgY29uc3QgSU5TRVJUX0JMT0NLX0NPTU1BTkQ6IExleGljYWxDb21tYW5kPEluc2VydEJsb2NrUGF5bG9hZD4gPVxuICBjcmVhdGVDb21tYW5kKCdJTlNFUlRfQkxPQ0tfQ09NTUFORCcpXG4iXSwibmFtZXMiOlsiSU5TRVJUX0JMT0NLX0NPTU1BTkQiLCJjcmVhdGVDb21tYW5kIl0sIm1hcHBpbmdzIjoiOzs7OytCQU1hQTs7O2VBQUFBOzs7eUJBSmlCO0FBSXZCLE1BQU1BLHVCQUNYQyxJQUFBQSxzQkFBYSxFQUFDIn0=

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { BlockFields } from '../nodes/BlocksNode';
+export type InsertBlockPayload = Exclude<BlockFields, 'id'>;
+export declare function BlocksPlugin(): React.ReactNode;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/blocks/plugin/index.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAoB,MAAM,OAAO,CAAA;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAMtD,MAAM,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;AAE3D,wBAAgB,YAAY,IAAI,KAAK,CAAC,SAAS,CA8C9C"}

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

@@ -0,0 +1,91 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "BlocksPlugin", {
+    enumerable: true,
+    get: 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");
+const _commands = require("./commands");
+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 = {
+        __proto__: null
+    };
+    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;
+}
+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(_commands.INSERT_BLOCK_COMMAND, (payload)=>{
+            editor.update(()=>{
+                const blockNode = (0, _BlocksNode.$createBlockNode)(payload);
+                const selection = (0, _lexical.$getSelection)() || (0, _lexical.$getPreviousSelection)();
+                if ((0, _lexical.$isRangeSelection)(selection)) {
+                    const { focus } = selection;
+                    const focusNode = focus.getNode();
+                    // First, delete currently selected node if it's an empty paragraph and if there are sufficient
+                    // paragraph nodes (more than 1) left in the parent node, so that we don't "trap" the user
+                    if ((0, _lexical.$isParagraphNode)(focusNode) && focusNode.getTextContentSize() === 0 && focusNode.getParent().getChildren().filter((node)=>(0, _lexical.$isParagraphNode)(node)).length > 1) {
+                        focusNode.remove();
+                    }
+                    (0, _utils.$insertNodeToNearestRoot)(blockNode);
+                }
+            });
+            return true;
+        }, _lexical.COMMAND_PRIORITY_EDITOR));
+    }, [
+        editor
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_drawer.BlocksDrawerComponent, null);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9ibG9ja3MvcGx1Z2luL2luZGV4LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIndXNlIGNsaWVudCdcbmltcG9ydCB7IHVzZUxleGljYWxDb21wb3NlckNvbnRleHQgfSBmcm9tICdAbGV4aWNhbC9yZWFjdC9MZXhpY2FsQ29tcG9zZXJDb250ZXh0J1xuaW1wb3J0IHsgJGluc2VydE5vZGVUb05lYXJlc3RSb290LCBtZXJnZVJlZ2lzdGVyIH0gZnJvbSAnQGxleGljYWwvdXRpbHMnXG5pbXBvcnQge1xuICAkZ2V0UHJldmlvdXNTZWxlY3Rpb24sXG4gICRnZXRTZWxlY3Rpb24sXG4gICRpc1BhcmFncmFwaE5vZGUsXG4gICRpc1JhbmdlU2VsZWN0aW9uLFxuICBDT01NQU5EX1BSSU9SSVRZX0VESVRPUixcbn0gZnJvbSAnbGV4aWNhbCdcbmltcG9ydCBSZWFjdCwgeyB1c2VFZmZlY3QgfSBmcm9tICdyZWFjdCdcblxuaW1wb3J0IHR5cGUgeyBCbG9ja0ZpZWxkcyB9IGZyb20gJy4uL25vZGVzL0Jsb2Nrc05vZGUnXG5cbmltcG9ydCB7IEJsb2Nrc0RyYXdlckNvbXBvbmVudCB9IGZyb20gJy4uL2RyYXdlcidcbmltcG9ydCB7ICRjcmVhdGVCbG9ja05vZGUsIEJsb2NrTm9kZSB9IGZyb20gJy4uL25vZGVzL0Jsb2Nrc05vZGUnXG5pbXBvcnQgeyBJTlNFUlRfQkxPQ0tfQ09NTUFORCB9IGZyb20gJy4vY29tbWFuZHMnXG5cbmV4cG9ydCB0eXBlIEluc2VydEJsb2NrUGF5bG9hZCA9IEV4Y2x1ZGU8QmxvY2tGaWVsZHMsICdpZCc+XG5cbmV4cG9ydCBmdW5jdGlvbiBCbG9ja3NQbHVnaW4oKTogUmVhY3QuUmVhY3ROb2RlIHtcbiAgY29uc3QgW2VkaXRvcl0gPSB1c2VMZXhpY2FsQ29tcG9zZXJDb250ZXh0KClcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGlmICghZWRpdG9yLmhhc05vZGVzKFtCbG9ja05vZGVdKSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdCbG9ja3NQbHVnaW46IEJsb2Nrc05vZGUgbm90IHJlZ2lzdGVyZWQgb24gZWRpdG9yJylcbiAgICB9XG5cbiAgICByZXR1cm4gbWVyZ2VSZWdpc3RlcihcbiAgICAgIGVkaXRvci5yZWdpc3RlckNvbW1hbmQ8SW5zZXJ0QmxvY2tQYXlsb2FkPihcbiAgICAgICAgSU5TRVJUX0JMT0NLX0NPTU1BTkQsXG4gICAgICAgIChwYXlsb2FkOiBJbnNlcnRCbG9ja1BheWxvYWQpID0+IHtcbiAgICAgICAgICBlZGl0b3IudXBkYXRlKCgpID0+IHtcbiAgICAgICAgICAgIGNvbnN0IGJsb2NrTm9kZSA9ICRjcmVhdGVCbG9ja05vZGUocGF5bG9hZClcblxuICAgICAgICAgICAgY29uc3Qgc2VsZWN0aW9uID0gJGdldFNlbGVjdGlvbigpIHx8ICRnZXRQcmV2aW91c1NlbGVjdGlvbigpXG5cbiAgICAgICAgICAgIGlmICgkaXNSYW5nZVNlbGVjdGlvbihzZWxlY3Rpb24pKSB7XG4gICAgICAgICAgICAgIGNvbnN0IHsgZm9jdXMgfSA9IHNlbGVjdGlvblxuICAgICAgICAgICAgICBjb25zdCBmb2N1c05vZGUgPSBmb2N1cy5nZXROb2RlKClcblxuICAgICAgICAgICAgICAvLyBGaXJzdCwgZGVsZXRlIGN1cnJlbnRseSBzZWxlY3RlZCBub2RlIGlmIGl0J3MgYW4gZW1wdHkgcGFyYWdyYXBoIGFuZCBpZiB0aGVyZSBhcmUgc3VmZmljaWVudFxuICAgICAgICAgICAgICAvLyBwYXJhZ3JhcGggbm9kZXMgKG1vcmUgdGhhbiAxKSBsZWZ0IGluIHRoZSBwYXJlbnQgbm9kZSwgc28gdGhhdCB3ZSBkb24ndCBcInRyYXBcIiB0aGUgdXNlclxuICAgICAgICAgICAgICBpZiAoXG4gICAgICAgICAgICAgICAgJGlzUGFyYWdyYXBoTm9kZShmb2N1c05vZGUpICYmXG4gICAgICAgICAgICAgICAgZm9jdXNOb2RlLmdldFRleHRDb250ZW50U2l6ZSgpID09PSAwICYmXG4gICAgICAgICAgICAgICAgZm9jdXNOb2RlXG4gICAgICAgICAgICAgICAgICAuZ2V0UGFyZW50KClcbiAgICAgICAgICAgICAgICAgIC5nZXRDaGlsZHJlbigpXG4gICAgICAgICAgICAgICAgICAuZmlsdGVyKChub2RlKSA9PiAkaXNQYXJhZ3JhcGhOb2RlKG5vZGUpKS5sZW5ndGggPiAxXG4gICAgICAgICAgICAgICkge1xuICAgICAgICAgICAgICAgIGZvY3VzTm9kZS5yZW1vdmUoKVxuICAgICAgICAgICAgICB9XG5cbiAgICAgICAgICAgICAgJGluc2VydE5vZGVUb05lYXJlc3RSb290KGJsb2NrTm9kZSlcbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9KVxuXG4gICAgICAgICAgcmV0dXJuIHRydWVcbiAgICAgICAgfSxcbiAgICAgICAgQ09NTUFORF9QUklPUklUWV9FRElUT1IsXG4gICAgICApLFxuICAgIClcbiAgfSwgW2VkaXRvcl0pXG5cbiAgcmV0dXJuIDxCbG9ja3NEcmF3ZXJDb21wb25lbnQgLz5cbn1cbiJdLCJuYW1lcyI6WyJCbG9ja3NQbHVnaW4iLCJlZGl0b3IiLCJ1c2VMZXhpY2FsQ29tcG9zZXJDb250ZXh0IiwidXNlRWZmZWN0IiwiaGFzTm9kZXMiLCJCbG9ja05vZGUiLCJFcnJvciIsIm1lcmdlUmVnaXN0ZXIiLCJyZWdpc3RlckNvbW1hbmQiLCJJTlNFUlRfQkxPQ0tfQ09NTUFORCIsInBheWxvYWQiLCJ1cGRhdGUiLCJibG9ja05vZGUiLCIkY3JlYXRlQmxvY2tOb2RlIiwic2VsZWN0aW9uIiwiJGdldFNlbGVjdGlvbiIsIiRnZXRQcmV2aW91c1NlbGVjdGlvbiIsIiRpc1JhbmdlU2VsZWN0aW9uIiwiZm9jdXMiLCJmb2N1c05vZGUiLCJnZXROb2RlIiwiJGlzUGFyYWdyYXBoTm9kZSIsImdldFRleHRDb250ZW50U2l6ZSIsImdldFBhcmVudCIsImdldENoaWxkcmVuIiwiZmlsdGVyIiwibm9kZSIsImxlbmd0aCIsInJlbW92ZSIsIiRpbnNlcnROb2RlVG9OZWFyZXN0Um9vdCIsIkNPTU1BTkRfUFJJT1JJVFlfRURJVE9SIiwiQmxvY2tzRHJhd2VyQ29tcG9uZW50Il0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7K0JBb0JnQkE7OztlQUFBQTs7O3dDQW5CMEI7dUJBQ2M7eUJBT2pEOytEQUMwQjt3QkFJSzs0QkFDTTswQkFDUDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBSTlCLFNBQVNBO0lBQ2QsTUFBTSxDQUFDQyxPQUFPLEdBQUdDLElBQUFBLGlEQUF5QjtJQUUxQ0MsSUFBQUEsZ0JBQVMsRUFBQztRQUNSLElBQUksQ0FBQ0YsT0FBT0csUUFBUSxDQUFDO1lBQUNDLHFCQUFTO1NBQUMsR0FBRztZQUNqQyxNQUFNLElBQUlDLE1BQU07UUFDbEI7UUFFQSxPQUFPQyxJQUFBQSxvQkFBYSxFQUNsQk4sT0FBT08sZUFBZSxDQUNwQkMsOEJBQW9CLEVBQ3BCLENBQUNDO1lBQ0NULE9BQU9VLE1BQU0sQ0FBQztnQkFDWixNQUFNQyxZQUFZQyxJQUFBQSw0QkFBZ0IsRUFBQ0g7Z0JBRW5DLE1BQU1JLFlBQVlDLElBQUFBLHNCQUFhLE9BQU1DLElBQUFBLDhCQUFxQjtnQkFFMUQsSUFBSUMsSUFBQUEsMEJBQWlCLEVBQUNILFlBQVk7b0JBQ2hDLE1BQU0sRUFBRUksS0FBSyxFQUFFLEdBQUdKO29CQUNsQixNQUFNSyxZQUFZRCxNQUFNRSxPQUFPO29CQUUvQiwrRkFBK0Y7b0JBQy9GLDBGQUEwRjtvQkFDMUYsSUFDRUMsSUFBQUEseUJBQWdCLEVBQUNGLGNBQ2pCQSxVQUFVRyxrQkFBa0IsT0FBTyxLQUNuQ0gsVUFDR0ksU0FBUyxHQUNUQyxXQUFXLEdBQ1hDLE1BQU0sQ0FBQyxDQUFDQyxPQUFTTCxJQUFBQSx5QkFBZ0IsRUFBQ0ssT0FBT0MsTUFBTSxHQUFHLEdBQ3JEO3dCQUNBUixVQUFVUyxNQUFNO29CQUNsQjtvQkFFQUMsSUFBQUEsK0JBQXdCLEVBQUNqQjtnQkFDM0I7WUFDRjtZQUVBLE9BQU87UUFDVCxHQUNBa0IsZ0NBQXVCO0lBRzdCLEdBQUc7UUFBQzdCO0tBQU87SUFFWCxxQkFBTyw2QkFBQzhCLDZCQUFxQjtBQUMvQiJ9

package/dist/field/features/blocks/populationPromise.d.ts

@@ -0,0 +1,5 @@
+import type { PopulationPromise } from '../types';
+import type { BlocksFeatureProps } from './feature.server';
+import type { SerializedBlockNode } from './nodes/BlocksNode';
+export declare const blockPopulationPromiseHOC: (props: BlocksFeatureProps) => PopulationPromise<SerializedBlockNode>;
+//# sourceMappingURL=populationPromise.d.ts.map

package/dist/field/features/blocks/populationPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"populationPromise.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/populationPromise.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAI7D,eAAO,MAAM,yBAAyB,UAC7B,kBAAkB,KACxB,kBAAkB,mBAAmB,CA2DvC,CAAA"}

package/dist/field/features/blocks/populationPromise.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "blockPopulationPromiseHOC", {
+    enumerable: true,
+    get: function() {
+        return blockPopulationPromiseHOC;
+    }
+});
+const _config = require("payload/config");
+const _recurseNestedFields = require("../../../populate/recurseNestedFields");
+const blockPopulationPromiseHOC = (props)=>{
+    const blockPopulationPromise = ({ context, currentDepth, depth, editorPopulationPromises, findMany, flattenLocales, node, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc })=>{
+        const blocks = props.blocks;
+        const blockFieldData = node.fields;
+        const promises = [];
+        // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
+        const payloadConfig = req.payload.config;
+        const validRelationships = payloadConfig.collections.map((c)=>c.slug) || [];
+        blocks.forEach((block)=>{
+            block.fields = (0, _config.sanitizeFields)({
+                config: payloadConfig,
+                fields: block.fields,
+                validRelationships
+            });
+        });
+        // find block used in this node
+        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
+        if (!block || !block?.fields?.length || !blockFieldData) {
+            return promises;
+        }
+        (0, _recurseNestedFields.recurseNestedFields)({
+            context,
+            currentDepth,
+            data: blockFieldData,
+            depth,
+            editorPopulationPromises,
+            fields: block.fields,
+            findMany,
+            flattenLocales,
+            overrideAccess,
+            populationPromises,
+            promises,
+            req,
+            showHiddenFields,
+            // The afterReadPromise gets its data from looking for field.name inside the siblingDoc. Thus, here we cannot pass the whole document's siblingDoc, but only the siblingDoc (sibling fields) of the current field.
+            siblingDoc: blockFieldData
+        });
+        return promises;
+    };
+    return blockPopulationPromise;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/blocks/validate.d.ts

@@ -0,0 +1,5 @@
+import type { BlocksFeatureProps } from '@payloadcms/richtext-lexical';
+import type { NodeValidation } from '../types';
+import type { SerializedBlockNode } from './nodes/BlocksNode';
+export declare const blockValidationHOC: (props: BlocksFeatureProps) => NodeValidation<SerializedBlockNode>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/field/features/blocks/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../../src/field/features/blocks/validate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAKtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAE7D,eAAO,MAAM,kBAAkB,UACtB,kBAAkB,KACxB,eAAe,mBAAmB,CAkEpC,CAAA"}

package/dist/field/features/blocks/validate.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "blockValidationHOC", {
+    enumerable: true,
+    get: function() {
+        return blockValidationHOC;
+    }
+});
+const _config = require("payload/config");
+const blockValidationHOC = (props)=>{
+    const blockValidation = async ({ node, validation })=>{
+        const blockFieldData = node.fields;
+        const blocks = props.blocks;
+        const { options: { req, req: { payload: { config } } } } = validation;
+        // Sanitize block's fields here. This is done here and not in the feature, because the payload config is available here
+        const validRelationships = config.collections.map((c)=>c.slug) || [];
+        blocks.forEach((block)=>{
+            block.fields = (0, _config.sanitizeFields)({
+                config,
+                fields: block.fields,
+                validRelationships
+            });
+        });
+        // find block
+        const block = props.blocks.find((block)=>block.slug === blockFieldData.blockType);
+        // validate block
+        if (!block) {
+            return 'Block not found';
+        }
+        for (const field of block.fields){
+            if ('validate' in field && typeof field.validate === 'function' && field.validate) {
+                const fieldValue = 'name' in field ? node.fields[field.name] : null;
+                const passesCondition = field.admin?.condition ? Boolean(field.admin.condition(fieldValue, node.fields, {
+                    user: req?.user
+                })) : true;
+                if (!passesCondition) {
+                    continue; // Fixes https://github.com/payloadcms/payload/issues/4000
+                }
+                const validationResult = await field.validate(fieldValue, {
+                    ...field,
+                    id: validation.options.id,
+                    data: fieldValue,
+                    operation: validation.options.operation,
+                    req,
+                    siblingData: validation.options.siblingData
+                });
+                if (validationResult !== true) {
+                    return validationResult;
+                }
+            }
+        }
+        return true;
+    };
+    return blockValidation;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/field/features/common/floatingSelectToolbarFeaturesButtonsSection/index.js

@@ -10,11 +10,11 @@ Object.defineProperty(exports, "FeaturesSectionWithEntries", {
 });
 const FeaturesSectionWithEntries = (entries)=>{
     return {
+        type: 'buttons',
         entries,
         key: 'features',
-        order: 5,
-        type: 'buttons'
+        order: 5
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9jb21tb24vZmxvYXRpbmdTZWxlY3RUb29sYmFyRmVhdHVyZXNCdXR0b25zU2VjdGlvbi9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb24sXG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSxcbn0gZnJvbSAnLi4vLi4vLi4vbGV4aWNhbC9wbHVnaW5zL0Zsb2F0aW5nU2VsZWN0VG9vbGJhci90eXBlcydcblxuZXhwb3J0IGNvbnN0IEZlYXR1cmVzU2VjdGlvbldpdGhFbnRyaWVzID0gKFxuICBlbnRyaWVzOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uRW50cnlbXSxcbik6IEZsb2F0aW5nVG9vbGJhclNlY3Rpb24gPT4ge1xuICByZXR1cm4ge1xuICAgIGVudHJpZXMsXG4gICAga2V5OiAnZmVhdHVyZXMnLFxuICAgIG9yZGVyOiA1LFxuICAgIHR5cGU6ICdidXR0b25zJyxcbiAgfVxufVxuIl0sIm5hbWVzIjpbIkZlYXR1cmVzU2VjdGlvbldpdGhFbnRyaWVzIiwiZW50cmllcyIsImtleSIsIm9yZGVyIiwidHlwZSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsNkJBQTZCLENBQ3hDQztJQUVBLE9BQU87UUFDTEE7UUFDQUMsS0FBSztRQUNMQyxPQUFPO1FBQ1BDLE1BQU07SUFDUjtBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9maWVsZC9mZWF0dXJlcy9jb21tb24vZmxvYXRpbmdTZWxlY3RUb29sYmFyRmVhdHVyZXNCdXR0b25zU2VjdGlvbi9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb24sXG4gIEZsb2F0aW5nVG9vbGJhclNlY3Rpb25FbnRyeSxcbn0gZnJvbSAnLi4vLi4vLi4vbGV4aWNhbC9wbHVnaW5zL0Zsb2F0aW5nU2VsZWN0VG9vbGJhci90eXBlcydcblxuZXhwb3J0IGNvbnN0IEZlYXR1cmVzU2VjdGlvbldpdGhFbnRyaWVzID0gKFxuICBlbnRyaWVzOiBGbG9hdGluZ1Rvb2xiYXJTZWN0aW9uRW50cnlbXSxcbik6IEZsb2F0aW5nVG9vbGJhclNlY3Rpb24gPT4ge1xuICByZXR1cm4ge1xuICAgIHR5cGU6ICdidXR0b25zJyxcbiAgICBlbnRyaWVzLFxuICAgIGtleTogJ2ZlYXR1cmVzJyxcbiAgICBvcmRlcjogNSxcbiAgfVxufVxuIl0sIm5hbWVzIjpbIkZlYXR1cmVzU2VjdGlvbldpdGhFbnRyaWVzIiwiZW50cmllcyIsInR5cGUiLCJrZXkiLCJvcmRlciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFLYUE7OztlQUFBQTs7O0FBQU4sTUFBTUEsNkJBQTZCLENBQ3hDQztJQUVBLE9BQU87UUFDTEMsTUFBTTtRQUNORDtRQUNBRSxLQUFLO1FBQ0xDLE9BQU87SUFDVDtBQUNGIn0=

package/dist/field/features/common/floatingSelectToolbarTextDropdownSection/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,sDAAsD,CAAA;AAE7D,eAAO,MAAM,8BAA8B,YAChC,2BAA2B,EAAE,KACrC,sBAUF,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/field/features/common/floatingSelectToolbarTextDropdownSection/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC5B,MAAM,sDAAsD,CAAA;AAI7D,eAAO,MAAM,8BAA8B,YAChC,2BAA2B,EAAE,KACrC,sBAQF,CAAA"}