@blocknote/code-block 0.30.1 → 0.31.0

package/dist/webpack-stats.json

@@ -1 +1 @@
-{"builtAt":1747749749764,"assets":[{"name":"blocknote-code-block.cjs","size":6844},{"name":"blocknote-code-block.cjs.map","size":14773}],"chunks":[{"id":"a1ee98a","entry":true,"initial":true,"files":["blocknote-code-block.cjs"],"names":["blocknote-code-block"]}],"modules":[{"name":"./src/shiki.bundle.ts","size":4614,"chunks":["a1ee98a"]},{"name":"./src/index.ts","size":3574,"chunks":["a1ee98a"]}]}
+{"builtAt":1747754363170,"assets":[{"name":"blocknote-code-block.cjs","size":6844},{"name":"blocknote-code-block.cjs.map","size":14773}],"chunks":[{"id":"a1ee98a","entry":true,"initial":true,"files":["blocknote-code-block.cjs"],"names":["blocknote-code-block"]}],"modules":[{"name":"./src/shiki.bundle.ts","size":4614,"chunks":["a1ee98a"]},{"name":"./src/index.ts","size":3574,"chunks":["a1ee98a"]}]}

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/code-block"
   },
   "license": "MPL-2.0",
-  "version": "0.30.1",
+  "version": "0.31.0",
   "files": [
     "dist",
     "types",
@@ -42,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@blocknote/core": "0.30.1",
+    "@blocknote/core": "0.31.0",
     "@shikijs/core": "^3.2.1",
     "@shikijs/engine-javascript": "^3.2.1",
     "@shikijs/langs-precompiled": "^3.2.1",
@@ -59,7 +59,7 @@
     "vitest": "^2.0.3"
   },
   "peerDependencies": {
-    "@blocknote/core": "^0.30.1"
+    "@blocknote/core": "^0.31.0"
   },
   "eslintConfig": {
     "extends": [

package/types/src/context/ServerBlockNoteEditor.d.ts

@@ -0,0 +1,137 @@
+import { Block, BlockNoteEditor, BlockNoteEditorOptions, BlockSchema, DefaultBlockSchema, DefaultInlineContentSchema, DefaultStyleSchema, InlineContentSchema, PartialBlock, StyleSchema } from "@blocknote/core";
+import { Node } from "@tiptap/pm/model";
+import * as React from "react";
+import type * as Y from "yjs";
+/**
+ * Use the ServerBlockNoteEditor to interact with BlockNote documents in a server (nodejs) environment.
+ */
+export declare class ServerBlockNoteEditor<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema> {
+    /**
+     * Internal BlockNoteEditor (not recommended to use directly, use the methods of this class instead)
+     */
+    readonly editor: BlockNoteEditor<BSchema, ISchema, SSchema>;
+    /**
+     * We currently use a JSDOM instance to mock document and window methods
+     *
+     * A possible improvement could be to make this:
+     * a) pluggable so other shims can be used as well
+     * b) obsolete, but for this all blocks should be React based and we need to remove all references to document / window
+     *    from the core / react package. (and even then, it's likely some custom blocks would still use document / window methods)
+     */
+    private jsdom;
+    /**
+     * Calls a function with mocking window and document using JSDOM
+     *
+     * We could make this obsolete by passing in a document / window object to the render / serialize methods of Blocks
+     */
+    _withJSDOM<T>(fn: () => Promise<T>): Promise<T>;
+    static create<BSchema extends BlockSchema = DefaultBlockSchema, ISchema extends InlineContentSchema = DefaultInlineContentSchema, SSchema extends StyleSchema = DefaultStyleSchema>(options?: Partial<BlockNoteEditorOptions<BSchema, ISchema, SSchema>>): ServerBlockNoteEditor<BSchema, ISchema, SSchema>;
+    protected constructor(options: Partial<BlockNoteEditorOptions<any, any, any>>);
+    /** PROSEMIRROR / BLOCKNOTE conversions */
+    /**
+     * Turn Prosemirror JSON to BlockNote style JSON
+     * @param json Prosemirror JSON
+     * @returns BlockNote style JSON
+     */
+    _prosemirrorNodeToBlocks(pmNode: Node): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Turn Prosemirror JSON to BlockNote style JSON
+     * @param json Prosemirror JSON
+     * @returns BlockNote style JSON
+     */
+    _prosemirrorJSONToBlocks(json: any): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Turn BlockNote JSON to Prosemirror node / state
+     * @param blocks BlockNote blocks
+     * @returns Prosemirror root node
+     */
+    _blocksToProsemirrorNode(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Node;
+    /** YJS / BLOCKNOTE conversions */
+    /**
+     * Turn a Y.XmlFragment collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)
+     * @returns BlockNote document (BlockNote style JSON of all blocks)
+     */
+    yXmlFragmentToBlocks(xmlFragment: Y.XmlFragment): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * Convert blocks to a Y.XmlFragment
+     *
+     * This can be used when importing existing content to Y.Doc for the first time,
+     * note that this should not be used to rehydrate a Y.Doc from a database once
+     * collaboration has begun as all history will be lost
+     *
+     * @param blocks the blocks to convert
+     * @returns Y.XmlFragment
+     */
+    blocksToYXmlFragment(blocks: Block<BSchema, ISchema, SSchema>[], xmlFragment?: Y.XmlFragment): Y.XmlFragment;
+    /**
+     * Turn a Y.Doc collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)
+     * @returns BlockNote document (BlockNote style JSON of all blocks)
+     */
+    yDocToBlocks(ydoc: Y.Doc, xmlFragment?: string): Block<BSchema, InlineContentSchema, StyleSchema>[];
+    /**
+     * This can be used when importing existing content to Y.Doc for the first time,
+     * note that this should not be used to rehydrate a Y.Doc from a database once
+     * collaboration has begun as all history will be lost
+     *
+     * @param blocks
+     */
+    blocksToYDoc(blocks: PartialBlock<BSchema, ISchema, SSchema>[], xmlFragment?: string): Y.Doc;
+    /** HTML / BLOCKNOTE conversions */
+    /**
+     * Exports blocks into a simplified HTML string. To better conform to HTML standards, children of blocks which aren't list
+     * items are un-nested in the output HTML.
+     *
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToHTMLLossy(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Serializes blocks into an HTML string in the format that would normally be rendered by the editor.
+     *
+     * Use this method if you want to server-side render HTML (for example, a blog post that has been edited in BlockNote)
+     * and serve it to users without loading the editor on the client (i.e.: displaying the blog post)
+     *
+     * @param blocks An array of blocks that should be serialized into HTML.
+     * @returns The blocks, serialized as an HTML string.
+     */
+    blocksToFullHTML(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Parses blocks from an HTML string. Tries to create `Block` objects out of any HTML block-level elements, and
+     * `InlineNode` objects from any HTML inline elements, though not all element types are recognized. If BlockNote
+     * doesn't recognize an HTML element's tag, it will parse it as a paragraph or plain text.
+     * @param html The HTML string to parse blocks from.
+     * @returns The blocks parsed from the HTML string.
+     */
+    tryParseHTMLToBlocks(html: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /** MARKDOWN / BLOCKNOTE conversions */
+    /**
+     * Serializes blocks into a Markdown string. The output is simplified as Markdown does not support all features of
+     * BlockNote - children of blocks which aren't list items are un-nested and certain styles are removed.
+     * @param blocks An array of blocks that should be serialized into Markdown.
+     * @returns The blocks, serialized as a Markdown string.
+     */
+    blocksToMarkdownLossy(blocks: PartialBlock<BSchema, ISchema, SSchema>[]): Promise<string>;
+    /**
+     * Creates a list of blocks from a Markdown string. Tries to create `Block` and `InlineNode` objects based on
+     * Markdown syntax, though not all symbols are recognized. If BlockNote doesn't recognize a symbol, it will parse it
+     * as text.
+     * @param markdown The Markdown string to parse blocks from.
+     * @returns The blocks parsed from the Markdown string.
+     */
+    tryParseMarkdownToBlocks(markdown: string): Promise<Block<BSchema, ISchema, SSchema>[]>;
+    /**
+     * If you're using React Context in your blocks, you can use this method to wrap editor calls for importing / exporting / block manipulation
+     * with the React Context Provider.
+     *
+     * Example:
+     *
+     * ```tsx
+        const html = await editor.withReactContext(
+        ({ children }) => (
+          <YourContext.Provider value={true}>{children}</YourContext.Provider>
+        ),
+        async () => editor.blocksToFullHTML(blocks)
+      );
+     */
+    withReactContext<T>(comp: React.FC<any>, fn: () => Promise<T>): Promise<T>;
+}

package/types/src/context/ServerBlockNoteEditor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/src/context/react/ReactServer.test.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TestContext: import("react").Context<true | undefined>;