@lexical/markdown 0.3.1 → 0.3.4

package/LexicalMarkdown.dev.js

@@ -18,7 +18,6 @@ var richText = require('@lexical/rich-text');
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  */
 function indexBy(list, callback) {
   const index = {};
@@ -51,7 +50,6 @@ const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  */
 function createMarkdownExport(transformers) {
   const byType = transformersByType(transformers); // Export only uses text formats that are responsible for single format
@@ -200,7 +198,6 @@ function hasFormat(node, format) {
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  */
 const CODE_BLOCK_REG_EXP = /^```(\w{1,10})?\s?$/;
 function createMarkdownImport(transformers) {
@@ -436,7 +433,6 @@ function createTextFormatTransformersIndex(textTransformers) {
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  */
 
 function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
@@ -726,7 +722,6 @@ function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
-
  */
 
 const replaceWithBlock = createNode => {
@@ -939,7 +934,6 @@ const LINK = {
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *
  */
 const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, CODE, UNORDERED_LIST, ORDERED_LIST]; // Order of text format transformers matters:
 //

package/README.md

@@ -22,21 +22,21 @@ editor.update(() => {
 
 It can also be used for initializing editor's state from markdown string. Here's an example with react `<RichTextPlugin>`
 ```jsx
-<LexicalComposer>
-  <RichTextPlugin initialEditorState={() => {
+<LexicalComposer initialEditorState={() => {
     $convertFromMarkdownString(markdown, TRANSFORMERS);
-  }} />
+  }}>
+  <RichTextPlugin />
 </LexicalComposer>
 ```
 
 ## Shortcuts
-Can use `<LexicalMarkdownShortcutPlugin>` if using React
+Can use `<MarkdownShortcutPlugin>` if using React
 ```jsx
 import { TRANSFORMERS } from '@lexical/markdown';
 import {MarkdownShortcutPlugin} from '@lexical/react/LexicalMarkdownShortcutPlugin';
 
 <LexicalComposer>
-  <LexicalMarkdownShortcutPlugin transformers={TRANSFORMERS} />
+  <MarkdownShortcutPlugin transformers={TRANSFORMERS} />
 </LexicalComposer>
 ```
 

package/autoFormatUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { AutoFormatTriggerState, ScanningContext } from './utils';
+import type { DecoratorNode, EditorState, LexicalEditor } from 'lexical';
+export declare function updateAutoFormatting<T>(editor: LexicalEditor, scanningContext: ScanningContext, createHorizontalRuleNode: () => DecoratorNode<T>): void;
+export declare function getTriggerState(editorState: EditorState): null | AutoFormatTriggerState;
+export declare function findScanningContext(editor: LexicalEditor, currentTriggerState: null | AutoFormatTriggerState, priorTriggerState: null | AutoFormatTriggerState): null | ScanningContext;

package/convertFromPlainTextUtils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { DecoratorNode, LexicalEditor, RootNode } from 'lexical';
+export declare function convertStringToLexical(text: string, editor: LexicalEditor): null | RootNode;
+export declare function convertMarkdownForElementNodes<T>(editor: LexicalEditor, createHorizontalRuleNode: null | (() => DecoratorNode<T>)): void;

package/convertToMarkdown.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export declare function $convertToMarkdownString(): string;

package/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { ElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from './v2/MarkdownTransformers';
+import { registerMarkdownShortcuts } from './v2/MarkdownShortcuts';
+import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, HEADING, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, STRIKETHROUGH, UNORDERED_LIST } from './v2/MarkdownTransformers';
+declare const ELEMENT_TRANSFORMERS: Array<ElementTransformer>;
+declare const TEXT_FORMAT_TRANSFORMERS: Array<TextFormatTransformer>;
+declare const TEXT_MATCH_TRANSFORMERS: Array<TextMatchTransformer>;
+declare const TRANSFORMERS: Array<Transformer>;
+declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>): void;
+declare function $convertToMarkdownString(transformers?: Array<Transformer>): string;
+export { $convertFromMarkdownString, $convertToMarkdownString, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, CHECK_LIST, CODE, ELEMENT_TRANSFORMERS, ElementTransformer, HEADING, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, LINK, ORDERED_LIST, QUOTE, registerMarkdownShortcuts, STRIKETHROUGH, TEXT_FORMAT_TRANSFORMERS, TEXT_MATCH_TRANSFORMERS, TextFormatTransformer, TextMatchTransformer, Transformer, TRANSFORMERS, UNORDERED_LIST, };

package/package.json

@@ -8,18 +8,18 @@
     "markdown"
   ],
   "license": "MIT",
-  "version": "0.3.1",
+  "version": "0.3.4",
   "main": "LexicalMarkdown.js",
   "peerDependencies": {
-    "lexical": "0.3.1"
+    "lexical": "0.3.4"
   },
   "dependencies": {
-    "@lexical/utils": "0.3.1",
-    "@lexical/code": "0.3.1",
-    "@lexical/text": "0.3.1",
-    "@lexical/rich-text": "0.3.1",
-    "@lexical/list": "0.3.1",
-    "@lexical/link": "0.3.1"
+    "@lexical/utils": "0.3.4",
+    "@lexical/code": "0.3.4",
+    "@lexical/text": "0.3.4",
+    "@lexical/rich-text": "0.3.4",
+    "@lexical/list": "0.3.4",
+    "@lexical/link": "0.3.4"
   },
   "repository": {
     "type": "git",

package/utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { TextNodeWithOffset } from '@lexical/text';
+import type { DecoratorNode, ElementNode, LexicalEditor, LexicalNode, NodeKey, TextFormatType } from 'lexical';
+export declare type AutoFormatTriggerState = Readonly<{
+    anchorOffset: number;
+    hasParentNode: boolean;
+    isCodeBlock: boolean;
+    isParentAListItemNode: boolean;
+    isSelectionCollapsed: boolean;
+    isSimpleText: boolean;
+    nodeKey: NodeKey;
+    textContent: string;
+}>;
+export declare type MarkdownFormatKind = 'noTransformation' | 'paragraphH1' | 'paragraphH2' | 'paragraphH3' | 'paragraphH4' | 'paragraphH5' | 'paragraphH6' | 'paragraphBlockQuote' | 'paragraphUnorderedList' | 'paragraphOrderedList' | 'paragraphCodeBlock' | 'horizontalRule' | 'bold' | 'code' | 'italic' | 'underline' | 'strikethrough' | 'italic_bold' | 'strikethrough_italic' | 'strikethrough_bold' | 'strikethrough_italic_bold' | 'link';
+export declare type ScanningContext = {
+    currentElementNode: null | ElementNode;
+    editor: LexicalEditor;
+    isAutoFormatting: boolean;
+    isWithinCodeBlock: boolean;
+    joinedText: string | null | undefined;
+    markdownCriteria: MarkdownCriteria;
+    patternMatchResults: PatternMatchResults;
+    textNodeWithOffset: TextNodeWithOffset | null | undefined;
+    triggerState: AutoFormatTriggerState | null | undefined;
+};
+export declare type MarkdownCriteria = Readonly<{
+    export?: (node: LexicalNode, traverseChildren: (node: ElementNode) => string) => string | null;
+    exportFormat?: TextFormatType;
+    exportTag?: string;
+    exportTagClose?: string;
+    markdownFormatKind: MarkdownFormatKind | null | undefined;
+    regEx: RegExp;
+    regExForAutoFormatting: RegExp;
+    requiresParagraphStart: boolean | null | undefined;
+}>;
+declare type CaptureGroupDetail = {
+    offsetInParent: number;
+    text: string;
+};
+export declare type PatternMatchResults = {
+    regExCaptureGroups: Array<CaptureGroupDetail>;
+};
+export declare type MarkdownCriteriaWithPatternMatchResults = {
+    markdownCriteria: null | MarkdownCriteria;
+    patternMatchResults: null | PatternMatchResults;
+};
+export declare type MarkdownCriteriaArray = Array<MarkdownCriteria>;
+export declare type AutoFormatTriggerKind = 'space_trigger' | 'codeBlock_trigger';
+export declare type AutoFormatTrigger = {
+    triggerKind: AutoFormatTriggerKind;
+    triggerString: string;
+};
+export declare const triggers: Array<AutoFormatTrigger>;
+export declare const allMarkdownCriteria: MarkdownCriteriaArray;
+export declare function getAllTriggers(): Array<AutoFormatTrigger>;
+export declare function getAllMarkdownCriteriaForParagraphs(): MarkdownCriteriaArray;
+export declare function getAllMarkdownCriteriaForTextNodes(): MarkdownCriteriaArray;
+export declare function getAllMarkdownCriteria(): MarkdownCriteriaArray;
+export declare function getInitialScanningContext(editor: LexicalEditor, isAutoFormatting: boolean, textNodeWithOffset: null | TextNodeWithOffset, triggerState: null | AutoFormatTriggerState): ScanningContext;
+export declare function resetScanningContext(scanningContext: ScanningContext): ScanningContext;
+export declare function getCodeBlockCriteria(): MarkdownCriteria;
+export declare function getPatternMatchResultsForCriteria(markdownCriteria: MarkdownCriteria, scanningContext: ScanningContext, parentElementNode: ElementNode): null | PatternMatchResults;
+export declare function getPatternMatchResultsForCodeBlock(scanningContext: ScanningContext, text: string): null | PatternMatchResults;
+export declare function hasPatternMatchResults(scanningContext: ScanningContext): boolean;
+export declare function getTextNodeWithOffsetOrThrow(scanningContext: ScanningContext): TextNodeWithOffset;
+export declare function transformTextNodeForMarkdownCriteria<T>(scanningContext: ScanningContext, elementNode: ElementNode, createHorizontalRuleNode: null | (() => DecoratorNode<T>)): void;
+export declare function getParentElementNodeOrThrow(scanningContext: ScanningContext): ElementNode;
+export {};

package/v2/MarkdownExport.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Transformer } from '@lexical/markdown';
+export declare function createMarkdownExport(transformers: Array<Transformer>): () => string;

package/v2/MarkdownImport.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Transformer } from '@lexical/markdown';
+export declare function createMarkdownImport(transformers: Array<Transformer>): (markdownString: string) => void;

package/v2/MarkdownShortcuts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Transformer } from '@lexical/markdown';
+import type { LexicalEditor } from 'lexical';
+export declare function registerMarkdownShortcuts(editor: LexicalEditor, transformers?: Array<Transformer>): () => void;

package/v2/MarkdownTransformers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { ElementNode, LexicalNode, TextFormatType, TextNode } from 'lexical';
+export declare type Transformer = ElementTransformer | TextFormatTransformer | TextMatchTransformer;
+export declare type ElementTransformer = {
+    export: (node: LexicalNode, traverseChildren: (node: ElementNode) => string) => string | null;
+    regExp: RegExp;
+    replace: (parentNode: ElementNode, children: Array<LexicalNode>, match: Array<string>, isImport: boolean) => void;
+    type: 'element';
+};
+export declare type TextFormatTransformer = Readonly<{
+    format: ReadonlyArray<TextFormatType>;
+    tag: string;
+    intraword?: boolean;
+    type: 'text-format';
+}>;
+export declare type TextMatchTransformer = Readonly<{
+    export: (node: LexicalNode, exportChildren: (node: ElementNode) => string, exportFormat: (node: TextNode, textContent: string) => string) => string | null;
+    importRegExp: RegExp;
+    regExp: RegExp;
+    replace: (node: TextNode, match: RegExpMatchArray) => void;
+    trigger: string;
+    type: 'text-match';
+}>;
+export declare const HEADING: ElementTransformer;
+export declare const QUOTE: ElementTransformer;
+export declare const CODE: ElementTransformer;
+export declare const UNORDERED_LIST: ElementTransformer;
+export declare const CHECK_LIST: ElementTransformer;
+export declare const ORDERED_LIST: ElementTransformer;
+export declare const INLINE_CODE: TextFormatTransformer;
+export declare const BOLD_ITALIC_STAR: TextFormatTransformer;
+export declare const BOLD_ITALIC_UNDERSCORE: TextFormatTransformer;
+export declare const BOLD_STAR: TextFormatTransformer;
+export declare const BOLD_UNDERSCORE: TextFormatTransformer;
+export declare const STRIKETHROUGH: TextFormatTransformer;
+export declare const ITALIC_STAR: TextFormatTransformer;
+export declare const ITALIC_UNDERSCORE: TextFormatTransformer;
+export declare const LINK: TextMatchTransformer;

package/v2/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { ElementTransformer, TextFormatTransformer, TextMatchTransformer, Transformer } from '@lexical/markdown';
+export declare function indexBy<T>(list: Array<T>, callback: (arg0: T) => string): Readonly<Record<string, Array<T>>>;
+export declare function transformersByType(transformers: Array<Transformer>): Readonly<{
+    element: Array<ElementTransformer>;
+    textFormat: Array<TextFormatTransformer>;
+    textMatch: Array<TextMatchTransformer>;
+}>;
+export declare const PUNCTUATION_OR_SPACE: RegExp;

package/LexicalMarkdown.d.ts

@@ -1,98 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import type {
-  LexicalEditor,
-  ElementNode,
-  LexicalNode,
-  TextNode,
-  TextFormatType,
-} from 'lexical';
-
-export type Transformer =
-  | ElementTransformer
-  | TextFormatTransformer
-  | TextMatchTransformer;
-
-export type ElementTransformer = {
-  export: (
-    node: LexicalNode,
-    traverseChildren: (node: ElementNode) => string,
-  ) => string | null;
-  regExp: RegExp;
-  replace: (
-    parentNode: ElementNode,
-    children: Array<LexicalNode>,
-    match: Array<string>,
-    isImport: boolean,
-  ) => void;
-  type: 'element';
-};
-
-export type TextFormatTransformer = {
-  format: Array<TextFormatType>;
-  tag: string;
-  intraword?: boolean;
-  type: 'text-format';
-};
-
-export type TextMatchTransformer = {
-  export: (
-    node: LexicalNode,
-    exportChildren: (node: ElementNode) => string,
-    exportFormat: (node: TextNode, textContent: string) => string,
-  ) => string | null;
-  importRegExp: RegExp;
-  regExp: RegExp;
-  replace: (node: TextNode, match: RegExpMatchArray) => void;
-  trigger: string;
-  type: 'text-match';
-};
-
-// TODO:
-// transformers should be required argument, breaking change
-export function registerMarkdownShortcuts(
-  editor: LexicalEditor,
-  transformers?: Array<Transformer>,
-): () => void;
-
-// TODO:
-// transformers should be required argument, breaking change
-export function $convertFromMarkdownString(
-  markdown: string,
-  transformers?: Array<Transformer>,
-): void;
-
-// TODO:
-// transformers should be required argument, breaking change
-export function $convertToMarkdownString(
-  transformers?: Array<Transformer>,
-): string;
-
-export const BOLD_ITALIC_STAR: TextFormatTransformer;
-export const BOLD_ITALIC_UNDERSCORE: TextFormatTransformer;
-export const BOLD_STAR: TextFormatTransformer;
-export const BOLD_UNDERSCORE: TextFormatTransformer;
-export const INLINE_CODE: TextFormatTransformer;
-export const ITALIC_STAR: TextFormatTransformer;
-export const ITALIC_UNDERSCORE: TextFormatTransformer;
-export const STRIKETHROUGH: TextFormatTransformer;
-
-export const UNORDERED_LIST: ElementTransformer;
-export const CODE: ElementTransformer;
-export const HEADING: ElementTransformer;
-export const ORDERED_LIST: ElementTransformer;
-export const QUOTE: ElementTransformer;
-export const CHECK_LIST: ElementTransformer;
-
-export const LINK: TextMatchTransformer;
-
-export const TRANSFORMERS: Array<Transformer>;
-export const ELEMENT_TRANSFORMERS: Array<ElementTransformer>;
-export const TEXT_FORMAT_TRANSFORMERS: Array<TextFormatTransformer>;
-export const TEXT_MATCH_TRANSFORMERS: Array<TextFormatTransformer>;