@lobehub/editor 1.0.0

package/es/locale/index.js

@@ -0,0 +1,24 @@
+export default {
+  file: {
+    error: 'Error: {{message}}',
+    uploading: 'Uploading file...'
+  },
+  image: {
+    broken: 'Broken image'
+  },
+  link: {
+    edit: 'Edit Link',
+    open: 'Open Link',
+    placeholder: 'Enter link URL',
+    unlink: 'Unlink Link'
+  },
+  table: {
+    delete: 'Delete table',
+    deleteColumn: 'Delete column',
+    deleteRow: 'Delete row',
+    insertColumnLeft: 'Insert {{count}} column(s) to the left',
+    insertColumnRight: 'Insert {{count}} column(s) to the right',
+    insertRowAbove: 'Insert {{count}} row(s) above',
+    insertRowBelow: 'Insert {{count}} row(s) below'
+  }
+};

package/es/plugins/codeblock/command/index.d.ts

@@ -0,0 +1,20 @@
+import { CodeNode } from '@lexical/code';
+import { LexicalEditor, LexicalNode } from 'lexical';
+export declare const CustomShikiTokenizer: {
+    $tokenize: (codeNode: CodeNode, language?: string | undefined) => LexicalNode[];
+    defaultColorReplacements: {
+        current?: import("../plugin/FacadeShiki").AllColorReplacements | undefined;
+    } | undefined;
+    defaultLanguage: string;
+    defaultTheme: string | {
+        dark: string;
+        light: string;
+    };
+};
+export declare const UPDATE_CODEBLOCK_LANG: import("lexical").LexicalCommand<{
+    lang: string;
+}>;
+export declare const UPDATE_CODEBLOCK_COLOR_REPLACEMENTS: import("lexical").LexicalCommand<{
+    colorReplacements?: import("../plugin/FacadeShiki").AllColorReplacements | undefined;
+}>;
+export declare function registerCodeCommand(editor: LexicalEditor): () => void;

package/es/plugins/codeblock/command/index.js

@@ -0,0 +1,84 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { $isCodeNode } from '@lexical/code';
+import { $findMatchingParent } from '@lexical/utils';
+import { $getRoot, $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import { ShikiTokenizer } from "../plugin/CodeHighlighterShiki";
+export var CustomShikiTokenizer = {
+  $tokenize: ShikiTokenizer.$tokenize,
+  defaultColorReplacements: ShikiTokenizer.defaultColorReplacements,
+  defaultLanguage: ShikiTokenizer.defaultLanguage,
+  defaultTheme: ShikiTokenizer.defaultTheme
+};
+export var UPDATE_CODEBLOCK_LANG = createCommand('UPDATE_CODEBLOCK_LANG');
+export var UPDATE_CODEBLOCK_COLOR_REPLACEMENTS = createCommand('UPDATE_CODEBLOCK_COLOR_REPLACEMENTS');
+function getAllCodeNode(rootNode) {
+  var codeNodes = [];
+  var child = rootNode.getFirstChild();
+  while (child !== null) {
+    if ($isCodeNode(child)) {
+      codeNodes.push(child);
+    }
+    if ($isElementNode(child)) {
+      var subChildrenNodes = getAllCodeNode(child);
+      codeNodes.push.apply(codeNodes, _toConsumableArray(subChildrenNodes));
+    }
+    child = child.getNextSibling();
+  }
+  return codeNodes;
+}
+export function registerCodeCommand(editor) {
+  var unregisterLangCommand = editor.registerCommand(UPDATE_CODEBLOCK_LANG, function (payload) {
+    CustomShikiTokenizer.defaultLanguage = payload.lang;
+    var codeNode = editor.read(function () {
+      var selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        if (selection.isCollapsed()) {
+          var node = $findMatchingParent(selection.anchor.getNode(), $isCodeNode);
+          return node;
+        } else {
+          var anchor = $findMatchingParent(selection.anchor.getNode(), $isCodeNode);
+          var focus = $findMatchingParent(selection.focus.getNode(), $isCodeNode);
+          if (anchor && focus && anchor === focus) {
+            return anchor;
+          }
+          return null;
+        }
+      }
+      return false;
+    });
+    if (!codeNode) {
+      return false;
+    }
+    // Need to defer execution due to possible transform execution order confusion from selection changes
+    queueMicrotask(function () {
+      editor.update(function () {
+        if ($isCodeNode(codeNode)) {
+          codeNode.setLanguage(payload.lang);
+        }
+      });
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  );
+  var unregisterColorReplacementsCommand = editor.registerCommand(UPDATE_CODEBLOCK_COLOR_REPLACEMENTS, function (payload) {
+    CustomShikiTokenizer.defaultColorReplacements = payload.colorReplacements;
+    editor.update(function () {
+      var codes = getAllCodeNode($getRoot());
+      codes.forEach(function (code) {
+        // Mark the code node as dirty to trigger re-highlighting with new color replacements
+        code.markDirty();
+      });
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  );
+  return function () {
+    unregisterLangCommand();
+    unregisterColorReplacementsCommand();
+  };
+}

package/es/plugins/codeblock/index.d.ts

@@ -0,0 +1,4 @@
+export { UPDATE_CODEBLOCK_LANG } from './command';
+export * from './plugin';
+export * from './react';
+export { bundledLanguagesInfo } from 'shiki';

package/es/plugins/codeblock/index.js

@@ -0,0 +1,4 @@
+export { UPDATE_CODEBLOCK_LANG } from "./command";
+export * from "./plugin";
+export * from "./react";
+export { bundledLanguagesInfo } from 'shiki';

package/es/plugins/codeblock/plugin/CodeHighlighterShiki.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { CodeNode } from '@lexical/code';
+import type { LexicalEditor, LexicalNode } from 'lexical';
+import { AllColorReplacements } from './FacadeShiki';
+export interface Tokenizer {
+    $tokenize(codeNode: CodeNode, language?: string): LexicalNode[];
+    defaultColorReplacements?: {
+        current?: AllColorReplacements;
+    };
+    defaultLanguage: string;
+    defaultTheme: string | {
+        dark: string;
+        light: string;
+    };
+}
+export declare const ShikiTokenizer: Tokenizer;
+export declare function toCodeTheme(tokenizer: Tokenizer): string;
+export declare function registerCodeHighlighting(editor: LexicalEditor, tokenizer?: Tokenizer): () => void;