@blocknote/core 0.13.2 → 0.13.4

package/types/src/blocks/FileBlockContent/FileBlockContent.d.ts

@@ -0,0 +1,93 @@
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockFromConfig } from "../../schema";
+export declare const filePropSchema: {
+    backgroundColor: {
+        default: "default";
+    };
+    name: {
+        default: "";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+};
+export declare const fileBlockConfig: {
+    type: "file";
+    propSchema: {
+        backgroundColor: {
+            default: "default";
+        };
+        name: {
+            default: "";
+        };
+        url: {
+            default: "";
+        };
+        caption: {
+            default: "";
+        };
+    };
+    content: "none";
+    isFileBlock: true;
+};
+export declare const fileRender: (block: BlockFromConfig<typeof fileBlockConfig, any, any>, editor: BlockNoteEditor<any, any, any>) => {
+    dom: HTMLDivElement;
+    destroy: () => void;
+} | {
+    dom: HTMLDivElement;
+    destroy?: undefined;
+};
+export declare const fileParse: (element: HTMLElement) => {
+    url: string | undefined;
+} | {
+    caption: string | undefined;
+    url: string | undefined;
+} | undefined;
+export declare const fileToExternalHTML: (block: BlockFromConfig<typeof fileBlockConfig, any, any>) => {
+    dom: HTMLParagraphElement;
+} | {
+    dom: HTMLAnchorElement;
+};
+export declare const FileBlock: {
+    config: {
+        type: "file";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            name: {
+                default: "";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+        };
+        content: "none";
+        isFileBlock: true;
+    };
+    implementation: import("../../schema").TiptapBlockImplementation<{
+        type: "file";
+        propSchema: {
+            backgroundColor: {
+                default: "default";
+            };
+            name: {
+                default: "";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+        };
+        content: "none";
+        isFileBlock: true;
+    }, any, import("../../schema").InlineContentSchema, import("../../schema").StyleSchema>;
+};

package/types/src/blocks/FileBlockContent/fileBlockHelpers.d.ts

@@ -0,0 +1,30 @@
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockFromConfig, FileBlockConfig } from "../../schema";
+export declare const createDefaultFilePreview: (block: BlockFromConfig<FileBlockConfig, any, any>) => {
+    dom: HTMLElement;
+    destroy?: () => void;
+};
+export declare const createFileAndCaptionWrapper: (block: BlockFromConfig<FileBlockConfig, any, any>, file: HTMLElement) => {
+    dom: HTMLDivElement;
+};
+export declare const createAddFileButton: (block: BlockFromConfig<FileBlockConfig, any, any>, editor: BlockNoteEditor<any, any, any>, buttonText?: string, buttonIcon?: HTMLElement) => {
+    dom: HTMLDivElement;
+    destroy: () => void;
+};
+export declare const parseEmbedElement: (embedElement: HTMLEmbedElement) => {
+    url: string | undefined;
+};
+export declare const parseFigureElement: (figureElement: HTMLElement, targetTag: string) => {
+    targetElement: HTMLElement;
+    caption: string | undefined;
+} | undefined;
+export declare const createLinkWithCaption: (element: HTMLElement, caption: string) => {
+    dom: HTMLDivElement;
+};
+export declare const createFigureWithCaption: (element: HTMLElement, caption: string) => {
+    dom: HTMLElement;
+};
+export declare const createResizeHandlesWrapper: (block: BlockFromConfig<FileBlockConfig, any, any>, editor: BlockNoteEditor<any, any, any>, element: HTMLElement, getWidth: () => number, setWidth: (width: number) => void) => {
+    dom: HTMLElement;
+    destroy: () => void;
+};

package/types/src/blocks/ImageBlockContent/ImageBlockContent.d.ts

@@ -1,5 +1,5 @@
 import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
-import { BlockFromConfig, BlockSchemaWithBlock, InlineContentSchema, StyleSchema } from "../../schema";
+import { BlockFromConfig, Props } from "../../schema";
 export declare const imagePropSchema: {
     textAlignment: {
         default: "left";
@@ -8,17 +8,23 @@ export declare const imagePropSchema: {
     backgroundColor: {
         default: "default";
     };
+    name: {
+        default: "";
+    };
     url: {
         default: "";
     };
     caption: {
         default: "";
     };
-    width: {
-        default: 512;
+    showPreview: {
+        default: true;
+    };
+    previewWidth: {
+        default: number;
     };
 };
-declare const blockConfig: {
+export declare const imageBlockConfig: {
     type: "image";
     propSchema: {
         textAlignment: {
@@ -28,23 +34,38 @@ declare const blockConfig: {
         backgroundColor: {
             default: "default";
         };
+        name: {
+            default: "";
+        };
         url: {
             default: "";
         };
         caption: {
             default: "";
         };
-        width: {
-            default: 512;
+        showPreview: {
+            default: true;
+        };
+        previewWidth: {
+            default: number;
         };
     };
     content: "none";
+    isFileBlock: true;
+    fileBlockAcceptMimeTypes: string[];
 };
-export declare const renderImage: (block: BlockFromConfig<typeof blockConfig, InlineContentSchema, StyleSchema>, editor: BlockNoteEditor<BlockSchemaWithBlock<"image", typeof blockConfig>>) => {
+export declare const imageRender: (block: BlockFromConfig<typeof imageBlockConfig, any, any>, editor: BlockNoteEditor<any, any, any>) => {
     dom: HTMLDivElement;
     destroy: () => void;
+} | {
+    dom: HTMLDivElement;
+    destroy?: undefined;
 };
-export declare const Image: {
+export declare const imageParse: (element: HTMLElement) => Partial<Props<typeof imageBlockConfig.propSchema>> | undefined;
+export declare const imageToExternalHTML: (block: BlockFromConfig<typeof imageBlockConfig, any, any>) => {
+    dom: HTMLElement;
+};
+export declare const ImageBlock: {
     config: {
         type: "image";
         propSchema: {
@@ -55,17 +76,25 @@ export declare const Image: {
             backgroundColor: {
                 default: "default";
             };
+            name: {
+                default: "";
+            };
             url: {
                 default: "";
             };
             caption: {
                 default: "";
             };
-            width: {
-                default: 512;
+            showPreview: {
+                default: true;
+            };
+            previewWidth: {
+                default: number;
             };
         };
         content: "none";
+        isFileBlock: true;
+        fileBlockAcceptMimeTypes: string[];
     };
     implementation: import("../../schema").TiptapBlockImplementation<{
         type: "image";
@@ -77,17 +106,24 @@ export declare const Image: {
             backgroundColor: {
                 default: "default";
             };
+            name: {
+                default: "";
+            };
             url: {
                 default: "";
             };
             caption: {
                 default: "";
             };
-            width: {
-                default: 512;
+            showPreview: {
+                default: true;
+            };
+            previewWidth: {
+                default: number;
             };
         };
         content: "none";
-    }, any, InlineContentSchema, StyleSchema>;
+        isFileBlock: true;
+        fileBlockAcceptMimeTypes: string[];
+    }, any, import("../../schema").InlineContentSchema, import("../../schema").StyleSchema>;
 };
-export {};

package/types/src/blocks/ImageBlockContent/imageBlockHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare const parseImageElement: (imageElement: HTMLImageElement) => {
+    url: string | undefined;
+    previewWidth: number | undefined;
+};

package/types/src/blocks/ListItemBlockContent/CheckListItemBlockContent/CheckListItemBlockContent.d.ts

@@ -0,0 +1,55 @@
+export declare const checkListItemPropSchema: {
+    checked: {
+        default: false;
+    };
+    backgroundColor: {
+        default: "default";
+    };
+    textColor: {
+        default: "default";
+    };
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+};
+export declare const CheckListItem: {
+    config: {
+        type: "checkListItem";
+        content: "inline";
+        propSchema: {
+            checked: {
+                default: false;
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    };
+    implementation: import("../../../schema").TiptapBlockImplementation<{
+        type: "checkListItem";
+        content: "inline";
+        propSchema: {
+            checked: {
+                default: false;
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            textColor: {
+                default: "default";
+            };
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+        };
+    }, any, import("../../../schema").InlineContentSchema, import("../../../schema").StyleSchema>;
+};

package/types/src/blocks/VideoBlockContent/VideoBlockContent.d.ts

@@ -0,0 +1,129 @@
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { BlockFromConfig, Props } from "../../schema";
+export declare const videoPropSchema: {
+    textAlignment: {
+        default: "left";
+        values: readonly ["left", "center", "right", "justify"];
+    };
+    backgroundColor: {
+        default: "default";
+    };
+    name: {
+        default: "";
+    };
+    url: {
+        default: "";
+    };
+    caption: {
+        default: "";
+    };
+    showPreview: {
+        default: true;
+    };
+    previewWidth: {
+        default: number;
+    };
+};
+export declare const videoBlockConfig: {
+    type: "video";
+    propSchema: {
+        textAlignment: {
+            default: "left";
+            values: readonly ["left", "center", "right", "justify"];
+        };
+        backgroundColor: {
+            default: "default";
+        };
+        name: {
+            default: "";
+        };
+        url: {
+            default: "";
+        };
+        caption: {
+            default: "";
+        };
+        showPreview: {
+            default: true;
+        };
+        previewWidth: {
+            default: number;
+        };
+    };
+    content: "none";
+    isFileBlock: true;
+    fileBlockAcceptMimeTypes: string[];
+};
+export declare const videoRender: (block: BlockFromConfig<typeof videoBlockConfig, any, any>, editor: BlockNoteEditor<any, any, any>) => {
+    dom: HTMLDivElement;
+    destroy: () => void;
+} | {
+    dom: HTMLDivElement;
+    destroy?: undefined;
+};
+export declare const videoParse: (element: HTMLElement) => Partial<Props<typeof videoBlockConfig.propSchema>> | undefined;
+export declare const videoToExternalHTML: (block: BlockFromConfig<typeof videoBlockConfig, any, any>) => {
+    dom: HTMLElement;
+};
+export declare const VideoBlock: {
+    config: {
+        type: "video";
+        propSchema: {
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            name: {
+                default: "";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+            showPreview: {
+                default: true;
+            };
+            previewWidth: {
+                default: number;
+            };
+        };
+        content: "none";
+        isFileBlock: true;
+        fileBlockAcceptMimeTypes: string[];
+    };
+    implementation: import("../../schema").TiptapBlockImplementation<{
+        type: "video";
+        propSchema: {
+            textAlignment: {
+                default: "left";
+                values: readonly ["left", "center", "right", "justify"];
+            };
+            backgroundColor: {
+                default: "default";
+            };
+            name: {
+                default: "";
+            };
+            url: {
+                default: "";
+            };
+            caption: {
+                default: "";
+            };
+            showPreview: {
+                default: true;
+            };
+            previewWidth: {
+                default: number;
+            };
+        };
+        content: "none";
+        isFileBlock: true;
+        fileBlockAcceptMimeTypes: string[];
+    }, any, import("../../schema").InlineContentSchema, import("../../schema").StyleSchema>;
+};

package/types/src/blocks/VideoBlockContent/videoBlockHelpers.d.ts

@@ -0,0 +1,4 @@
+export declare const parseVideoElement: (videoElement: HTMLVideoElement) => {
+    url: string | undefined;
+    previewWidth: number | undefined;
+};

package/types/src/blocks/defaultBlockTypeGuards.d.ts

@@ -1,11 +1,16 @@
 import type { BlockNoteEditor } from "../editor/BlockNoteEditor";
-import { BlockFromConfig, InlineContentSchema, StyleSchema } from "../schema";
+import { BlockFromConfig, BlockSchema, FileBlockConfig, InlineContentSchema, StyleSchema } from "../schema";
 import { Block, DefaultBlockSchema } from "./defaultBlocks";
 import { defaultProps } from "./defaultProps";
 export declare function checkDefaultBlockTypeInSchema<BlockType extends keyof DefaultBlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blockType: BlockType, editor: BlockNoteEditor<any, I, S>): editor is BlockNoteEditor<{
     Type: DefaultBlockSchema[BlockType];
 }, I, S>;
 export declare function checkBlockIsDefaultType<BlockType extends keyof DefaultBlockSchema, I extends InlineContentSchema, S extends StyleSchema>(blockType: BlockType, block: Block<any, I, S>, editor: BlockNoteEditor<any, I, S>): block is BlockFromConfig<DefaultBlockSchema[BlockType], I, S>;
+export declare function checkBlockIsFileBlock<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(block: Block<any, I, S>, editor: BlockNoteEditor<B, I, S>): block is BlockFromConfig<FileBlockConfig, I, S>;
+export declare function checkBlockIsFileBlockWithPreview<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(block: Block<any, I, S>, editor: BlockNoteEditor<B, I, S>): block is BlockFromConfig<FileBlockConfig & {
+    propSchema: Required<FileBlockConfig["propSchema"]>;
+}, I, S>;
+export declare function checkBlockIsFileBlockWithPlaceholder<B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema>(block: Block<B, I, S>, editor: BlockNoteEditor<B, I, S>): boolean | undefined;
 export declare function checkBlockTypeHasDefaultProp<Prop extends keyof typeof defaultProps, I extends InlineContentSchema, S extends StyleSchema>(prop: Prop, blockType: string, editor: BlockNoteEditor<any, I, S>): editor is BlockNoteEditor<{
     [BT in string]: {
         type: BT;