@ruya.sa/richtext-lexical 3.71.7

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts

@@ -0,0 +1,7 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { PlaintextConverter, PlaintextConverters } from '../sync/types.js';
+export declare function findConverterForNode<TConverters extends PlaintextConverters, TConverter extends PlaintextConverter<any>>({ converters, node, }: {
+    converters: TConverters;
+    node: SerializedLexicalNode;
+}): TConverter | undefined;
+//# sourceMappingURL=findConverterForNode.d.ts.map

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findConverterForNode.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE/E,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,mBAAmB,EACvC,UAAU,SAAS,kBAAkB,CAAC,GAAG,CAAC,EAC1C,EACA,UAAU,EAEV,IAAI,GACL,EAAE;IACD,UAAU,EAAE,WAAW,CAAA;IACvB,IAAI,EAAE,qBAAqB,CAAA;CAC5B,GAAG,UAAU,GAAG,SAAS,CAezB"}

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.js

@@ -0,0 +1,15 @@
+export function findConverterForNode({
+  converters,
+  node
+}) {
+  let converterForNode;
+  if (node.type === 'block') {
+    converterForNode = converters?.blocks?.[node?.fields?.blockType];
+  } else if (node.type === 'inlineBlock') {
+    converterForNode = converters?.inlineBlocks?.[node?.fields?.blockType];
+  } else {
+    converterForNode = converters[node.type];
+  }
+  return converterForNode;
+}
+//# sourceMappingURL=findConverterForNode.js.map

package/dist/features/converters/lexicalToPlaintext/shared/findConverterForNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findConverterForNode.js","names":["findConverterForNode","converters","node","converterForNode","type","blocks","fields","blockType","inlineBlocks"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/findConverterForNode.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js'\nimport type { PlaintextConverter, PlaintextConverters } from '../sync/types.js'\n\nexport function findConverterForNode<\n  TConverters extends PlaintextConverters,\n  TConverter extends PlaintextConverter<any>,\n>({\n  converters,\n\n  node,\n}: {\n  converters: TConverters\n  node: SerializedLexicalNode\n}): TConverter | undefined {\n  let converterForNode: TConverter | undefined\n  if (node.type === 'block') {\n    converterForNode = converters?.blocks?.[\n      (node as SerializedBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else if (node.type === 'inlineBlock') {\n    converterForNode = converters?.inlineBlocks?.[\n      (node as SerializedInlineBlockNode)?.fields?.blockType\n    ] as TConverter\n  } else {\n    converterForNode = converters[node.type] as TConverter\n  }\n\n  return converterForNode\n}\n"],"mappings":"AAKA,OAAO,SAASA,qBAGd;EACAC,UAAU;EAEVC;AAAI,CAIL;EACC,IAAIC,gBAAA;EACJ,IAAID,IAAA,CAAKE,IAAI,KAAK,SAAS;IACzBD,gBAAA,GAAmBF,UAAA,EAAYI,MAAA,GAC5BH,IAAA,EAA8BI,MAAA,EAAQC,SAAA,CACxC;EACH,OAAO,IAAIL,IAAA,CAAKE,IAAI,KAAK,eAAe;IACtCD,gBAAA,GAAmBF,UAAA,EAAYO,YAAA,GAC5BN,IAAA,EAAoCI,MAAA,EAAQC,SAAA,CAC9C;EACH,OAAO;IACLJ,gBAAA,GAAmBF,UAAU,CAACC,IAAA,CAAKE,IAAI,CAAC;EAC1C;EAEA,OAAOD,gBAAA;AACT","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/shared/types.d.ts

@@ -0,0 +1,5 @@
+import type { SerializedLexicalNode } from 'lexical';
+export type SerializedLexicalNodeWithParent = {
+    parent?: SerializedLexicalNode;
+} & SerializedLexicalNode;
+//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToPlaintext/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACpD,MAAM,MAAM,+BAA+B,GAAG;IAC5C,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,GAAG,qBAAqB,CAAA"}

package/dist/features/converters/lexicalToPlaintext/shared/types.js

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

package/dist/features/converters/lexicalToPlaintext/shared/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/shared/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\nexport type SerializedLexicalNodeWithParent = {\n  parent?: SerializedLexicalNode\n} & SerializedLexicalNode\n"],"mappings":"AACA","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts

@@ -0,0 +1,22 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+import type { PlaintextConverters } from './types.js';
+export type ConvertLexicalToPlaintextArgs = {
+    /**
+     * A map of node types to their corresponding plaintext converter functions.
+     * This is optional - if not provided, the following heuristic will be used:
+     *
+     * - If the node has a `text` property, it will be used as the plaintext.
+     * - If the node has a `children` property, the children will be recursively converted to plaintext.
+     * - If the node has neither, it will be ignored.
+     **/
+    converters?: PlaintextConverters;
+    data: SerializedEditorState;
+};
+export declare function convertLexicalToPlaintext({ converters, data, }: ConvertLexicalToPlaintextArgs): string;
+export declare function convertLexicalNodesToPlaintext({ converters, nodes, parent, }: {
+    converters: PlaintextConverters;
+    nodes: SerializedLexicalNode[];
+    parent: SerializedLexicalNodeWithParent;
+}): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAKrD,MAAM,MAAM,6BAA6B,GAAG;IAC1C;;;;;;;QAOI;IACJ,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAAA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,UAAU,EACV,IAAI,GACL,EAAE,6BAA6B,GAAG,MAAM,CAWxC;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,UAAU,EACV,KAAK,EACL,MAAM,GACP,EAAE;IACD,UAAU,EAAE,mBAAmB,CAAA;IAC/B,KAAK,EAAE,qBAAqB,EAAE,CAAA;IAC9B,MAAM,EAAE,+BAA+B,CAAA;CACxC,GAAG,MAAM,EAAE,CAkFX"}

package/dist/features/converters/lexicalToPlaintext/sync/index.js

@@ -0,0 +1,88 @@
+/* eslint-disable no-console */import { hasText } from '../../../../validate/hasText.js';
+import { findConverterForNode } from '../shared/findConverterForNode.js';
+export function convertLexicalToPlaintext({
+  converters,
+  data
+}) {
+  if (hasText(data)) {
+    const plaintext = convertLexicalNodesToPlaintext({
+      converters: converters ?? {},
+      nodes: data?.root?.children,
+      parent: data?.root
+    }).join('');
+    return plaintext;
+  }
+  return '';
+}
+export function convertLexicalNodesToPlaintext({
+  converters,
+  nodes,
+  parent
+}) {
+  const plainTextArray = [];
+  let i = -1;
+  for (const node of nodes) {
+    i++;
+    const converter = findConverterForNode({
+      converters,
+      node
+    });
+    if (converter) {
+      try {
+        const converted = typeof converter === 'function' ? converter({
+          childIndex: i,
+          converters,
+          node,
+          nodesToPlaintext: args => {
+            return convertLexicalNodesToPlaintext({
+              converters: args.converters ?? converters,
+              nodes: args.nodes,
+              parent: args.parent ?? {
+                ...node,
+                parent
+              }
+            });
+          },
+          parent
+        }) : converter;
+        if (converted && typeof converted === 'string') {
+          plainTextArray.push(converted);
+        }
+      } catch (error) {
+        console.error('Error converting lexical node to plaintext:', error, 'node:', node);
+      }
+    } else {
+      // Default plaintext converter heuristic
+      if (node.type === 'paragraph' || node.type === 'heading' || node.type === 'list' || node.type === 'table') {
+        if (plainTextArray?.length) {
+          // Only add a new line if there is already text in the array
+          plainTextArray.push('\n\n');
+        }
+      } else if (node.type === 'listitem' || node.type === 'tablerow') {
+        if (plainTextArray?.length) {
+          // Only add a new line if there is already text in the array
+          plainTextArray.push('\n');
+        }
+      } else if (node.type === 'tablecell') {
+        if (plainTextArray?.length) {
+          plainTextArray.push(' | ');
+        }
+      } else if (node.type === 'linebreak') {
+        plainTextArray.push('\n');
+      } else if (node.type === 'tab') {
+        plainTextArray.push('\t');
+      } else if ('text' in node && node.text) {
+        plainTextArray.push(node.text);
+      }
+      if ('children' in node && node.children) {
+        plainTextArray.push(...convertLexicalNodesToPlaintext({
+          converters,
+          nodes: node.children,
+          parent: node
+        }));
+      }
+    }
+  }
+  return plainTextArray.filter(Boolean);
+}
+//# sourceMappingURL=index.js.map

package/dist/features/converters/lexicalToPlaintext/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["hasText","findConverterForNode","convertLexicalToPlaintext","converters","data","plaintext","convertLexicalNodesToPlaintext","nodes","root","children","parent","join","plainTextArray","i","node","converter","converted","childIndex","nodesToPlaintext","args","push","error","console","type","length","text","filter","Boolean"],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\nimport type { PlaintextConverters } from './types.js'\n\nimport { hasText } from '../../../../validate/hasText.js'\nimport { findConverterForNode } from '../shared/findConverterForNode.js'\n\nexport type ConvertLexicalToPlaintextArgs = {\n  /**\n   * A map of node types to their corresponding plaintext converter functions.\n   * This is optional - if not provided, the following heuristic will be used:\n   *\n   * - If the node has a `text` property, it will be used as the plaintext.\n   * - If the node has a `children` property, the children will be recursively converted to plaintext.\n   * - If the node has neither, it will be ignored.\n   **/\n  converters?: PlaintextConverters\n  data: SerializedEditorState\n}\n\nexport function convertLexicalToPlaintext({\n  converters,\n  data,\n}: ConvertLexicalToPlaintextArgs): string {\n  if (hasText(data)) {\n    const plaintext = convertLexicalNodesToPlaintext({\n      converters: converters ?? {},\n      nodes: data?.root?.children,\n      parent: data?.root,\n    }).join('')\n\n    return plaintext\n  }\n  return ''\n}\n\nexport function convertLexicalNodesToPlaintext({\n  converters,\n  nodes,\n  parent,\n}: {\n  converters: PlaintextConverters\n  nodes: SerializedLexicalNode[]\n  parent: SerializedLexicalNodeWithParent\n}): string[] {\n  const plainTextArray: string[] = []\n\n  let i = -1\n  for (const node of nodes) {\n    i++\n\n    const converter = findConverterForNode({\n      converters,\n      node,\n    })\n\n    if (converter) {\n      try {\n        const converted =\n          typeof converter === 'function'\n            ? converter({\n                childIndex: i,\n                converters,\n                node,\n                nodesToPlaintext: (args) => {\n                  return convertLexicalNodesToPlaintext({\n                    converters: args.converters ?? converters,\n                    nodes: args.nodes,\n                    parent: args.parent ?? {\n                      ...node,\n                      parent,\n                    },\n                  })\n                },\n                parent,\n              })\n            : converter\n\n        if (converted && typeof converted === 'string') {\n          plainTextArray.push(converted)\n        }\n      } catch (error) {\n        console.error('Error converting lexical node to plaintext:', error, 'node:', node)\n      }\n    } else {\n      // Default plaintext converter heuristic\n      if (\n        node.type === 'paragraph' ||\n        node.type === 'heading' ||\n        node.type === 'list' ||\n        node.type === 'table'\n      ) {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n\\n')\n        }\n      } else if (node.type === 'listitem' || node.type === 'tablerow') {\n        if (plainTextArray?.length) {\n          // Only add a new line if there is already text in the array\n          plainTextArray.push('\\n')\n        }\n      } else if (node.type === 'tablecell') {\n        if (plainTextArray?.length) {\n          plainTextArray.push(' | ')\n        }\n      } else if (node.type === 'linebreak') {\n        plainTextArray.push('\\n')\n      } else if (node.type === 'tab') {\n        plainTextArray.push('\\t')\n      } else if ('text' in node && node.text) {\n        plainTextArray.push(node.text as string)\n      }\n\n      if ('children' in node && node.children) {\n        plainTextArray.push(\n          ...convertLexicalNodesToPlaintext({\n            converters,\n            nodes: node.children as SerializedLexicalNode[],\n            parent: node,\n          }),\n        )\n      }\n    }\n  }\n\n  return plainTextArray.filter(Boolean)\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts

@@ -0,0 +1,60 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { DefaultNodeTypes, SerializedBlockNode, SerializedInlineBlockNode } from '../../../../nodeTypes.js';
+import type { SerializedLexicalNodeWithParent } from '../shared/types.js';
+export type PlaintextConverter<T extends {
+    [key: string]: any;
+    type?: string;
+} = SerializedLexicalNode> = ((args: {
+    childIndex: number;
+    converters: PlaintextConverters;
+    node: T;
+    nodesToPlaintext: (args: {
+        converters?: PlaintextConverters;
+        nodes: SerializedLexicalNode[];
+        parent?: SerializedLexicalNodeWithParent;
+    }) => string[];
+    parent: SerializedLexicalNodeWithParent;
+}) => string) | string;
+export type DefaultPlaintextNodeTypes = DefaultNodeTypes | SerializedBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}> | SerializedInlineBlockNode<{
+    blockName?: null | string;
+    blockType: string;
+}>;
+export type PlaintextConverters<T extends {
+    [key: string]: any;
+    type?: string;
+} = DefaultPlaintextNodeTypes> = {
+    [key: string]: {
+        [blockSlug: string]: PlaintextConverter<any>;
+    } | PlaintextConverter<any> | undefined;
+} & {
+    [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<Extract<T, {
+        type: nodeType;
+    }>>;
+} & {
+    blocks?: {
+        [K in Extract<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
+            type: 'block';
+        }> extends SerializedBlockNode<infer B> ? SerializedBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedBlockNode>;
+    };
+    inlineBlocks?: {
+        [K in Extract<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? B extends {
+            blockType: string;
+        } ? B['blockType'] : never : never, string>]?: PlaintextConverter<Extract<T, {
+            type: 'inlineBlock';
+        }> extends SerializedInlineBlockNode<infer B> ? SerializedInlineBlockNode<Extract<B, {
+            blockType: K;
+        }>> : SerializedInlineBlockNode>;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/features/converters/lexicalToPlaintext/sync/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"names":[],"mappings":"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"}

package/dist/features/converters/lexicalToPlaintext/sync/types.js

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

package/dist/features/converters/lexicalToPlaintext/sync/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/converters/lexicalToPlaintext/sync/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport type {\n  DefaultNodeTypes,\n  SerializedBlockNode,\n  SerializedInlineBlockNode,\n} from '../../../../nodeTypes.js'\nimport type { SerializedLexicalNodeWithParent } from '../shared/types.js'\n\nexport type PlaintextConverter<\n  T extends { [key: string]: any; type?: string } = SerializedLexicalNode,\n> =\n  | ((args: {\n      childIndex: number\n      converters: PlaintextConverters\n      node: T\n      nodesToPlaintext: (args: {\n        converters?: PlaintextConverters\n        nodes: SerializedLexicalNode[]\n        parent?: SerializedLexicalNodeWithParent\n      }) => string[]\n      parent: SerializedLexicalNodeWithParent\n    }) => string)\n  | string\n\nexport type DefaultPlaintextNodeTypes =\n  | DefaultNodeTypes\n  | SerializedBlockNode<{ blockName?: null | string; blockType: string }> // need these to ensure types for blocks and inlineBlocks work if no generics are provided\n  | SerializedInlineBlockNode<{ blockName?: null | string; blockType: string }>\n\nexport type PlaintextConverters<\n  T extends { [key: string]: any; type?: string } = DefaultPlaintextNodeTypes,\n> = {\n  [key: string]:\n    | {\n        [blockSlug: string]: PlaintextConverter<any>\n      }\n    | PlaintextConverter<any>\n    | undefined\n} & {\n  [nodeType in Exclude<NonNullable<T['type']>, 'block' | 'inlineBlock'>]?: PlaintextConverter<\n    Extract<T, { type: nodeType }>\n  >\n} & {\n  blocks?: {\n    [K in Extract<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'block' }> extends SerializedBlockNode<infer B>\n        ? SerializedBlockNode<Extract<B, { blockType: K }>>\n        : SerializedBlockNode\n    >\n  }\n  inlineBlocks?: {\n    [K in Extract<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? B extends { blockType: string }\n          ? B['blockType']\n          : never\n        : never,\n      string\n    >]?: PlaintextConverter<\n      Extract<T, { type: 'inlineBlock' }> extends SerializedInlineBlockNode<infer B>\n        ? SerializedInlineBlockNode<Extract<B, { blockType: K }>>\n        : SerializedInlineBlockNode\n    >\n  }\n}\n"],"mappings":"AA8BA","ignoreList":[]}

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

@@ -0,0 +1,8 @@
+import type { SerializedLexicalNode } from 'lexical';
+import type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js';
+import type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js';
+export declare const convertMarkdownToLexical: <TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes>({ editorConfig, markdown, }: {
+    editorConfig: SanitizedServerEditorConfig;
+    markdown: string;
+}) => TypedEditorState<TNodeTypes>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAA;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAK/E,eAAO,MAAM,wBAAwB,GACnC,UAAU,SAAS,qBAAqB,kDAIvC;IACD,YAAY,EAAE,2BAA2B,CAAA;IACzC,QAAQ,EAAE,MAAM,CAAA;CACjB,KAAG,gBAAgB,CAAC,UAAU,CAiB9B,CAAA"}

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

@@ -0,0 +1,21 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { getEnabledNodes } from '../../../lexical/nodes/index.js';
+import { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js';
+export const convertMarkdownToLexical = ({
+  editorConfig,
+  markdown
+}) => {
+  const headlessEditor = createHeadlessEditor({
+    nodes: getEnabledNodes({
+      editorConfig
+    })
+  });
+  headlessEditor.update(() => {
+    $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers);
+  }, {
+    discrete: true
+  });
+  const editorJSON = headlessEditor.getEditorState().toJSON();
+  return editorJSON;
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createHeadlessEditor","getEnabledNodes","$convertFromMarkdownString","convertMarkdownToLexical","editorConfig","markdown","headlessEditor","nodes","update","features","markdownTransformers","discrete","editorJSON","getEditorState","toJSON"],"sources":["../../../../src/features/converters/markdownToLexical/index.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nimport { createHeadlessEditor } from '@lexical/headless'\n\nimport type { SanitizedServerEditorConfig } from '../../../lexical/config/types.js'\nimport type { DefaultNodeTypes, TypedEditorState } from '../../../nodeTypes.js'\n\nimport { getEnabledNodes } from '../../../lexical/nodes/index.js'\nimport { $convertFromMarkdownString } from '../../../packages/@lexical/markdown/index.js'\n\nexport const convertMarkdownToLexical = <\n  TNodeTypes extends SerializedLexicalNode = DefaultNodeTypes,\n>({\n  editorConfig,\n  markdown,\n}: {\n  editorConfig: SanitizedServerEditorConfig\n  markdown: string\n}): TypedEditorState<TNodeTypes> => {\n  const headlessEditor = createHeadlessEditor({\n    nodes: getEnabledNodes({\n      editorConfig,\n    }),\n  })\n\n  headlessEditor.update(\n    () => {\n      $convertFromMarkdownString(markdown, editorConfig.features.markdownTransformers)\n    },\n    { discrete: true },\n  )\n\n  const editorJSON = headlessEditor.getEditorState().toJSON()\n\n  return editorJSON as TypedEditorState<TNodeTypes>\n}\n"],"mappings":"AAEA,SAASA,oBAAoB,QAAQ;AAKrC,SAASC,eAAe,QAAQ;AAChC,SAASC,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA2BA,CAEtC;EACAC,YAAY;EACZC;AAAQ,CAIT;EACC,MAAMC,cAAA,GAAiBN,oBAAA,CAAqB;IAC1CO,KAAA,EAAON,eAAA,CAAgB;MACrBG;IACF;EACF;EAEAE,cAAA,CAAeE,MAAM,CACnB;IACEN,0BAAA,CAA2BG,QAAA,EAAUD,YAAA,CAAaK,QAAQ,CAACC,oBAAoB;EACjF,GACA;IAAEC,QAAA,EAAU;EAAK;EAGnB,MAAMC,UAAA,GAAaN,cAAA,CAAeO,cAAc,GAAGC,MAAM;EAEzD,OAAOF,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/payloadPopulateFn.d.ts

@@ -0,0 +1,31 @@
+import { type Payload, type PayloadRequest, type TypedLocale } from '@ruya.sa/payload';
+import type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js';
+export declare const getPayloadPopulateFn: (args: {
+    currentDepth: number;
+    depth: number;
+    draft?: boolean;
+    locale?: TypedLocale;
+    overrideAccess?: boolean;
+    showHiddenFields?: boolean;
+} & ({
+    /**
+     * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.
+     */
+    payload: Payload;
+    /**
+     * When the converter is called, req CAN be passed in depending on where it's run.
+     * If this is undefined and config is passed through, lexical will create a new req object for you.
+     */
+    req?: never;
+} | {
+    /**
+     * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.
+     */
+    payload?: never;
+    /**
+     * When the converter is called, req CAN be passed in depending on where it's run.
+     * If this is undefined and config is passed through, lexical will create a new req object for you.
+     */
+    req: PayloadRequest;
+})) => Promise<HTMLPopulateFn>;
+//# sourceMappingURL=payloadPopulateFn.d.ts.map

package/dist/features/converters/utilities/payloadPopulateFn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloadPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAEtG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAIrE,eAAO,MAAM,oBAAoB,EAAE,CACjC,IAAI,EAAE;IACJ,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,WAAW,CAAA;IAEpB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,CACA;IACE;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,GAAG,CAAC,EAAE,KAAK,CAAA;CACZ,GACD;IACE;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAA;IACf;;;OAGG;IACH,GAAG,EAAE,cAAc,CAAA;CACpB,CACJ,KACE,OAAO,CAAC,cAAc,CAyC1B,CAAA"}

package/dist/features/converters/utilities/payloadPopulateFn.js

@@ -0,0 +1,42 @@
+import { createLocalReq } from '@ruya.sa/payload';
+import { populate } from '../../../populateGraphQL/populate.js';
+export const getPayloadPopulateFn = async ({
+  currentDepth,
+  depth,
+  draft,
+  overrideAccess,
+  payload,
+  req,
+  showHiddenFields
+}) => {
+  let reqToUse = req;
+  if (req === undefined && payload) {
+    reqToUse = await createLocalReq({}, payload);
+  }
+  if (!reqToUse) {
+    throw new Error('No req or payload provided');
+  }
+  const populateFn = async ({
+    id,
+    collectionSlug,
+    select
+  }) => {
+    const dataContainer = {};
+    await populate({
+      id,
+      collectionSlug,
+      currentDepth,
+      data: dataContainer,
+      depth,
+      draft: draft ?? false,
+      key: 'value',
+      overrideAccess: overrideAccess ?? true,
+      req: reqToUse,
+      select,
+      showHiddenFields: showHiddenFields ?? false
+    });
+    return dataContainer.value;
+  };
+  return populateFn;
+};
+//# sourceMappingURL=payloadPopulateFn.js.map

package/dist/features/converters/utilities/payloadPopulateFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payloadPopulateFn.js","names":["createLocalReq","populate","getPayloadPopulateFn","currentDepth","depth","draft","overrideAccess","payload","req","showHiddenFields","reqToUse","undefined","Error","populateFn","id","collectionSlug","select","dataContainer","data","key","value"],"sources":["../../../../src/features/converters/utilities/payloadPopulateFn.ts"],"sourcesContent":["import { createLocalReq, type Payload, type PayloadRequest, type TypedLocale } from '@ruya.sa/payload'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nimport { populate } from '../../../populateGraphQL/populate.js'\n\nexport const getPayloadPopulateFn: (\n  args: {\n    currentDepth: number\n    depth: number\n    draft?: boolean\n    locale?: TypedLocale\n\n    overrideAccess?: boolean\n    showHiddenFields?: boolean\n  } & (\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload: Payload\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req?: never\n      }\n    | {\n        /**\n         * This payload property will only be used if req is undefined. If localization is enabled, you must pass `req` instead.\n         */\n        payload?: never\n        /**\n         * When the converter is called, req CAN be passed in depending on where it's run.\n         * If this is undefined and config is passed through, lexical will create a new req object for you.\n         */\n        req: PayloadRequest\n      }\n  ),\n) => Promise<HTMLPopulateFn> = async ({\n  currentDepth,\n  depth,\n  draft,\n  overrideAccess,\n  payload,\n  req,\n  showHiddenFields,\n}) => {\n  let reqToUse: PayloadRequest | undefined = req\n  if (req === undefined && payload) {\n    reqToUse = await createLocalReq({}, payload)\n  }\n\n  if (!reqToUse) {\n    throw new Error('No req or payload provided')\n  }\n\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const dataContainer: {\n      value?: any\n    } = {}\n\n    await populate({\n      id,\n      collectionSlug,\n      currentDepth,\n      data: dataContainer,\n      depth,\n      draft: draft ?? false,\n      key: 'value',\n      overrideAccess: overrideAccess ?? true,\n      req: reqToUse,\n      select,\n      showHiddenFields: showHiddenFields ?? false,\n    })\n\n    return dataContainer.value\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,cAAc,QAA6D;AAIpF,SAASC,QAAQ,QAAQ;AAEzB,OAAO,MAAMC,oBAAA,GAiCkB,MAAAA,CAAO;EACpCC,YAAY;EACZC,KAAK;EACLC,KAAK;EACLC,cAAc;EACdC,OAAO;EACPC,GAAG;EACHC;AAAgB,CACjB;EACC,IAAIC,QAAA,GAAuCF,GAAA;EAC3C,IAAIA,GAAA,KAAQG,SAAA,IAAaJ,OAAA,EAAS;IAChCG,QAAA,GAAW,MAAMV,cAAA,CAAe,CAAC,GAAGO,OAAA;EACtC;EAEA,IAAI,CAACG,QAAA,EAAU;IACb,MAAM,IAAIE,KAAA,CAAM;EAClB;EAEA,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,aAAA,GAEF,CAAC;IAEL,MAAMhB,QAAA,CAAS;MACba,EAAA;MACAC,cAAA;MACAZ,YAAA;MACAe,IAAA,EAAMD,aAAA;MACNb,KAAA;MACAC,KAAA,EAAOA,KAAA,IAAS;MAChBc,GAAA,EAAK;MACLb,cAAA,EAAgBA,cAAA,IAAkB;MAClCE,GAAA,EAAKE,QAAA;MACLM,MAAA;MACAP,gBAAA,EAAkBA,gBAAA,IAAoB;IACxC;IAEA,OAAOQ,aAAA,CAAcG,KAAK;EAC5B;EAEA,OAAOP,UAAA;AACT","ignoreList":[]}

package/dist/features/converters/utilities/restPopulateFn.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js';
+export declare const getRestPopulateFn: (args: {
+    /**
+     * E.g. `http://localhost:3000/api`
+     */
+    apiURL: string;
+    depth?: number;
+    draft?: boolean;
+    locale?: string;
+}) => HTMLPopulateFn;
+//# sourceMappingURL=restPopulateFn.d.ts.map

package/dist/features/converters/utilities/restPopulateFn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restPopulateFn.d.ts","sourceRoot":"","sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AAErE,eAAO,MAAM,iBAAiB,EAAE,CAAC,IAAI,EAAE;IACrC;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,KAAK,cAoBL,CAAA"}

package/dist/features/converters/utilities/restPopulateFn.js

@@ -0,0 +1,33 @@
+import { stringify } from 'qs-esm';
+export const getRestPopulateFn = ({
+  apiURL,
+  depth,
+  draft,
+  locale
+}) => {
+  const populateFn = async ({
+    id,
+    collectionSlug,
+    select
+  }) => {
+    const query = stringify({
+      depth: depth ?? 0,
+      draft: draft ?? false,
+      locale,
+      select
+    }, {
+      addQueryPrefix: true
+    });
+    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {
+      credentials: 'include',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      },
+      method: 'GET'
+    }).then(res => res.json());
+    return res;
+  };
+  return populateFn;
+};
+//# sourceMappingURL=restPopulateFn.js.map

package/dist/features/converters/utilities/restPopulateFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restPopulateFn.js","names":["stringify","getRestPopulateFn","apiURL","depth","draft","locale","populateFn","id","collectionSlug","select","query","addQueryPrefix","res","fetch","credentials","headers","Accept","method","then","json"],"sources":["../../../../src/features/converters/utilities/restPopulateFn.ts"],"sourcesContent":["import { stringify } from 'qs-esm'\n\nimport type { HTMLPopulateFn } from '../lexicalToHtml/async/types.js'\n\nexport const getRestPopulateFn: (args: {\n  /**\n   * E.g. `http://localhost:3000/api`\n   */\n  apiURL: string\n  depth?: number\n  draft?: boolean\n  locale?: string\n}) => HTMLPopulateFn = ({ apiURL, depth, draft, locale }) => {\n  const populateFn: HTMLPopulateFn = async ({ id, collectionSlug, select }) => {\n    const query = stringify(\n      { depth: depth ?? 0, draft: draft ?? false, locale, select },\n      { addQueryPrefix: true },\n    )\n\n    const res = await fetch(`${apiURL}/${collectionSlug}/${id}${query}`, {\n      credentials: 'include',\n      headers: {\n        Accept: 'application/json',\n        'Content-Type': 'application/json',\n      },\n      method: 'GET',\n    }).then((res) => res.json())\n\n    return res\n  }\n\n  return populateFn\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ;AAI1B,OAAO,MAAMC,iBAAA,GAQUA,CAAC;EAAEC,MAAM;EAAEC,KAAK;EAAEC,KAAK;EAAEC;AAAM,CAAE;EACtD,MAAMC,UAAA,GAA6B,MAAAA,CAAO;IAAEC,EAAE;IAAEC,cAAc;IAAEC;EAAM,CAAE;IACtE,MAAMC,KAAA,GAAQV,SAAA,CACZ;MAAEG,KAAA,EAAOA,KAAA,IAAS;MAAGC,KAAA,EAAOA,KAAA,IAAS;MAAOC,MAAA;MAAQI;IAAO,GAC3D;MAAEE,cAAA,EAAgB;IAAK;IAGzB,MAAMC,GAAA,GAAM,MAAMC,KAAA,CAAM,GAAGX,MAAA,IAAUM,cAAA,IAAkBD,EAAA,GAAKG,KAAA,EAAO,EAAE;MACnEI,WAAA,EAAa;MACbC,OAAA,EAAS;QACPC,MAAA,EAAQ;QACR,gBAAgB;MAClB;MACAC,MAAA,EAAQ;IACV,GAAGC,IAAI,CAAEN,GAAA,IAAQA,GAAA,CAAIO,IAAI;IAEzB,OAAOP,GAAA;EACT;EAEA,OAAON,UAAA;AACT","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export declare const DebugJsxConverterFeatureClient: import("../../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createClientFeature","RichTextPlugin","DebugJsxConverterFeatureClient","plugins","Component","position"],"sources":["../../../../../src/features/debug/jsxConverter/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../../utilities/createClientFeature.js'\nimport { RichTextPlugin } from './plugin/index.js'\n\nexport const DebugJsxConverterFeatureClient = createClientFeature({\n  plugins: [\n    {\n      Component: RichTextPlugin,\n      position: 'bottom',\n    },\n  ],\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,cAAc,QAAQ;AAE/B,OAAO,MAAMC,8BAAA,GAAiCF,mBAAA,CAAoB;EAChEG,OAAA,EAAS,CACP;IACEC,SAAA,EAAWH,cAAA;IACXI,QAAA,EAAU;EACZ;AAEJ","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+import './style.scss';
+export declare function RichTextPlugin(): import("react").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/debug/jsxConverter/client/plugin/index.tsx"],"names":[],"mappings":"AAOA,OAAO,cAAc,CAAA;AAErB,wBAAgB,cAAc,gCAe7B"}

package/dist/features/debug/jsxConverter/client/plugin/index.js

@@ -0,0 +1,55 @@
+'use client';
+
+import { c as _c } from "react/compiler-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { useEffect, useState } from 'react';
+// eslint-disable-next-line payload/no-imports-from-exports-dir
+import { defaultJSXConverters, RichText } from '../../../../../exports/react/index.js';
+export function RichTextPlugin() {
+  const $ = _c(7);
+  const [editor] = useLexicalComposerContext();
+  let t0;
+  if ($[0] !== editor) {
+    t0 = editor.getEditorState().toJSON();
+    $[0] = editor;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const [editorState, setEditorState] = useState(t0);
+  let t1;
+  let t2;
+  if ($[2] !== editor) {
+    t1 = () => editor.registerUpdateListener(t3 => {
+      const {
+        editorState: editorState_0
+      } = t3;
+      setEditorState(editorState_0.toJSON());
+    });
+    t2 = [editor];
+    $[2] = editor;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[5] !== editorState) {
+    t3 = _jsx("div", {
+      className: "debug-jsx-converter",
+      children: _jsx(RichText, {
+        converters: defaultJSXConverters,
+        data: editorState
+      })
+    });
+    $[5] = editorState;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/debug/jsxConverter/client/plugin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["c","_c","useLexicalComposerContext","useEffect","useState","defaultJSXConverters","RichText","RichTextPlugin","$","editor","t0","getEditorState","toJSON","editorState","setEditorState","t1","t2","registerUpdateListener","t3","editorState_0","_jsx","className","children","converters","data"],"sources":["../../../../../../src/features/debug/jsxConverter/client/plugin/index.tsx"],"sourcesContent":["'use client'\n\nimport { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'\nimport { useEffect, useState } from 'react'\n\n// eslint-disable-next-line payload/no-imports-from-exports-dir\nimport { defaultJSXConverters, RichText } from '../../../../../exports/react/index.js'\nimport './style.scss'\n\nexport function RichTextPlugin() {\n  const [editor] = useLexicalComposerContext()\n  const [editorState, setEditorState] = useState(editor.getEditorState().toJSON())\n\n  useEffect(() => {\n    return editor.registerUpdateListener(({ editorState }) => {\n      setEditorState(editorState.toJSON())\n    })\n  }, [editor])\n\n  return (\n    <div className=\"debug-jsx-converter\">\n      <RichText converters={defaultJSXConverters} data={editorState} />\n    </div>\n  )\n}\n"],"mappings":"AAAA;;AAAA,SAAAA,CAAA,IAAAC,EAAA;;AAEA,SAASC,yBAAyB,QAAQ;AAC1C,SAASC,SAAS,EAAEC,QAAQ,QAAQ;AAEpC;AACA,SAASC,oBAAoB,EAAEC,QAAQ,QAAQ;AAG/C,OAAO,SAAAC,eAAA;EAAA,MAAAC,CAAA,GAAAP,EAAA;EACL,OAAAQ,MAAA,IAAiBP,yBAAA;EAAA,IAAAQ,EAAA;EAAA,IAAAF,CAAA,QAAAC,MAAA;IAC8BC,EAAA,GAAAD,MAAA,CAAAE,cAAA,CAAqB,EAAAC,MAAA,CAAS;IAAAJ,CAAA,MAAAC,MAAA;IAAAD,CAAA,MAAAE,EAAA;EAAA;IAAAA,EAAA,GAAAF,CAAA;EAAA;EAA7E,OAAAK,WAAA,EAAAC,cAAA,IAAsCV,QAAA,CAASM,EAA8B;EAAA,IAAAK,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAR,CAAA,QAAAC,MAAA;IAEnEM,EAAA,GAAAA,CAAA,KACDN,MAAA,CAAAQ,sBAAA,CAAAC,EAAA;MAA+B;QAAAL,WAAA,EAAAM;MAAA,IAAAD,EAAe;MACnDJ,cAAA,CAAeD,aAAA,CAAAD,MAAA,CAAkB;IAAA,CACnC;IACCI,EAAA,IAACP,MAAA;IAAOD,CAAA,MAAAC,MAAA;IAAAD,CAAA,MAAAO,EAAA;IAAAP,CAAA,MAAAQ,EAAA;EAAA;IAAAD,EAAA,GAAAP,CAAA;IAAAQ,EAAA,GAAAR,CAAA;EAAA;EAJXL,SAAA,CAAUY,EAIV,EAAGC,EAAQ;EAAA,IAAAE,EAAA;EAAA,IAAAV,CAAA,QAAAK,WAAA;IAGTK,EAAA,GAAAE,IAAA,CAAC;MAAAC,SAAA,EAAc;MAAAC,QAAA,EACbF,IAAA,CAAAd,QAAA;QAAAiB,UAAA,EAAAlB,oBAAA;QAAAmB,IAAA,EAAkDX;MAAA,C;;;;;;;SADpDK,E","ignoreList":[]}

package/dist/features/debug/jsxConverter/server/index.d.ts

@@ -0,0 +1,2 @@
+export declare const DebugJsxConverterFeature: import("../../../typesServer.js").FeatureProviderProviderServer<undefined, undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/debug/jsxConverter/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/debug/jsxConverter/server/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,kGAKnC,CAAA"}

package/dist/features/debug/jsxConverter/server/index.js

@@ -0,0 +1,8 @@
+import { createServerFeature } from '../../../../utilities/createServerFeature.js';
+export const DebugJsxConverterFeature = createServerFeature({
+  feature: {
+    ClientFeature: '@ruya.sa/richtext-lexical/client#DebugJsxConverterFeatureClient'
+  },
+  key: 'jsxConverter'
+});
+//# sourceMappingURL=index.js.map

package/dist/features/debug/jsxConverter/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createServerFeature","DebugJsxConverterFeature","feature","ClientFeature","key"],"sources":["../../../../../src/features/debug/jsxConverter/server/index.ts"],"sourcesContent":["import { createServerFeature } from '../../../../utilities/createServerFeature.js'\n\nexport const DebugJsxConverterFeature = createServerFeature({\n  feature: {\n    ClientFeature: '@ruya.sa/richtext-lexical/client#DebugJsxConverterFeatureClient',\n  },\n  key: 'jsxConverter',\n})\n"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ;AAEpC,OAAO,MAAMC,wBAAA,GAA2BD,mBAAA,CAAoB;EAC1DE,OAAA,EAAS;IACPC,aAAA,EAAe;EACjB;EACAC,GAAA,EAAK;AACP","ignoreList":[]}

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

@@ -0,0 +1,2 @@
+export declare const TestRecorderFeatureClient: import("../../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# 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,uFAOpC,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"}