@ruya.sa/richtext-lexical 3.71.7

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts

@@ -0,0 +1,23 @@
+import type { SerializedEditorState, SerializedLexicalNode } from 'lexical';
+export type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
+    converter: ({ childIndex, converters, lexicalPluginNode, parentNodeType, }: {
+        childIndex: number;
+        converters: LexicalPluginNodeConverter[];
+        lexicalPluginNode: {
+            children?: SerializedLexicalNode[];
+        } & SerializedLexicalNode;
+        parentNodeType: string;
+        quiet?: boolean;
+    }) => T;
+    nodeTypes: string[];
+};
+export type PayloadPluginLexicalData = {
+    characters: number;
+    comments: unknown[];
+    html?: string;
+    jsonContent: SerializedEditorState;
+    markdown?: string;
+    preview: string;
+    words: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE3E,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IAChG,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,0BAA0B,EAAE,CAAA;QACxC,iBAAiB,EAAE;YAAE,QAAQ,CAAC,EAAE,qBAAqB,EAAE,CAAA;SAAE,GAAG,qBAAqB,CAAA;QACjF,cAAc,EAAE,MAAM,CAAA;QACtB,KAAK,CAAC,EAAE,OAAO,CAAA;KAChB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/converter/types.js

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

package/dist/features/migrations/lexicalPluginToLexical/converter/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/lexicalPluginToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedEditorState, SerializedLexicalNode } from 'lexical'\n\nexport type LexicalPluginNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    lexicalPluginNode,\n    parentNodeType,\n  }: {\n    childIndex: number\n    converters: LexicalPluginNodeConverter[]\n    lexicalPluginNode: { children?: SerializedLexicalNode[] } & SerializedLexicalNode\n    parentNodeType: string\n    quiet?: boolean\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type PayloadPluginLexicalData = {\n  characters: number\n  comments: unknown[]\n  html?: string\n  jsonContent: SerializedEditorState\n  markdown?: string\n  preview: string\n  words: number\n}\n"],"mappings":"AAkBA","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/feature.client.d.ts

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

package/dist/features/migrations/lexicalPluginToLexical/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,mCAAmC,oFAI9C,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/feature.client.js

@@ -0,0 +1,10 @@
+'use client';
+
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {
+  return {
+    nodes: [UnknownConvertedNode]
+  };
+});
+//# sourceMappingURL=feature.client.js.map

package/dist/features/migrations/lexicalPluginToLexical/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","LexicalPluginToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const LexicalPluginToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,mCAAA,GAAsCF,mBAAA,CAAoB;EACrE,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts

@@ -0,0 +1,10 @@
+import type { LexicalPluginNodeConverter } from './converter/types.js';
+export type LexicalPluginToLexicalFeatureProps = {
+    converters?: (({ defaultConverters, }: {
+        defaultConverters: LexicalPluginNodeConverter[];
+    }) => LexicalPluginNodeConverter[]) | LexicalPluginNodeConverter[];
+    disableHooks?: boolean;
+    quiet?: boolean;
+};
+export declare const LexicalPluginToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<LexicalPluginToLexicalFeatureProps, LexicalPluginToLexicalFeatureProps, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAA4B,MAAM,sBAAsB,CAAA;AAOhG,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,CAAC,EACP,CAAC,CAAC,EACA,iBAAiB,GAClB,EAAE;QACD,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;KAChD,KAAK,0BAA0B,EAAE,CAAC,GACnC,0BAA0B,EAAE,CAAA;IAChC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,6BAA6B,iJAiDtC,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js

@@ -0,0 +1,49 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+import { defaultConverters } from './converter/defaultConverters.js';
+import { convertLexicalPluginToLexical } from './converter/index.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const LexicalPluginToLexicalFeature = createServerFeature({
+  feature: ({
+    props
+  }) => {
+    if (!props) {
+      props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+      converters = props.converters({
+        defaultConverters
+      });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+      converters = props.converters;
+    } else {
+      converters = defaultConverters;
+    }
+    props.converters = converters;
+    return {
+      ClientFeature: '@ruya.sa/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',
+      hooks: props.disableHooks ? undefined : {
+        afterRead: [({
+          value
+        }) => {
+          if (!value || !('jsonContent' in value)) {
+            // incomingEditorState null or not from Lexical Plugin
+            return value;
+          }
+          // Lexical Plugin => convert to lexical
+          return convertLexicalPluginToLexical({
+            converters: props.converters,
+            lexicalPluginData: value,
+            quiet: props?.quiet
+          });
+        }]
+      },
+      nodes: [{
+        node: UnknownConvertedNode
+      }],
+      sanitizedServerFeatureProps: props
+    };
+  },
+  key: 'lexicalPluginToLexical'
+});
+//# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/lexicalPluginToLexical/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.js","names":["createServerFeature","defaultConverters","convertLexicalPluginToLexical","UnknownConvertedNode","LexicalPluginToLexicalFeature","feature","props","converters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","lexicalPluginData","quiet","nodes","node","sanitizedServerFeatureProps","key"],"sources":["../../../../src/features/migrations/lexicalPluginToLexical/feature.server.ts"],"sourcesContent":["import type { LexicalPluginNodeConverter, PayloadPluginLexicalData } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultConverters } from './converter/defaultConverters.js'\nimport { convertLexicalPluginToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type LexicalPluginToLexicalFeatureProps = {\n  converters?:\n    | (({\n        defaultConverters,\n      }: {\n        defaultConverters: LexicalPluginNodeConverter[]\n      }) => LexicalPluginNodeConverter[])\n    | LexicalPluginNodeConverter[]\n  disableHooks?: boolean\n  quiet?: boolean\n}\n\nexport const LexicalPluginToLexicalFeature =\n  createServerFeature<LexicalPluginToLexicalFeatureProps>({\n    feature: ({ props }) => {\n      if (!props) {\n        props = {}\n      }\n\n      let converters: LexicalPluginNodeConverter[] = []\n\n      if (props?.converters && typeof props?.converters === 'function') {\n        converters = props.converters({ defaultConverters })\n      } else if (props.converters && typeof props?.converters !== 'function') {\n        converters = props.converters\n      } else {\n        converters = defaultConverters\n      }\n\n      props.converters = converters\n\n      return {\n        ClientFeature: '@ruya.sa/richtext-lexical/client#LexicalPluginToLexicalFeatureClient',\n        hooks: props.disableHooks\n          ? undefined\n          : {\n              afterRead: [\n                ({ value }) => {\n                  if (!value || !('jsonContent' in value)) {\n                    // incomingEditorState null or not from Lexical Plugin\n                    return value\n                  }\n\n                  // Lexical Plugin => convert to lexical\n                  return convertLexicalPluginToLexical({\n                    converters: props.converters as LexicalPluginNodeConverter[],\n                    lexicalPluginData: value as PayloadPluginLexicalData,\n                    quiet: props?.quiet,\n                  })\n                },\n              ],\n            },\n        nodes: [\n          {\n            node: UnknownConvertedNode,\n          },\n        ],\n        sanitizedServerFeatureProps: props,\n      }\n    },\n    key: 'lexicalPluginToLexical',\n  })\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,iBAAiB,QAAQ;AAClC,SAASC,6BAA6B,QAAQ;AAC9C,SAASC,oBAAoB,QAAQ;AAcrC,OAAO,MAAMC,6BAAA,GACXJ,mBAAA,CAAwD;EACtDK,OAAA,EAASA,CAAC;IAAEC;EAAK,CAAE;IACjB,IAAI,CAACA,KAAA,EAAO;MACVA,KAAA,GAAQ,CAAC;IACX;IAEA,IAAIC,UAAA,GAA2C,EAAE;IAEjD,IAAID,KAAA,EAAOC,UAAA,IAAc,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MAChEA,UAAA,GAAaD,KAAA,CAAMC,UAAU,CAAC;QAAEN;MAAkB;IACpD,OAAO,IAAIK,KAAA,CAAMC,UAAU,IAAI,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MACtEA,UAAA,GAAaD,KAAA,CAAMC,UAAU;IAC/B,OAAO;MACLA,UAAA,GAAaN,iBAAA;IACf;IAEAK,KAAA,CAAMC,UAAU,GAAGA,UAAA;IAEnB,OAAO;MACLC,aAAA,EAAe;MACfC,KAAA,EAAOH,KAAA,CAAMI,YAAY,GACrBC,SAAA,GACA;QACEC,SAAA,EAAW,CACT,CAAC;UAAEC;QAAK,CAAE;UACR,IAAI,CAACA,KAAA,IAAS,EAAE,iBAAiBA,KAAI,GAAI;YACvC;YACA,OAAOA,KAAA;UACT;UAEA;UACA,OAAOX,6BAAA,CAA8B;YACnCK,UAAA,EAAYD,KAAA,CAAMC,UAAU;YAC5BO,iBAAA,EAAmBD,KAAA;YACnBE,KAAA,EAAOT,KAAA,EAAOS;UAChB;QACF;MAEJ;MACJC,KAAA,EAAO,CACL;QACEC,IAAA,EAAMd;MACR,EACD;MACDe,2BAAA,EAA6BZ;IAC/B;EACF;EACAa,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { UnknownConvertedNodeData } from './index.js';
+import './index.scss';
+type Props = {
+    data: UnknownConvertedNodeData;
+};
+export declare const UnknownConvertedNodeComponent: React.FC<Props>;
+export {};
+//# sourceMappingURL=Component.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js

@@ -0,0 +1,15 @@
+'use client';
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+export const UnknownConvertedNodeComponent = props => {
+  const {
+    data
+  } = props;
+  return /*#__PURE__*/_jsxs("div", {
+    children: ["Unknown converted payload-plugin-lexical node: ", /*#__PURE__*/_jsx("strong", {
+      children: data?.nodeType
+    })]
+  });
+};
+//# sourceMappingURL=Component.js.map

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Component.js","names":["React","UnknownConvertedNodeComponent","props","data","_jsxs","_jsx","nodeType"],"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted payload-plugin-lexical node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"mappings":"AAAA;;;AACA,OAAOA,KAAA,MAAW;AAUlB,OAAO,MAAMC,6BAAA,GAAkDC,KAAA;EAC7D,MAAM;IAAEC;EAAI,CAAE,GAAGD,KAAA;EAEjB,oBACEE,KAAA,CAAC;eAAI,mD,aAC4CC,IAAA,CAAC;gBAAQF,IAAA,EAAMG;;;AAGpE","ignoreList":[]}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.d.ts

@@ -0,0 +1,33 @@
+import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import type { JSX } from 'react';
+import { DecoratorNode } from 'lexical';
+export type UnknownConvertedNodeData = {
+    nodeData: unknown;
+    nodeType: string;
+};
+export type SerializedUnknownConvertedNode = Spread<{
+    data: UnknownConvertedNodeData;
+}, SerializedLexicalNode>;
+/** @noInheritDoc */
+export declare class UnknownConvertedNode extends DecoratorNode<JSX.Element> {
+    __data: UnknownConvertedNodeData;
+    constructor({ data, key }: {
+        data: UnknownConvertedNodeData;
+        key?: NodeKey;
+    });
+    static clone(node: UnknownConvertedNode): UnknownConvertedNode;
+    static getType(): string;
+    static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode;
+    canInsertTextAfter(): true;
+    canInsertTextBefore(): true;
+    createDOM(config: EditorConfig): HTMLElement;
+    decorate(): JSX.Element;
+    exportJSON(): SerializedUnknownConvertedNode;
+    isInline(): boolean;
+    updateDOM(prevNode: this, dom: HTMLElement): boolean;
+}
+export declare function $createUnknownConvertedNode({ data, }: {
+    data: UnknownConvertedNodeData;
+}): UnknownConvertedNode;
+export declare function $isUnknownConvertedNode(node: LexicalNode | null | undefined): node is UnknownConvertedNode;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAyB,aAAa,EAAE,MAAM,SAAS,CAAA;AAG9D,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;WAK5D,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;WAOvD,OAAO,IAAI,MAAM;WAIjB,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKhG,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAIlB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO;IAIvB,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAG9D;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAMvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, DecoratorNode } from 'lexical';
+import * as React from 'react';
+const Component = /*#__PURE__*/React.lazy(() => import('./Component.js').then(module => ({
+  default: module.UnknownConvertedNodeComponent
+})));
+/** @noInheritDoc */
+export class UnknownConvertedNode extends DecoratorNode {
+  __data;
+  constructor({
+    data,
+    key
+  }) {
+    super(key);
+    this.__data = data;
+  }
+  static clone(node) {
+    return new this({
+      data: node.__data,
+      key: node.__key
+    });
+  }
+  static getType() {
+    return 'unknownConverted';
+  }
+  static importJSON(serializedNode) {
+    const node = $createUnknownConvertedNode({
+      data: serializedNode.data
+    });
+    return node;
+  }
+  canInsertTextAfter() {
+    return true;
+  }
+  canInsertTextBefore() {
+    return true;
+  }
+  createDOM(config) {
+    const element = document.createElement('span');
+    addClassNamesToElement(element, 'unknownConverted');
+    return element;
+  }
+  decorate() {
+    return /*#__PURE__*/_jsx(Component, {
+      data: this.__data
+    });
+  }
+  exportJSON() {
+    return {
+      type: this.getType(),
+      data: this.__data,
+      version: 1
+    };
+  }
+  // Mutation
+  isInline() {
+    return true;
+  }
+  updateDOM(prevNode, dom) {
+    return false;
+  }
+}
+export function $createUnknownConvertedNode({
+  data
+}) {
+  return $applyNodeReplacement(new UnknownConvertedNode({
+    data
+  }));
+}
+export function $isUnknownConvertedNode(node) {
+  return node instanceof UnknownConvertedNode;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["addClassNamesToElement","$applyNodeReplacement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","_jsx","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"sources":["../../../../../../src/features/migrations/lexicalPluginToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { $applyNodeReplacement, DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static override clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new this({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static override getType(): string {\n    return 'unknownConverted'\n  }\n\n  static override importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  override createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  override decorate(): JSX.Element {\n    return <Component data={this.__data} />\n  }\n\n  override exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  override isInline(): boolean {\n    return true\n  }\n\n  override updateDOM(prevNode: this, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return $applyNodeReplacement(\n    new UnknownConvertedNode({\n      data,\n    }),\n  )\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,qBAAqB,EAAEC,aAAa,QAAQ;AACrD,YAAYC,KAAA,MAAW;AAcvB,MAAMC,SAAA,gBAAYD,KAAA,CAAME,IAAI,CAAC,MAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAEC,MAAA,KAAY;EACzCC,OAAA,EAASD,MAAA,CAAOE;AAClB;AAGF;AACA,OAAO,MAAMC,oBAAA,SAA6BR,aAAA;EACxCS,MAAA;EAEAC,YAAY;IAAEC,IAAI;IAAEC;EAAG,CAAqD,EAAE;IAC5E,KAAK,CAACA,GAAA;IACN,IAAI,CAACH,MAAM,GAAGE,IAAA;EAChB;EAEA,OAAgBE,MAAMC,IAA0B,EAAwB;IACtE,OAAO,IAAI,IAAI,CAAC;MACdH,IAAA,EAAMG,IAAA,CAAKL,MAAM;MACjBG,GAAA,EAAKE,IAAA,CAAKC;IACZ;EACF;EAEA,OAAgBC,QAAA,EAAkB;IAChC,OAAO;EACT;EAEA,OAAgBC,WAAWC,cAA8C,EAAwB;IAC/F,MAAMJ,IAAA,GAAOK,2BAAA,CAA4B;MAAER,IAAA,EAAMO,cAAA,CAAeP;IAAK;IACrE,OAAOG,IAAA;EACT;EAEAM,mBAAA,EAA2B;IACzB,OAAO;EACT;EAEAC,oBAAA,EAA4B;IAC1B,OAAO;EACT;EAESC,UAAUC,MAAoB,EAAe;IACpD,MAAMC,OAAA,GAAUC,QAAA,CAASC,aAAa,CAAC;IACvC5B,sBAAA,CAAuB0B,OAAA,EAAS;IAChC,OAAOA,OAAA;EACT;EAESG,SAAA,EAAwB;IAC/B,oBAAOC,IAAA,CAAC1B,SAAA;MAAUS,IAAA,EAAM,IAAI,CAACF;;EAC/B;EAESoB,WAAA,EAA6C;IACpD,OAAO;MACLC,IAAA,EAAM,IAAI,CAACd,OAAO;MAClBL,IAAA,EAAM,IAAI,CAACF,MAAM;MACjBsB,OAAA,EAAS;IACX;EACF;EAEA;EAESC,SAAA,EAAoB;IAC3B,OAAO;EACT;EAESC,UAAUC,QAAc,EAAEC,GAAgB,EAAW;IAC5D,OAAO;EACT;AACF;AAEA,OAAO,SAAShB,4BAA4B;EAC1CR;AAAI,CAGL;EACC,OAAOZ,qBAAA,CACL,IAAIS,oBAAA,CAAqB;IACvBG;EACF;AAEJ;AAEA,OAAO,SAASyB,wBACdtB,IAAoC;EAEpC,OAAOA,IAAA,YAAgBN,oBAAA;AACzB","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateBlockquoteConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,wBAAwB,EAAE,kBAiBtC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.js

@@ -0,0 +1,23 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateBlockquoteConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'quote',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'quote',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    };
+  },
+  nodeTypes: ['blockquote']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/blockquote/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateBlockquoteConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/blockquote/converter.ts"],"sourcesContent":["import type { SerializedQuoteNode } from '../../../../../blockquote/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateBlockquoteConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'quote',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'quote',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    } as const as SerializedQuoteNode\n  },\n  nodeTypes: ['blockquote'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,wBAAA,GAA+C;EAC1DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateHeadingConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAkBnC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.js

@@ -0,0 +1,24 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateHeadingConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'heading',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'heading',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      tag: slateNode.type,
+      version: 1
+    };
+  },
+  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/heading/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateHeadingConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/heading/converter.ts"],"sourcesContent":["import type { SerializedHeadingNode } from '../../../../../heading/server/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateHeadingConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'heading',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'heading',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      tag: slateNode.type as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', // Slate puts the tag (h1 / h2 / ...) inside of node.type\n      version: 1,\n    } as const as SerializedHeadingNode\n  },\n  nodeTypes: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,qBAAA,GAA4C;EACvDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,GAAA,EAAKT,SAAA,CAAUC,IAAI;MACnBS,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC,MAAM,MAAM,MAAM,MAAM,MAAM;AAC5C","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateIndentConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,oBAAoB,EAAE,kBAgClC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.js

@@ -0,0 +1,33 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateIndentConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    const convertChildren = (node, indentLevel = 0) => {
+      if (node?.type && (!node.children || node.type !== 'indent') || !node?.type && node?.text) {
+        return {
+          ...convertSlateNodesToLexical({
+            canContainParagraphs: false,
+            converters,
+            parentNodeType: 'indent',
+            slateNodes: [node]
+          })[0],
+          indent: indentLevel
+        };
+      }
+      const children = node.children.map(child => convertChildren(child, indentLevel + 1));
+      return {
+        type: 'paragraph',
+        children,
+        direction: 'ltr',
+        format: '',
+        indent: indentLevel,
+        version: 1
+      };
+    };
+    return convertChildren(slateNode);
+  },
+  nodeTypes: ['indent']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/indent/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateIndentConverter","converter","converters","slateNode","convertChildren","node","indentLevel","type","children","text","canContainParagraphs","parentNodeType","slateNodes","indent","map","child","direction","format","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/indent/converter.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedParagraphNode } from 'lexical'\n\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateIndentConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    const convertChildren = (node: any, indentLevel: number = 0): SerializedLexicalNode => {\n      if (\n        (node?.type && (!node.children || node.type !== 'indent')) ||\n        (!node?.type && node?.text)\n      ) {\n        return {\n          ...convertSlateNodesToLexical({\n            canContainParagraphs: false,\n            converters,\n            parentNodeType: 'indent',\n            slateNodes: [node],\n          })[0],\n          indent: indentLevel,\n        } as const as SerializedLexicalNode\n      }\n\n      const children = node.children.map((child: any) => convertChildren(child, indentLevel + 1))\n      return {\n        type: 'paragraph',\n        children,\n        direction: 'ltr',\n        format: '',\n        indent: indentLevel,\n        version: 1,\n      } as const as SerializedParagraphNode\n    }\n\n    return convertChildren(slateNode)\n  },\n  nodeTypes: ['indent'],\n}\n"],"mappings":"AAIA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,oBAAA,GAA2C;EACtDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,MAAMC,eAAA,GAAkBA,CAACC,IAAA,EAAWC,WAAA,GAAsB,CAAC;MACzD,IACED,IAAC,EAAME,IAAA,KAAS,CAACF,IAAA,CAAKG,QAAQ,IAAIH,IAAA,CAAKE,IAAI,KAAK,QAAO,KACtD,CAACF,IAAA,EAAME,IAAA,IAAQF,IAAA,EAAMI,IAAA,EACtB;QACA,OAAO;UACL,GAAGV,0BAAA,CAA2B;YAC5BW,oBAAA,EAAsB;YACtBR,UAAA;YACAS,cAAA,EAAgB;YAChBC,UAAA,EAAY,CAACP,IAAA;UACf,EAAE,CAAC,EAAE;UACLQ,MAAA,EAAQP;QACV;MACF;MAEA,MAAME,QAAA,GAAWH,IAAA,CAAKG,QAAQ,CAACM,GAAG,CAAEC,KAAA,IAAeX,eAAA,CAAgBW,KAAA,EAAOT,WAAA,GAAc;MACxF,OAAO;QACLC,IAAA,EAAM;QACNC,QAAA;QACAQ,SAAA,EAAW;QACXC,MAAA,EAAQ;QACRJ,MAAA,EAAQP,WAAA;QACRY,OAAA,EAAS;MACX;IACF;IAEA,OAAOd,eAAA,CAAgBD,SAAA;EACzB;EACAgB,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateLinkConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,kBAAkB,EAAE,kBAwBhC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.js

@@ -0,0 +1,30 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateLinkConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'link',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'link',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      fields: {
+        ...(slateNode.fields || {}),
+        doc: slateNode.doc || null,
+        linkType: slateNode.linkType || 'custom',
+        newTab: slateNode.newTab || false,
+        url: (slateNode.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined
+      },
+      format: '',
+      indent: 0,
+      version: 2
+    };
+  },
+  nodeTypes: ['link']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/link/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateLinkConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","fields","doc","linkType","newTab","url","undefined","format","indent","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/link/converter.ts"],"sourcesContent":["import type { SerializedLinkNode } from '../../../../../link/nodes/types.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateLinkConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'link',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'link',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      fields: {\n        ...(slateNode.fields || {}),\n        doc: slateNode.doc || null,\n        linkType: slateNode.linkType || 'custom',\n        newTab: slateNode.newTab || false,\n        url: (slateNode.linkType || 'custom') === 'custom' ? slateNode.url || 'https' : undefined, // can be undefined only if linkType is not custom, otherwise: validation error\n      },\n      format: '',\n      indent: 0,\n      version: 2,\n    } as const as SerializedLinkNode\n  },\n  nodeTypes: ['link'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,kBAAA,GAAyC;EACpDC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;QACN,IAAIP,SAAA,CAAUO,MAAM,IAAI,CAAC,CAAC;QAC1BC,GAAA,EAAKR,SAAA,CAAUQ,GAAG,IAAI;QACtBC,QAAA,EAAUT,SAAA,CAAUS,QAAQ,IAAI;QAChCC,MAAA,EAAQV,SAAA,CAAUU,MAAM,IAAI;QAC5BC,GAAA,EAAK,CAACX,SAAA,CAAUS,QAAQ,IAAI,QAAO,MAAO,WAAWT,SAAA,CAAUW,GAAG,IAAI,UAAUC;MAClF;MACAC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateListItemConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,sBAAsB,EAAE,kBAmBpC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.js

@@ -0,0 +1,26 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateListItemConverter = {
+  converter({
+    childIndex,
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'listitem',
+      checked: undefined,
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'listitem',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      value: childIndex + 1,
+      version: 1
+    };
+  },
+  nodeTypes: ['li']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/listItem/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateListItemConverter","converter","childIndex","converters","slateNode","type","checked","undefined","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","value","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/listItem/converter.ts"],"sourcesContent":["import type { SerializedListItemNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateListItemConverter: SlateNodeConverter = {\n  converter({ childIndex, converters, slateNode }) {\n    return {\n      type: 'listitem',\n      checked: undefined,\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'listitem',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      value: childIndex + 1,\n      version: 1,\n    } as const as SerializedListItemNode\n  },\n  nodeTypes: ['li'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,sBAAA,GAA6C;EACxDC,UAAU;IAAEC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IAC7C,OAAO;MACLC,IAAA,EAAM;MACNC,OAAA,EAASC,SAAA;MACTC,QAAA,EAAUT,0BAAA,CAA2B;QACnCU,oBAAA,EAAsB;QACtBN,UAAA;QACAO,cAAA,EAAgB;QAChBC,UAAA,EAAYP,SAAA,CAAUI;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,KAAA,EAAOb,UAAA,GAAa;MACpBc,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateOrderedListConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,yBAAyB,EAAE,kBAoBvC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js

@@ -0,0 +1,26 @@
+import { convertSlateNodesToLexical } from '../../index.js';
+export const SlateOrderedListConverter = {
+  converter({
+    converters,
+    slateNode
+  }) {
+    return {
+      type: 'list',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: false,
+        converters,
+        parentNodeType: 'list',
+        slateNodes: slateNode.children
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      listType: 'number',
+      start: 1,
+      tag: 'ol',
+      version: 1
+    };
+  },
+  nodeTypes: ['ol']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/orderedList/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["convertSlateNodesToLexical","SlateOrderedListConverter","converter","converters","slateNode","type","children","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","listType","start","tag","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/orderedList/converter.ts"],"sourcesContent":["import type { SerializedListNode } from '../../../../../lists/plugin/index.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nimport { convertSlateNodesToLexical } from '../../index.js'\n\nexport const SlateOrderedListConverter: SlateNodeConverter = {\n  converter({ converters, slateNode }) {\n    return {\n      type: 'list',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: false,\n        converters,\n        parentNodeType: 'list',\n        slateNodes: slateNode.children!,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      listType: 'number',\n      start: 1,\n      tag: 'ol',\n      version: 1,\n    } as const as SerializedListNode\n  },\n  nodeTypes: ['ol'],\n}\n"],"mappings":"AAGA,SAASA,0BAA0B,QAAQ;AAE3C,OAAO,MAAMC,yBAAA,GAAgD;EAC3DC,UAAU;IAAEC,UAAU;IAAEC;EAAS,CAAE;IACjC,OAAO;MACLC,IAAA,EAAM;MACNC,QAAA,EAAUN,0BAAA,CAA2B;QACnCO,oBAAA,EAAsB;QACtBJ,UAAA;QACAK,cAAA,EAAgB;QAChBC,UAAA,EAAYL,SAAA,CAAUE;MACxB;MACAI,SAAA,EAAW;MACXC,MAAA,EAAQ;MACRC,MAAA,EAAQ;MACRC,QAAA,EAAU;MACVC,KAAA,EAAO;MACPC,GAAA,EAAK;MACLC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateRelationshipConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,eAAO,MAAM,0BAA0B,EAAE,kBAWxC,CAAA"}

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js

@@ -0,0 +1,15 @@
+export const SlateRelationshipConverter = {
+  converter({
+    slateNode
+  }) {
+    return {
+      type: 'relationship',
+      format: '',
+      relationTo: slateNode.relationTo,
+      value: slateNode?.value?.id || '',
+      version: 2
+    };
+  },
+  nodeTypes: ['relationship']
+};
+//# sourceMappingURL=converter.js.map

package/dist/features/migrations/slateToLexical/converter/converters/relationship/converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.js","names":["SlateRelationshipConverter","converter","slateNode","type","format","relationTo","value","id","version","nodeTypes"],"sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/relationship/converter.ts"],"sourcesContent":["import type { SerializedRelationshipNode } from '../../../../../relationship/server/nodes/RelationshipNode.js'\nimport type { SlateNodeConverter } from '../../types.js'\n\nexport const SlateRelationshipConverter: SlateNodeConverter = {\n  converter({ slateNode }) {\n    return {\n      type: 'relationship',\n      format: '',\n      relationTo: slateNode.relationTo,\n      value: slateNode?.value?.id || '',\n      version: 2,\n    } as const as SerializedRelationshipNode\n  },\n  nodeTypes: ['relationship'],\n}\n"],"mappings":"AAGA,OAAO,MAAMA,0BAAA,GAAiD;EAC5DC,UAAU;IAAEC;EAAS,CAAE;IACrB,OAAO;MACLC,IAAA,EAAM;MACNC,MAAA,EAAQ;MACRC,UAAA,EAAYH,SAAA,CAAUG,UAAU;MAChCC,KAAA,EAAOJ,SAAA,EAAWI,KAAA,EAAOC,EAAA,IAAM;MAC/BC,OAAA,EAAS;IACX;EACF;EACAC,SAAA,EAAW,CAAC;AACd","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts

@@ -0,0 +1,3 @@
+import type { SlateNodeConverter } from '../../types.js';
+export declare const SlateUnknownConverter: SlateNodeConverter;
+//# sourceMappingURL=converter.d.ts.map

package/dist/features/migrations/slateToLexical/converter/converters/unknown/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../../../../../../src/features/migrations/slateToLexical/converter/converters/unknown/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAIxD,eAAO,MAAM,qBAAqB,EAAE,kBAqBnC,CAAA"}