@payloadcms/richtext-lexical 3.0.0-canary.95fcd13 → 3.0.0-canary.9beaa28

package/dist/features/converters/html/converter/types.js

@@ -1,3 +1,2 @@
-export { };
-
+export {};
 //# sourceMappingURL=types.js.map

package/dist/features/converters/html/converter/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/html/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { Payload, PayloadRequest } from 'payload'\n\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    node,\n    parent,\n    req,\n  }: {\n    childIndex: number\n    converters: HTMLConverter[]\n    node: T\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, req CAN be passed in depending on where it's run.\n     */\n    req: PayloadRequest | null\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"names":[],"mappings":"AAuBA,WAEyB"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/html/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nimport type { PayloadRequest } from 'payload'\n\nexport type HTMLConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: (args: {\n    childIndex: number\n    converters: HTMLConverter<any>[]\n    draft: boolean\n    node: T\n    overrideAccess: boolean\n    parent: SerializedLexicalNodeWithParent\n    /**\n     * When the converter is called, req CAN be passed in depending on where it's run.\n     */\n    req: PayloadRequest | null\n    showHiddenFields: boolean\n  }) => Promise<string> | string\n  nodeTypes: string[]\n}\n\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AAoBA","ignoreList":[]}

package/dist/features/converters/html/field/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAqC,MAAM,SAAS,CAAA;AAEvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAA;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAM1D,KAAK,KAAK,GAAG;IACX;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,sBAEnC;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,aAAa,EA+ChB,CAAA;AA0DD,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,KAAK,KACT,KA6EJ,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/html/field/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAqC,MAAM,SAAS,CAAA;AAEvE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qCAAqC,CAAA;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAM1D,KAAK,KAAK,GAAG;IACX;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,sBAEnC;IACD,YAAY,EAAE,2BAA2B,CAAA;CAC1C,KAAG,aAAa,EA+ChB,CAAA;AA0DD,eAAO,MAAM,WAAW,EAAE;AACxB;;;;IAII;AACJ,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,KAAK,KACT,KAyFJ,CAAA"}

package/dist/features/converters/html/field/index.js

@@ -4,151 +4,149 @@ import { convertLexicalToHTML } from '../converter/index.js';
  * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.
  *
  * @param editorConfig
- */ export const consolidateHTMLConverters = ({ editorConfig })=>{
-    const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter');
-    const htmlConverterFeatureProps = htmlConverterFeature?.sanitizedServerFeatureProps;
-    const defaultConvertersWithConvertersFromFeatures = [
-        ...defaultHTMLConverters
-    ];
-    for (const converter of editorConfig.features.converters.html){
-        defaultConvertersWithConvertersFromFeatures.push(converter);
+ */
+export const consolidateHTMLConverters = ({
+  editorConfig
+}) => {
+  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter');
+  const htmlConverterFeatureProps = htmlConverterFeature?.sanitizedServerFeatureProps;
+  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters];
+  for (const converter of editorConfig.features.converters.html) {
+    defaultConvertersWithConvertersFromFeatures.push(converter);
+  }
+  const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
+    defaultConverters: defaultConvertersWithConvertersFromFeatures
+  }) : htmlConverterFeatureProps?.converters || defaultConvertersWithConvertersFromFeatures;
+  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from
+  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.
+  // This guarantees that user-added converters which are added after the default ones will always have precedence
+  const foundNodeTypes = [];
+  const filteredConverters = [];
+  for (const converter of finalConverters.reverse()) {
+    if (!converter.nodeTypes?.length) {
+      continue;
     }
-    const finalConverters = htmlConverterFeatureProps?.converters && typeof htmlConverterFeatureProps?.converters === 'function' ? htmlConverterFeatureProps.converters({
-        defaultConverters: defaultConvertersWithConvertersFromFeatures
-    }) : htmlConverterFeatureProps?.converters || defaultConvertersWithConvertersFromFeatures;
-    // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from
-    // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.
-    // This guarantees that user-added converters which are added after the default ones will always have precedence
-    const foundNodeTypes = [];
-    const filteredConverters = [];
-    for (const converter of finalConverters.reverse()){
-        if (!converter.nodeTypes?.length) {
-            continue;
-        }
-        const newConverter = {
-            converter: converter.converter,
-            nodeTypes: [
-                ...converter.nodeTypes
-            ]
-        };
-        newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType)=>{
-            if (foundNodeTypes.includes(nodeType)) {
-                return false;
-            }
-            foundNodeTypes.push(nodeType);
-            return true;
-        });
-        if (newConverter.nodeTypes.length) {
-            filteredConverters.push(newConverter);
-        }
+    const newConverter = {
+      converter: converter.converter,
+      nodeTypes: [...converter.nodeTypes]
+    };
+    newConverter.nodeTypes = newConverter.nodeTypes.filter(nodeType => {
+      if (foundNodeTypes.includes(nodeType)) {
+        return false;
+      }
+      foundNodeTypes.push(nodeType);
+      return true;
+    });
+    if (newConverter.nodeTypes.length) {
+      filteredConverters.push(newConverter);
     }
-    return filteredConverters;
+  }
+  return filteredConverters;
 };
 // find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively
 function findFieldPathAndSiblingFields(fields, path, field) {
-    for (const curField of fields){
-        if (curField === field) {
-            return {
-                path: [
-                    ...path,
-                    curField.name
-                ],
-                siblingFields: fields
-            };
+  for (const curField of fields) {
+    if (curField === field) {
+      return {
+        path: [...path, curField.name],
+        siblingFields: fields
+      };
+    }
+    if ('fields' in curField) {
+      const result = findFieldPathAndSiblingFields(curField.fields, 'name' in curField ? [...path, curField.name] : [...path], field);
+      if (result) {
+        return result;
+      }
+    } else if ('tabs' in curField) {
+      for (const tab of curField.tabs) {
+        const result = findFieldPathAndSiblingFields(tab.fields, 'name' in tab ? [...path, tab.name] : [...path], field);
+        if (result) {
+          return result;
         }
-        if ('fields' in curField) {
-            const result = findFieldPathAndSiblingFields(curField.fields, 'name' in curField ? [
-                ...path,
-                curField.name
-            ] : [
-                ...path
-            ], field);
-            if (result) {
-                return result;
-            }
-        } else if ('tabs' in curField) {
-            for (const tab of curField.tabs){
-                const result = findFieldPathAndSiblingFields(tab.fields, 'name' in tab ? [
-                    ...path,
-                    tab.name
-                ] : [
-                    ...path
-                ], field);
-                if (result) {
-                    return result;
-                }
-            }
-        } else if ('blocks' in curField) {
-            for (const block of curField.blocks){
-                if (block?.fields?.length) {
-                    const result = findFieldPathAndSiblingFields(block.fields, [
-                        ...path,
-                        curField.name,
-                        block.slug
-                    ], field);
-                    if (result) {
-                        return result;
-                    }
-                }
-            }
+      }
+    } else if ('blocks' in curField) {
+      for (const block of curField.blocks) {
+        if (block?.fields?.length) {
+          const result = findFieldPathAndSiblingFields(block.fields, [...path, curField.name, block.slug], field);
+          if (result) {
+            return result;
+          }
         }
+      }
     }
-    return null;
+  }
+  return null;
 }
-export const lexicalHTML = (lexicalFieldName, props)=>{
-    const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props;
-    return {
-        name,
-        type: 'code',
-        admin: {
-            editorOptions: {
-                language: 'html'
-            },
-            hidden
-        },
-        hooks: {
-            afterRead: [
-                async ({ collection, field, global, req, siblingData })=>{
-                    const fields = collection ? collection.fields : global.fields;
-                    const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field);
-                    if (!foundSiblingFields) throw new Error(`Could not find sibling fields of current lexicalHTML field with name ${field?.name}`);
-                    const { siblingFields } = foundSiblingFields;
-                    const lexicalField = siblingFields.find((field)=>'name' in field && field.name === lexicalFieldName);
-                    const lexicalFieldData = siblingData[lexicalFieldName];
-                    if (!lexicalFieldData) {
-                        return '';
-                    }
-                    if (!lexicalField) {
-                        throw new Error('You cannot use the lexicalHTML field because the referenced lexical field was not found');
-                    }
-                    const config = lexicalField?.editor?.editorConfig;
-                    if (!config) {
-                        throw new Error('The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.');
-                    }
-                    if (!config?.resolvedFeatureMap?.has('htmlConverter')) {
-                        throw new Error('You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature');
-                    }
-                    const finalConverters = consolidateHTMLConverters({
-                        editorConfig: config
-                    });
-                    return await convertLexicalToHTML({
-                        converters: finalConverters,
-                        data: lexicalFieldData,
-                        req
-                    });
-                }
-            ],
-            beforeChange: [
-                ({ siblingData, value })=>{
-                    if (storeInDB) {
-                        return value;
-                    }
-                    delete siblingData[name];
-                    return null;
-                }
-            ]
+export const lexicalHTML = (lexicalFieldName, props) => {
+  const {
+    name = 'lexicalHTML',
+    hidden = true,
+    storeInDB = false
+  } = props;
+  return {
+    name,
+    type: 'code',
+    admin: {
+      editorOptions: {
+        language: 'html'
+      },
+      hidden
+    },
+    hooks: {
+      afterRead: [async ({
+        collection,
+        draft,
+        field,
+        global,
+        overrideAccess,
+        req,
+        showHiddenFields,
+        siblingData
+      }) => {
+        const fields = collection ? collection.fields : global.fields;
+        const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field);
+        if (!foundSiblingFields) throw new Error(`Could not find sibling fields of current lexicalHTML field with name ${field?.name}`);
+        const {
+          siblingFields
+        } = foundSiblingFields;
+        const lexicalField = siblingFields.find(field => 'name' in field && field.name === lexicalFieldName);
+        const lexicalFieldData = siblingData[lexicalFieldName];
+        if (!lexicalFieldData) {
+          return '';
         }
-    };
+        if (!lexicalField) {
+          throw new Error('You cannot use the lexicalHTML field because the referenced lexical field was not found');
+        }
+        const config = lexicalField?.editor?.editorConfig;
+        if (!config) {
+          throw new Error('The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.');
+        }
+        if (!config?.resolvedFeatureMap?.has('htmlConverter')) {
+          throw new Error('You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature');
+        }
+        const finalConverters = consolidateHTMLConverters({
+          editorConfig: config
+        });
+        return await convertLexicalToHTML({
+          converters: finalConverters,
+          data: lexicalFieldData,
+          draft,
+          overrideAccess,
+          req,
+          showHiddenFields
+        });
+      }],
+      beforeChange: [({
+        siblingData,
+        value
+      }) => {
+        if (storeInDB) {
+          return value;
+        }
+        delete siblingData[name];
+        return null;
+      }]
+    }
+  };
 };
-
 //# sourceMappingURL=index.js.map

package/dist/features/converters/html/field/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/features/converters/html/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, FieldAffectingData, RichTextField } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js'\nimport type { AdapterProps, LexicalRichTextAdapter } from '../../../../types.js'\nimport type { HTMLConverter } from '../converter/types.js'\nimport type { HTMLConverterFeatureProps } from '../feature.server.js'\n\nimport { defaultHTMLConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToHTML } from '../converter/index.js'\n\ntype Props = {\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  name: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}): HTMLConverter[] => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps =\n    htmlConverterFeature?.sanitizedServerFeatureProps\n\n  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters]\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from\n  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.\n  // This guarantees that user-added converters which are added after the default ones will always have precedence\n  const foundNodeTypes: string[] = []\n  const filteredConverters: HTMLConverter[] = []\n  for (const converter of finalConverters.reverse()) {\n    if (!converter.nodeTypes?.length) {\n      continue\n    }\n    const newConverter: HTMLConverter = {\n      converter: converter.converter,\n      nodeTypes: [...converter.nodeTypes],\n    }\n    newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType) => {\n      if (foundNodeTypes.includes(nodeType)) {\n        return false\n      }\n      foundNodeTypes.push(nodeType)\n      return true\n    })\n\n    if (newConverter.nodeTypes.length) {\n      filteredConverters.push(newConverter)\n    }\n  }\n\n  return filteredConverters\n}\n\n// find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively\nfunction findFieldPathAndSiblingFields(\n  fields: Field[],\n  path: string[],\n  field: FieldAffectingData,\n): {\n  path: string[]\n  siblingFields: Field[]\n} {\n  for (const curField of fields) {\n    if (curField === field) {\n      return {\n        path: [...path, curField.name],\n        siblingFields: fields,\n      }\n    }\n\n    if ('fields' in curField) {\n      const result = findFieldPathAndSiblingFields(\n        curField.fields,\n        'name' in curField ? [...path, curField.name] : [...path],\n        field,\n      )\n      if (result) {\n        return result\n      }\n    } else if ('tabs' in curField) {\n      for (const tab of curField.tabs) {\n        const result = findFieldPathAndSiblingFields(\n          tab.fields,\n          'name' in tab ? [...path, tab.name] : [...path],\n          field,\n        )\n        if (result) {\n          return result\n        }\n      }\n    } else if ('blocks' in curField) {\n      for (const block of curField.blocks) {\n        if (block?.fields?.length) {\n          const result = findFieldPathAndSiblingFields(\n            block.fields,\n            [...path, curField.name, block.slug],\n            field,\n          )\n          if (result) {\n            return result\n          }\n        }\n      }\n    }\n  }\n\n  return null\n}\n\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  props: Props,\n) => Field = (lexicalFieldName, props) => {\n  const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props\n  return {\n    name,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({ collection, field, global, req, siblingData }) => {\n          const fields = collection ? collection.fields : global.fields\n\n          const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field)\n\n          if (!foundSiblingFields)\n            throw new Error(\n              `Could not find sibling fields of current lexicalHTML field with name ${field?.name}`,\n            )\n\n          const { siblingFields } = foundSiblingFields\n          const lexicalField: RichTextField<SerializedEditorState, AdapterProps> =\n            siblingFields.find(\n              (field) => 'name' in field && field.name === lexicalFieldName,\n            ) as RichTextField<SerializedEditorState, AdapterProps>\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            data: lexicalFieldData,\n            req,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[name]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"names":["defaultHTMLConverters","convertLexicalToHTML","consolidateHTMLConverters","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","sanitizedServerFeatureProps","defaultConvertersWithConvertersFromFeatures","converter","features","converters","html","push","finalConverters","defaultConverters","foundNodeTypes","filteredConverters","reverse","nodeTypes","length","newConverter","filter","nodeType","includes","findFieldPathAndSiblingFields","fields","path","field","curField","name","siblingFields","result","tab","tabs","block","blocks","slug","lexicalHTML","lexicalFieldName","props","hidden","storeInDB","type","admin","editorOptions","language","hooks","afterRead","collection","global","req","siblingData","foundSiblingFields","Error","lexicalField","find","lexicalFieldData","config","editor","has","data","beforeChange","value"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["defaultHTMLConverters","convertLexicalToHTML","consolidateHTMLConverters","editorConfig","htmlConverterFeature","resolvedFeatureMap","get","htmlConverterFeatureProps","sanitizedServerFeatureProps","defaultConvertersWithConvertersFromFeatures","converter","features","converters","html","push","finalConverters","defaultConverters","foundNodeTypes","filteredConverters","reverse","nodeTypes","length","newConverter","filter","nodeType","includes","findFieldPathAndSiblingFields","fields","path","field","curField","name","siblingFields","result","tab","tabs","block","blocks","slug","lexicalHTML","lexicalFieldName","props","hidden","storeInDB","type","admin","editorOptions","language","hooks","afterRead","collection","draft","global","overrideAccess","req","showHiddenFields","siblingData","foundSiblingFields","Error","lexicalField","find","lexicalFieldData","config","editor","has","data","beforeChange","value"],"sources":["../../../../../src/features/converters/html/field/index.ts"],"sourcesContent":["import type { SerializedEditorState } from 'lexical'\nimport type { Field, FieldAffectingData, RichTextField } from 'payload'\n\nimport type { SanitizedServerEditorConfig } from '../../../../lexical/config/types.js'\nimport type { AdapterProps, LexicalRichTextAdapter } from '../../../../types.js'\nimport type { HTMLConverter } from '../converter/types.js'\nimport type { HTMLConverterFeatureProps } from '../index.js'\n\nimport { defaultHTMLConverters } from '../converter/defaultConverters.js'\nimport { convertLexicalToHTML } from '../converter/index.js'\n\ntype Props = {\n  /**\n   * Whether the lexicalHTML field should be hidden in the admin panel\n   *\n   * @default true\n   */\n  hidden?: boolean\n  name: string\n  /**\n   * Whether the HTML should be stored in the database\n   *\n   * @default false\n   */\n  storeInDB?: boolean\n}\n\n/**\n * Combines the default HTML converters with HTML converters found in the features, and with HTML converters configured in the htmlConverter feature.\n *\n * @param editorConfig\n */\nexport const consolidateHTMLConverters = ({\n  editorConfig,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n}): HTMLConverter[] => {\n  const htmlConverterFeature = editorConfig.resolvedFeatureMap.get('htmlConverter')\n  const htmlConverterFeatureProps: HTMLConverterFeatureProps =\n    htmlConverterFeature?.sanitizedServerFeatureProps\n\n  const defaultConvertersWithConvertersFromFeatures = [...defaultHTMLConverters]\n\n  for (const converter of editorConfig.features.converters.html) {\n    defaultConvertersWithConvertersFromFeatures.push(converter)\n  }\n\n  const finalConverters =\n    htmlConverterFeatureProps?.converters &&\n    typeof htmlConverterFeatureProps?.converters === 'function'\n      ? htmlConverterFeatureProps.converters({\n          defaultConverters: defaultConvertersWithConvertersFromFeatures,\n        })\n      : (htmlConverterFeatureProps?.converters as HTMLConverter[]) ||\n        defaultConvertersWithConvertersFromFeatures\n\n  // filter converters by nodeTypes. The last converter in the list wins. If there are multiple converters for the same nodeType, the last one will be used and the node types will be removed from\n  // previous converters. If previous converters do not have any nodeTypes left, they will be removed from the list.\n  // This guarantees that user-added converters which are added after the default ones will always have precedence\n  const foundNodeTypes: string[] = []\n  const filteredConverters: HTMLConverter[] = []\n  for (const converter of finalConverters.reverse()) {\n    if (!converter.nodeTypes?.length) {\n      continue\n    }\n    const newConverter: HTMLConverter = {\n      converter: converter.converter,\n      nodeTypes: [...converter.nodeTypes],\n    }\n    newConverter.nodeTypes = newConverter.nodeTypes.filter((nodeType) => {\n      if (foundNodeTypes.includes(nodeType)) {\n        return false\n      }\n      foundNodeTypes.push(nodeType)\n      return true\n    })\n\n    if (newConverter.nodeTypes.length) {\n      filteredConverters.push(newConverter)\n    }\n  }\n\n  return filteredConverters\n}\n\n// find the path of this field, as well as its sibling fields, by looking for this `field` in fields and traversing it recursively\nfunction findFieldPathAndSiblingFields(\n  fields: Field[],\n  path: string[],\n  field: FieldAffectingData,\n): {\n  path: string[]\n  siblingFields: Field[]\n} {\n  for (const curField of fields) {\n    if (curField === field) {\n      return {\n        path: [...path, curField.name],\n        siblingFields: fields,\n      }\n    }\n\n    if ('fields' in curField) {\n      const result = findFieldPathAndSiblingFields(\n        curField.fields,\n        'name' in curField ? [...path, curField.name] : [...path],\n        field,\n      )\n      if (result) {\n        return result\n      }\n    } else if ('tabs' in curField) {\n      for (const tab of curField.tabs) {\n        const result = findFieldPathAndSiblingFields(\n          tab.fields,\n          'name' in tab ? [...path, tab.name] : [...path],\n          field,\n        )\n        if (result) {\n          return result\n        }\n      }\n    } else if ('blocks' in curField) {\n      for (const block of curField.blocks) {\n        if (block?.fields?.length) {\n          const result = findFieldPathAndSiblingFields(\n            block.fields,\n            [...path, curField.name, block.slug],\n            field,\n          )\n          if (result) {\n            return result\n          }\n        }\n      }\n    }\n  }\n\n  return null\n}\n\nexport const lexicalHTML: (\n  /**\n   * A string which matches the lexical field name you want to convert to HTML.\n   *\n   * This has to be a SIBLING field of this lexicalHTML field - otherwise, it won't be able to find the lexical field.\n   **/\n  lexicalFieldName: string,\n  props: Props,\n) => Field = (lexicalFieldName, props) => {\n  const { name = 'lexicalHTML', hidden = true, storeInDB = false } = props\n  return {\n    name,\n    type: 'code',\n    admin: {\n      editorOptions: {\n        language: 'html',\n      },\n      hidden,\n    },\n    hooks: {\n      afterRead: [\n        async ({\n          collection,\n          draft,\n          field,\n          global,\n          overrideAccess,\n          req,\n          showHiddenFields,\n          siblingData,\n        }) => {\n          const fields = collection ? collection.fields : global.fields\n\n          const foundSiblingFields = findFieldPathAndSiblingFields(fields, [], field)\n\n          if (!foundSiblingFields)\n            throw new Error(\n              `Could not find sibling fields of current lexicalHTML field with name ${field?.name}`,\n            )\n\n          const { siblingFields } = foundSiblingFields\n          const lexicalField: RichTextField<SerializedEditorState, AdapterProps> =\n            siblingFields.find(\n              (field) => 'name' in field && field.name === lexicalFieldName,\n            ) as RichTextField<SerializedEditorState, AdapterProps>\n\n          const lexicalFieldData: SerializedEditorState = siblingData[lexicalFieldName]\n\n          if (!lexicalFieldData) {\n            return ''\n          }\n\n          if (!lexicalField) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the referenced lexical field was not found',\n            )\n          }\n\n          const config = (lexicalField?.editor as LexicalRichTextAdapter)?.editorConfig\n\n          if (!config) {\n            throw new Error(\n              'The linked lexical field does not have an editorConfig. This is needed for the lexicalHTML field.',\n            )\n          }\n\n          if (!config?.resolvedFeatureMap?.has('htmlConverter')) {\n            throw new Error(\n              'You cannot use the lexicalHTML field because the linked lexical field does not have a HTMLConverterFeature',\n            )\n          }\n\n          const finalConverters = consolidateHTMLConverters({\n            editorConfig: config,\n          })\n\n          return await convertLexicalToHTML({\n            converters: finalConverters,\n            data: lexicalFieldData,\n            draft,\n            overrideAccess,\n            req,\n            showHiddenFields,\n          })\n        },\n      ],\n      beforeChange: [\n        ({ siblingData, value }) => {\n          if (storeInDB) {\n            return value\n          }\n          delete siblingData[name]\n          return null\n        },\n      ],\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/converters/html/index.d.ts

@@ -0,0 +1,8 @@
+import type { HTMLConverter } from './converter/types.js';
+export type HTMLConverterFeatureProps = {
+    converters?: (({ defaultConverters }: {
+        defaultConverters: HTMLConverter<any>[];
+    }) => HTMLConverter<any>[]) | HTMLConverter<any>[];
+};
+export declare const HTMLConverterFeature: import("../../typesServer.js").FeatureProviderProviderServer<HTMLConverterFeatureProps, HTMLConverterFeatureProps, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/html/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/html/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIzD,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;KAAE,KAAK,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,GAC9F,aAAa,CAAC,GAAG,CAAC,EAAE,CAAA;CACzB,CAAA;AAGD,eAAO,MAAM,oBAAoB,+HAG/B,CAAA"}

package/dist/features/converters/html/index.js

@@ -0,0 +1,7 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+// This is just used to save the props on the richText field
+export const HTMLConverterFeature = createServerFeature({
+  feature: {},
+  key: 'htmlConverter'
+});
+//# sourceMappingURL=index.js.map

package/dist/features/converters/html/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createServerFeature","HTMLConverterFeature","feature","key"],"sources":["../../../../src/features/converters/html/index.ts"],"sourcesContent":["import type { HTMLConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\n\nexport type HTMLConverterFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: HTMLConverter<any>[] }) => HTMLConverter<any>[])\n    | HTMLConverter<any>[]\n}\n\n// This is just used to save the props on the richText field\nexport const HTMLConverterFeature = createServerFeature<HTMLConverterFeatureProps>({\n  feature: {},\n  key: 'htmlConverter',\n})\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AAQpC;AACA,OAAO,MAAMC,oBAAA,GAAuBD,mBAAA,CAA+C;EACjFE,OAAA,EAAS,CAAC;EACVC,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/createClientComponent.d.ts

@@ -1,7 +1,7 @@
-import type { FeatureProviderProviderClient } from './typesClient.js';
-import type { ServerFeature } from './typesServer.js';
+import type React from 'react';
+import type { ClientComponentProps, FeatureProviderProviderClient } from './typesClient.js';
 /**
  * Utility function to create a client component for the client feature
  */
-export declare const createClientComponent: <ClientFeatureProps>(clientFeature: FeatureProviderProviderClient<ClientFeatureProps>) => ServerFeature<unknown, ClientFeatureProps>["ClientFeature"];
+export declare const createClientComponent: <ClientFeatureProps>(clientFeature: FeatureProviderProviderClient<ClientFeatureProps>) => React.FC<ClientComponentProps<ClientFeatureProps>>;
 //# sourceMappingURL=createClientComponent.d.ts.map

package/dist/features/createClientComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createClientComponent.d.ts","sourceRoot":"","sources":["../../src/features/createClientComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAIrD;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,kBAAkB,iBACvC,6BAA6B,CAAC,kBAAkB,CAAC,KAC/D,aAAa,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,eAAe,CAK5D,CAAA"}
+{"version":3,"file":"createClientComponent.d.ts","sourceRoot":"","sources":["../../src/features/createClientComponent.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAA;AAI3F;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,kBAAkB,iBACvC,6BAA6B,CAAC,kBAAkB,CAAC,KAC/D,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,CAKnD,CAAA"}

package/dist/features/createClientComponent.js

@@ -1,12 +1,13 @@
 'use client';
+
 import { useLexicalFeature } from '../utilities/useLexicalFeature.js';
 /**
  * Utility function to create a client component for the client feature
- */ export const createClientComponent = (clientFeature)=>{
-    return (props)=>{
-        useLexicalFeature(props.featureKey, clientFeature(props));
-        return null;
-    };
+ */
+export const createClientComponent = clientFeature => {
+  return props => {
+    useLexicalFeature(props.featureKey, clientFeature(props));
+    return null;
+  };
 };
-
 //# sourceMappingURL=createClientComponent.js.map

package/dist/features/createClientComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/features/createClientComponent.tsx"],"sourcesContent":["'use client'\n\nimport type { FeatureProviderProviderClient } from './typesClient.js'\nimport type { ServerFeature } from './typesServer.js'\n\nimport { useLexicalFeature } from '../utilities/useLexicalFeature.js'\n\n/**\n * Utility function to create a client component for the client feature\n */\nexport const createClientComponent = <ClientFeatureProps,>(\n  clientFeature: FeatureProviderProviderClient<ClientFeatureProps>,\n): ServerFeature<unknown, ClientFeatureProps>['ClientFeature'] => {\n  return (props) => {\n    useLexicalFeature(props.featureKey, clientFeature(props))\n    return null\n  }\n}\n"],"names":["useLexicalFeature","createClientComponent","clientFeature","props","featureKey"],"mappings":"AAAA;AAKA,SAASA,iBAAiB,QAAQ,oCAAmC;AAErE;;CAEC,GACD,OAAO,MAAMC,wBAAwB,CACnCC;IAEA,OAAO,CAACC;QACNH,kBAAkBG,MAAMC,UAAU,EAAEF,cAAcC;QAClD,OAAO;IACT;AACF,EAAC"}
+{"version":3,"file":"createClientComponent.js","names":["useLexicalFeature","createClientComponent","clientFeature","props","featureKey"],"sources":["../../src/features/createClientComponent.tsx"],"sourcesContent":["'use client'\n\nimport type React from 'react'\n\nimport type { ClientComponentProps, FeatureProviderProviderClient } from './typesClient.js'\n\nimport { useLexicalFeature } from '../utilities/useLexicalFeature.js'\n\n/**\n * Utility function to create a client component for the client feature\n */\nexport const createClientComponent = <ClientFeatureProps,>(\n  clientFeature: FeatureProviderProviderClient<ClientFeatureProps>,\n): React.FC<ClientComponentProps<ClientFeatureProps>> => {\n  return (props) => {\n    useLexicalFeature(props.featureKey, clientFeature(props))\n    return null\n  }\n}\n"],"mappings":"AAAA;;AAMA,SAASA,iBAAiB,QAAQ;AAElC;;;AAGA,OAAO,MAAMC,qBAAA,GACXC,aAAA;EAEA,OAAQC,KAAA;IACNH,iBAAA,CAAkBG,KAAA,CAAMC,UAAU,EAAEF,aAAA,CAAcC,KAAA;IAClD,OAAO;EACT;AACF","ignoreList":[]}

package/dist/features/createFeaturePropComponent.js

@@ -1,18 +1,19 @@
 'use client';
+
 import { useAddClientFunction, useFieldProps, useTableCell } from '@payloadcms/ui';
-const useLexicalFeatureProp = (featureKey, componentKey, prop)=>{
-    const { schemaPath: schemaPathFromFieldProps } = useFieldProps();
-    const tableCell = useTableCell();
-    const schemaPathFromCellProps = tableCell?.cellProps?.schemaPath;
-    const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.
-    ;
-    useAddClientFunction(`lexicalFeature.${schemaPath}.${featureKey}.lexical_internal_components.${componentKey}`, prop);
+const useLexicalFeatureProp = (featureKey, componentKey, prop) => {
+  const {
+    schemaPath: schemaPathFromFieldProps
+  } = useFieldProps();
+  const tableCell = useTableCell();
+  const schemaPathFromCellProps = tableCell?.cellProps?.field?._schemaPath;
+  const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps;
+  useAddClientFunction(`lexicalFeature.${schemaPath}.${featureKey}.lexical_internal_components.${componentKey}`, prop);
 };
-export const createFeaturePropComponent = (prop)=>{
-    return (props)=>{
-        useLexicalFeatureProp(props.featureKey, props.componentKey, prop);
-        return null;
-    };
+export const createFeaturePropComponent = prop => {
+  return props => {
+    useLexicalFeatureProp(props.featureKey, props.componentKey, prop);
+    return null;
+  };
 };
-
 //# sourceMappingURL=createFeaturePropComponent.js.map

package/dist/features/createFeaturePropComponent.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/features/createFeaturePropComponent.tsx"],"sourcesContent":["'use client'\n\nimport type React from 'react'\n\nimport { useAddClientFunction, useFieldProps, useTableCell } from '@payloadcms/ui'\n\nconst useLexicalFeatureProp = <T,>(featureKey: string, componentKey: string, prop: T) => {\n  const { schemaPath: schemaPathFromFieldProps } = useFieldProps()\n  const tableCell = useTableCell()\n\n  const schemaPathFromCellProps = tableCell?.cellProps?.schemaPath\n\n  const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.\n\n  useAddClientFunction(\n    `lexicalFeature.${schemaPath}.${featureKey}.lexical_internal_components.${componentKey}`,\n    prop,\n  )\n}\n\nexport const createFeaturePropComponent = <T = unknown,>(\n  prop: T,\n): React.FC<{ componentKey: string; featureKey: string }> => {\n  return (props) => {\n    useLexicalFeatureProp(props.featureKey, props.componentKey, prop)\n    return null\n  }\n}\n"],"names":["useAddClientFunction","useFieldProps","useTableCell","useLexicalFeatureProp","featureKey","componentKey","prop","schemaPath","schemaPathFromFieldProps","tableCell","schemaPathFromCellProps","cellProps","createFeaturePropComponent","props"],"mappings":"AAAA;AAIA,SAASA,oBAAoB,EAAEC,aAAa,EAAEC,YAAY,QAAQ,iBAAgB;AAElF,MAAMC,wBAAwB,CAAKC,YAAoBC,cAAsBC;IAC3E,MAAM,EAAEC,YAAYC,wBAAwB,EAAE,GAAGP;IACjD,MAAMQ,YAAYP;IAElB,MAAMQ,0BAA0BD,WAAWE,WAAWJ;IAEtD,MAAMA,aAAaG,2BAA2BF,yBAAyB,iOAAiO;;IAExSR,qBACE,CAAC,eAAe,EAAEO,WAAW,CAAC,EAAEH,WAAW,6BAA6B,EAAEC,aAAa,CAAC,EACxFC;AAEJ;AAEA,OAAO,MAAMM,6BAA6B,CACxCN;IAEA,OAAO,CAACO;QACNV,sBAAsBU,MAAMT,UAAU,EAAES,MAAMR,YAAY,EAAEC;QAC5D,OAAO;IACT;AACF,EAAC"}
+{"version":3,"file":"createFeaturePropComponent.js","names":["useAddClientFunction","useFieldProps","useTableCell","useLexicalFeatureProp","featureKey","componentKey","prop","schemaPath","schemaPathFromFieldProps","tableCell","schemaPathFromCellProps","cellProps","field","_schemaPath","createFeaturePropComponent","props"],"sources":["../../src/features/createFeaturePropComponent.tsx"],"sourcesContent":["'use client'\n\nimport type React from 'react'\n\nimport { useAddClientFunction, useFieldProps, useTableCell } from '@payloadcms/ui'\n\nconst useLexicalFeatureProp = <T,>(featureKey: string, componentKey: string, prop: T) => {\n  const { schemaPath: schemaPathFromFieldProps } = useFieldProps()\n  const tableCell = useTableCell()\n\n  const schemaPathFromCellProps = tableCell?.cellProps?.field?._schemaPath\n\n  const schemaPath = schemaPathFromCellProps || schemaPathFromFieldProps // schemaPathFromCellProps needs to have priority, as there can be cells within fields (e.g. list drawers) and the cell schemaPath needs to be used there - not the parent field schemaPath. There cannot be fields within cells.\n\n  useAddClientFunction(\n    `lexicalFeature.${schemaPath}.${featureKey}.lexical_internal_components.${componentKey}`,\n    prop,\n  )\n}\n\nexport const createFeaturePropComponent = <T = unknown,>(\n  prop: T,\n): React.FC<{ componentKey: string; featureKey: string }> => {\n  return (props) => {\n    useLexicalFeatureProp(props.featureKey, props.componentKey, prop)\n    return null\n  }\n}\n"],"mappings":"AAAA;;AAIA,SAASA,oBAAoB,EAAEC,aAAa,EAAEC,YAAY,QAAQ;AAElE,MAAMC,qBAAA,GAAwBA,CAAAC,UAAA,EAAAC,YAAA,EAAAC,IAAA;EAC5B;IAAAC,UAAA,EAAAC;EAAA,IAAiDP,aAAA;EACjD,MAAAQ,SAAA,GAAkBP,YAAA;EAElB,MAAAQ,uBAAA,GAAgCD,SAAA,EAAAE,SAAA,EAAAC,KAAA,EAAAC,WAAA;EAEhC,MAAAN,UAAA,GAAmBG,uBAAA,IAA2BF,wBAAA;EAE9CR,oBAAA,CACE,kBAAkBO,UAAA,IAAcH,UAAA,gCAA0CC,YAAA,EAAc,EACxFC,IAAA;AAAA,CAEJ;AAEA,OAAO,MAAMQ,0BAAA,GACXR,IAAA;EAEA,OAAQS,KAAA;IACNZ,qBAAA,CAAsBY,KAAA,CAAMX,UAAU,EAAEW,KAAA,CAAMV,YAAY,EAAEC,IAAA;IAC5D,OAAO;EACT;AACF","ignoreList":[]}

package/dist/features/debug/testRecorder/client/index.d.ts

@@ -0,0 +1,5 @@
+export declare const TestRecorderFeatureClient: import("react").FC<{
+    featureKey: string;
+    order: number;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/debug/testRecorder/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/debug/testRecorder/client/index.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,yBAAyB;;;EAOpC,CAAA"}

package/dist/features/debug/testRecorder/client/index.js

@@ -0,0 +1,11 @@
+'use client';
+
+import { createClientFeature } from '../../../../utilities/createClientFeature.js';
+import { TestRecorderPlugin } from './plugin/index.js';
+export const TestRecorderFeatureClient = createClientFeature({
+  plugins: [{
+    Component: TestRecorderPlugin,
+    position: 'bottom'
+  }]
+});
+//# sourceMappingURL=index.js.map

package/dist/features/debug/testRecorder/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createClientFeature","TestRecorderPlugin","TestRecorderFeatureClient","plugins","Component","position"],"sources":["../../../../../src/features/debug/testRecorder/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../../utilities/createClientFeature.js'\nimport { TestRecorderPlugin } from './plugin/index.js'\n\nexport const TestRecorderFeatureClient = createClientFeature({\n  plugins: [\n    {\n      Component: TestRecorderPlugin,\n      position: 'bottom',\n    },\n  ],\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,kBAAkB,QAAQ;AAEnC,OAAO,MAAMC,yBAAA,GAA4BF,mBAAA,CAAoB;EAC3DG,OAAA,EAAS,CACP;IACEC,SAAA,EAAWH,kBAAA;IACXI,QAAA,EAAU;EACZ;AAEJ","ignoreList":[]}

package/dist/features/debug/testRecorder/client/plugin/index.d.ts

@@ -0,0 +1,5 @@
+import type { PluginComponent } from '../../../../typesClient.js';
+import './index.scss';
+export declare function isSelectAll(event: KeyboardEvent): boolean;
+export declare const TestRecorderPlugin: PluginComponent<undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/debug/testRecorder/client/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/debug/testRecorder/client/plugin/index.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAGjE,OAAO,cAAc,CAAA;AA8ErB,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAEzD;AAmWD,eAAO,MAAM,kBAAkB,EAAE,eAAe,CAAC,SAAS,CAYzD,CAAA"}