@blocknote/core 0.9.0 → 0.9.3

package/src/extensions/UniqueID/UniqueID.ts

@@ -52,14 +52,15 @@ const UniqueID = Extension.create({
       types: [],
       generateID: () => {
         // Use mock ID if tests are running.
-        if ((window as any).__TEST_OPTIONS) {
-          if ((window as any).__TEST_OPTIONS.mockID === undefined) {
-            (window as any).__TEST_OPTIONS.mockID = 0;
+        if (typeof window !== "undefined" && (window as any).__TEST_OPTIONS) {
+          const testOptions = (window as any).__TEST_OPTIONS;
+          if (testOptions.mockID === undefined) {
+            testOptions.mockID = 0;
           } else {
-            (window as any).__TEST_OPTIONS.mockID++;
+            testOptions.mockID++;
           }
 
-          return (window as any).__TEST_OPTIONS.mockID.toString() as string;
+          return testOptions.mockID.toString() as string;
         }
 
         return v4();
@@ -129,7 +130,7 @@ const UniqueID = Extension.create({
           const filterTransactions =
             this.options.filterTransaction &&
             transactions.some((tr) => {
-              var _a, _b;
+              let _a, _b;
               return !((_b = (_a = this.options).filterTransaction) === null ||
               _b === void 0
                 ? void 0
@@ -161,7 +162,7 @@ const UniqueID = Extension.create({
               .filter((id) => id !== null);
             const duplicatedNewIds = findDuplicates(newIds);
             newNodes.forEach(({ node, pos }) => {
-              var _a;
+              let _a;
               // instead of checking `node.attrs[attributeName]` directly
               // we look at the current state of the node within `tr.doc`.
               // this helps to prevent adding new ids to the same node
@@ -196,7 +197,7 @@ const UniqueID = Extension.create({
         // we register a global drag handler to track the current drag source element
         view(view) {
           const handleDragstart = (event: any) => {
-            var _a;
+            let _a;
             dragSourceElement = (
               (_a = view.dom.parentElement) === null || _a === void 0
                 ? void 0
@@ -219,7 +220,7 @@ const UniqueID = Extension.create({
             // only create new ids for dropped content while holding `alt`
             // or content is dragged from another editor
             drop: (view, event: any) => {
-              var _a;
+              let _a;
               if (
                 dragSourceElement !== view.dom.parentElement ||
                 ((_a = event.dataTransfer) === null || _a === void 0

package/src/shared/EventEmitter.ts

@@ -11,6 +11,7 @@ type CallbackFunction<
 > = (...props: CallbackType<T, EventName>) => any;
 
 export class EventEmitter<T extends Record<string, any>> {
+  // eslint-disable-next-line @typescript-eslint/ban-types
   private callbacks: { [key: string]: Function[] } = {};
 
   public on<EventName extends StringKeyOf<T>>(

package/src/shared/plugins/suggestion/SuggestionPlugin.ts

@@ -28,7 +28,9 @@ class SuggestionsMenuView<
     private readonly pluginKey: PluginKey,
     updateSuggestionsMenu: (
       suggestionsMenuState: SuggestionsMenuState<T>
-    ) => void = () => {}
+    ) => void = () => {
+      // noop
+    }
   ) {
     this.pluginState = getDefaultPluginState<T>();
 
@@ -158,7 +160,9 @@ export const setupSuggestionsMenu = <
   onSelectItem: (props: {
     item: T;
     editor: BlockNoteEditor<BSchema>;
-  }) => void = () => {}
+  }) => void = () => {
+    // noop
+  }
 ) => {
   // Assertions
   if (defaultTriggerCharacter.length !== 1) {

package/types/src/extensions/Blocks/NonEditableBlockPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "prosemirror-state";
+export declare const NonEditableBlockPlugin: () => Plugin<any>;

package/types/src/extensions/Blocks/api/defaultProps.d.ts

@@ -0,0 +1,14 @@
+import { Props } from "./blockTypes";
+export declare const defaultProps: {
+    backgroundColor: {
+        default: "transparent";
+    };
+    textColor: {
+        default: "black";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+export type DefaultProps = Props<typeof defaultProps>;

package/types/src/extensions/Blocks/helpers/getBlockInfoFromPos.d.ts

@@ -1,14 +1,22 @@
 import { Node, NodeType } from "prosemirror-model";
-export type BlockInfo = {
+export type BlockInfoWithoutPositions = {
     id: string;
     node: Node;
     contentNode: Node;
     contentType: NodeType;
     numChildBlocks: number;
+};
+export type BlockInfo = BlockInfoWithoutPositions & {
     startPos: number;
     endPos: number;
     depth: number;
 };
+/**
+ * Helper function for `getBlockInfoFromPos`, returns information regarding
+ * provided blockContainer node.
+ * @param blockContainer The blockContainer node to retrieve info for.
+ */
+export declare function getBlockInfo(blockContainer: Node): BlockInfoWithoutPositions;
 /**
  * Retrieves information regarding the nearest blockContainer node in a
  * ProseMirror doc, relative to a position.

package/types/src/extensions/Blocks/nodes/BlockContent/ImageBlockContent/Image.d.ts

@@ -0,0 +1,6 @@
+import "@uppy/core/dist/style.css";
+import "@uppy/dashboard/dist/style.css";
+import "@uppy/drag-drop/dist/style.css";
+import "@uppy/file-input/dist/style.css";
+import "@uppy/progress-bar/dist/style.css";
+export declare const Image: BlockSpec<BType, PSchema, ContainsInlineContent>;

package/types/src/extensions/Blocks/nodes/BlockContent/ImageBlockContent/ImageBlockContent.d.ts

@@ -0,0 +1,37 @@
+import { BlockSpec } from "../../../api/blockTypes";
+export declare const imagePropSchema: {
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    backgroundColor: {
+        default: "transparent";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    width: {
+        default: 512;
+    };
+};
+export declare const Image: BlockSpec<"image", {
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    backgroundColor: {
+        default: "transparent";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    width: {
+        default: 512;
+    };
+}, false>;

package/types/src/extensions/ImageToolbar/ImageToolbarPlugin.d.ts

@@ -0,0 +1,36 @@
+import { EditorState, Plugin, PluginKey } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { BaseUiElementCallbacks, BaseUiElementState, BlockNoteEditor, BlockSchema, BlockSpec, SpecificBlock } from "../..";
+import { EventEmitter } from "../../shared/EventEmitter";
+export type ImageToolbarCallbacks = BaseUiElementCallbacks;
+export type ImageToolbarState = BaseUiElementState & {
+    block: SpecificBlock<BlockSchema & {
+        image: BlockSpec<"image", {
+            src: {
+                default: string;
+            };
+        }, false>;
+    }, "image">;
+};
+export declare class ImageToolbarView {
+    private readonly pluginKey;
+    private readonly pmView;
+    private imageToolbarState?;
+    updateImageToolbar: () => void;
+    prevWasEditable: boolean | null;
+    shouldShow: (state: EditorState) => boolean;
+    constructor(pluginKey: PluginKey, pmView: EditorView, updateImageToolbar: (imageToolbarState: ImageToolbarState) => void);
+    mouseDownHandler: () => void;
+    dragstartHandler: () => void;
+    blurHandler: (event: FocusEvent) => void;
+    scrollHandler: () => void;
+    update(view: EditorView, prevState: EditorState): void;
+    destroy(): void;
+}
+export declare const imageToolbarPluginKey: PluginKey<any>;
+export declare class ImageToolbarProsemirrorPlugin<BSchema extends BlockSchema> extends EventEmitter<any> {
+    private view;
+    readonly plugin: Plugin;
+    constructor(_editor: BlockNoteEditor<BSchema>);
+    onUpdate(callback: (state: ImageToolbarState) => void): () => void;
+}

package/types/src/extensions/SideMenu/MultipleNodeSelection.d.ts

@@ -1,5 +1,5 @@
-import { Selection } from "prosemirror-state";
 import { Node, ResolvedPos, Slice } from "prosemirror-model";
+import { Selection } from "prosemirror-state";
 import { Mappable } from "prosemirror-transform";
 /**
  * This class represents an editor selection which spans multiple nodes/blocks. It's currently only used to allow users

package/types/src/EventEmitter.d.ts

@@ -1,11 +0,0 @@
-type StringKeyOf<T> = Extract<keyof T, string>;
-type CallbackType<T extends Record<string, any>, EventName extends StringKeyOf<T>> = T[EventName] extends any[] ? T[EventName] : [T[EventName]];
-type CallbackFunction<T extends Record<string, any>, EventName extends StringKeyOf<T>> = (...props: CallbackType<T, EventName>) => any;
-export declare class EventEmitter<T extends Record<string, any>> {
-    private callbacks;
-    on<EventName extends StringKeyOf<T>>(event: EventName, fn: CallbackFunction<T, EventName>): this;
-    protected emit<EventName extends StringKeyOf<T>>(event: EventName, ...args: CallbackType<T, EventName>): this;
-    off<EventName extends StringKeyOf<T>>(event: EventName, fn?: CallbackFunction<T, EventName>): this;
-    protected removeAllListeners(): void;
-}
-export {};

package/types/src/extensions/DraggableBlocks/DraggableBlocksExtension.d.ts

@@ -1,16 +0,0 @@
-import { Editor, Extension } from "@tiptap/core";
-import { BlockSideMenuFactory } from "./BlockSideMenuFactoryTypes";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BlockSchema } from "../Blocks/api/blockTypes";
-export type DraggableBlocksOptions<BSchema extends BlockSchema> = {
-    tiptapEditor: Editor;
-    editor: BlockNoteEditor<BSchema>;
-    blockSideMenuFactory: BlockSideMenuFactory<BSchema>;
-};
-/**
- * This extension adds a menu to the side of blocks which features various BlockNote functions such as adding and
- * removing blocks. More importantly, it adds a drag handle which allows the user to drag and drop blocks.
- *
- * code based on https://github.com/ueberdosis/tiptap/issues/323#issuecomment-506637799
- */
-export declare const createDraggableBlocksExtension: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema>>>() => Extension<DraggableBlocksOptions<BSchema>, any>;

package/types/src/extensions/DraggableBlocks/DraggableBlocksPlugin.d.ts

@@ -1,55 +0,0 @@
-import { PluginView } from "@tiptap/pm/state";
-import { Plugin, PluginKey } from "prosemirror-state";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BaseUiElementCallbacks, BaseUiElementState } from "../../shared/BaseUiElementTypes";
-import { Block, BlockSchema } from "../Blocks/api/blockTypes";
-import { Editor } from "@tiptap/core";
-export type SideMenuCallbacks = BaseUiElementCallbacks & {
-    addBlock: () => void;
-    freezeMenu: () => void;
-    unfreezeMenu: () => void;
-    blockDragStart: (event: DragEvent) => void;
-    blockDragEnd: () => void;
-};
-export type SideMenuState<BSchema extends BlockSchema> = BaseUiElementState & {
-    block: Block<BSchema>;
-};
-export declare class SideMenuView<BSchema extends BlockSchema> implements PluginView {
-    editor: BlockNoteEditor<BSchema>;
-    ttEditor: Editor;
-    private sideMenuState?;
-    updateSideMenu: () => void;
-    horizontalPosAnchoredAtRoot: boolean;
-    horizontalPosAnchor: number;
-    hoveredBlock: HTMLElement | undefined;
-    isDragging: boolean;
-    menuFrozen: boolean;
-    constructor(editor: BlockNoteEditor<BSchema>, tiptapEditor: Editor, updateSideMenu: (sideMenuState: SideMenuState<BSchema>) => void);
-    /**
-     * Sets isDragging when dragging text.
-     */
-    onDragStart: () => void;
-    /**
-     * If the event is outside the editor contents,
-     * we dispatch a fake event, so that we can still drop the content
-     * when dragging / dropping to the side of the editor
-     */
-    onDrop: (event: DragEvent) => void;
-    /**
-     * If the event is outside the editor contents,
-     * we dispatch a fake event, so that we can still drop the content
-     * when dragging / dropping to the side of the editor
-     */
-    onDragOver: (event: DragEvent) => void;
-    onKeyDown: (_event: KeyboardEvent) => void;
-    onMouseDown: (_event: MouseEvent) => void;
-    onMouseMove: (event: MouseEvent) => void;
-    onScroll: () => void;
-    destroy(): void;
-    addBlock(): void;
-}
-export declare const sideMenuPluginKey: PluginKey<any>;
-export declare function setupSideMenu<BSchema extends BlockSchema>(editor: BlockNoteEditor<BSchema>, tiptapEditor: Editor, updateSideMenu: (sideMenuState: SideMenuState<BSchema>) => void): {
-    plugin: Plugin;
-    callbacks: Omit<SideMenuCallbacks, "destroy">;
-};

package/types/src/extensions/DraggableBlocks/MultipleNodeSelection.d.ts

@@ -1,24 +0,0 @@
-import { Selection } from "prosemirror-state";
-import { Node, ResolvedPos, Slice } from "prosemirror-model";
-import { Mappable } from "prosemirror-transform";
-/**
- * This class represents an editor selection which spans multiple nodes/blocks. It's currently only used to allow users
- * to drag multiple blocks at the same time. Expects the selection anchor and head to be between nodes, i.e. just before
- * the first target node and just after the last, and that anchor and head are at the same nesting level.
- *
- * Partially based on ProseMirror's NodeSelection implementation:
- * (https://github.com/ProseMirror/prosemirror-state/blob/master/src/selection.ts)
- * MultipleNodeSelection differs from NodeSelection in the following ways:
- * 1. Stores which nodes are included in the selection instead of just a single node.
- * 2. Already expects the selection to start just before the first target node and ends just after the last, while a
- * NodeSelection automatically sets both anchor and head to just before the single target node.
- */
-export declare class MultipleNodeSelection extends Selection {
-    nodes: Array<Node>;
-    constructor($anchor: ResolvedPos, $head: ResolvedPos);
-    static create(doc: Node, from: number, to?: number): MultipleNodeSelection;
-    content(): Slice;
-    eq(selection: Selection): boolean;
-    map(doc: Node, mapping: Mappable): Selection;
-    toJSON(): any;
-}

package/types/src/extensions/FormattingToolbar/FormattingToolbarExtension.d.ts

@@ -1,11 +0,0 @@
-import { Extension } from "@tiptap/core";
-import { BlockNoteEditor, BlockSchema } from "../..";
-import { FormattingToolbarFactory } from "./FormattingToolbarFactoryTypes";
-export type FormattingToolbarOptions<BSchema extends BlockSchema> = {
-    formattingToolbarFactory: FormattingToolbarFactory<BSchema>;
-    editor: BlockNoteEditor<BSchema>;
-};
-/**
- * The menu that is displayed when selecting a piece of text.
- */
-export declare const createFormattingToolbarExtension: <BSchema extends Record<string, import("../..").BlockSpec<string, import("../..").PropSchema>>>() => Extension<FormattingToolbarOptions<BSchema>, any>;

package/types/src/extensions/FormattingToolbar/FormattingToolbarFactoryTypes.d.ts

@@ -1,10 +0,0 @@
-import { EditorElement, ElementFactory } from "../../shared/EditorElement";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BlockSchema } from "../Blocks/api/blockTypes";
-export type FormattingToolbarStaticParams<BSchema extends BlockSchema> = {
-    editor: BlockNoteEditor<BSchema>;
-    getReferenceRect: () => DOMRect;
-};
-export type FormattingToolbarDynamicParams = {};
-export type FormattingToolbar = EditorElement<FormattingToolbarDynamicParams>;
-export type FormattingToolbarFactory<BSchema extends BlockSchema> = ElementFactory<FormattingToolbarStaticParams<BSchema>, FormattingToolbarDynamicParams>;

package/types/src/extensions/HyperlinkToolbar/HyperlinkMark.d.ts

@@ -1,8 +0,0 @@
-import { HyperlinkToolbarPluginProps } from "./HyperlinkToolbarPlugin";
-/**
- * This custom link includes a special menu for editing/deleting/opening the link.
- * The menu will be triggered by hovering over the link with the mouse,
- * or by moving the cursor inside the link text
- */
-declare const Hyperlink: import("@tiptap/core").Mark<HyperlinkToolbarPluginProps, any>;
-export default Hyperlink;

package/types/src/extensions/SlashMenu/SlashMenuExtension.d.ts

@@ -1,13 +0,0 @@
-import { Extension } from "@tiptap/core";
-import { PluginKey } from "prosemirror-state";
-import { SuggestionsMenuFactory } from "../../shared/plugins/suggestion/SuggestionsMenuFactoryTypes";
-import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
-import { BlockNoteEditor } from "../../BlockNoteEditor";
-import { BlockSchema } from "../Blocks/api/blockTypes";
-export type SlashMenuOptions<BSchema extends BlockSchema> = {
-    editor: BlockNoteEditor<BSchema> | undefined;
-    commands: BaseSlashMenuItem<BSchema>[] | undefined;
-    slashMenuFactory: SuggestionsMenuFactory<any> | undefined;
-};
-export declare const SlashMenuPluginKey: PluginKey<any>;
-export declare const createSlashMenuExtension: <BSchema extends Record<string, import("../Blocks/api/blockTypes").BlockSpec<string, import("../Blocks/api/blockTypes").PropSchema>>>() => Extension<SlashMenuOptions<BSchema>, any>;

package/types/src/extensions/SlashMenu/index.d.ts

@@ -1,3 +0,0 @@
-import { getDefaultSlashMenuItems } from "./defaultSlashMenuItems";
-import { BaseSlashMenuItem } from "./BaseSlashMenuItem";
-export { getDefaultSlashMenuItems, BaseSlashMenuItem };

package/types/src/shared/plugins/suggestion/SuggestionsMenuFactoryTypes.d.ts

@@ -1,12 +0,0 @@
-import { EditorElement, ElementFactory } from "../../EditorElement";
-import { SuggestionItem } from "./SuggestionItem";
-export type SuggestionsMenuStaticParams<T extends SuggestionItem> = {
-    itemCallback: (item: T) => void;
-    getReferenceRect: () => DOMRect;
-};
-export type SuggestionsMenuDynamicParams<T extends SuggestionItem> = {
-    items: T[];
-    keyboardHoveredItemIndex: number;
-};
-export type SuggestionsMenu<T extends SuggestionItem> = EditorElement<SuggestionsMenuDynamicParams<T>>;
-export type SuggestionsMenuFactory<T extends SuggestionItem> = ElementFactory<SuggestionsMenuStaticParams<T>, SuggestionsMenuDynamicParams<T>>;