@blocknote/core 0.9.6 → 0.10.0

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

@@ -0,0 +1,107 @@
+/** Define the main block types **/
+import { Extension, Node } from "@tiptap/core";
+import type { BlockNoteEditor } from "../../editor/BlockNoteEditor";
+import { InlineContent, InlineContentSchema, PartialInlineContent } from "../inlineContent/types";
+import { PropSchema, Props } from "../propTypes";
+import { StyleSchema } from "../styles/types";
+export type BlockNoteDOMElement = "editor" | "blockContainer" | "blockGroup" | "blockContent" | "inlineContent";
+export type BlockNoteDOMAttributes = Partial<{
+    [DOMElement in BlockNoteDOMElement]: Record<string, string>;
+}>;
+export type BlockConfig = {
+    type: string;
+    readonly propSchema: PropSchema;
+    content: "inline" | "none" | "table";
+};
+export type TiptapBlockImplementation<T extends BlockConfig, B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    requiredExtensions?: Array<Extension | Node>;
+    node: Node;
+    toInternalHTML: (block: BlockFromConfigNoChildren<T, I, S> & {
+        children: Block<B, I, S>[];
+    }, editor: BlockNoteEditor<B, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+    toExternalHTML: (block: BlockFromConfigNoChildren<T, I, S> & {
+        children: Block<B, I, S>[];
+    }, editor: BlockNoteEditor<B, I, S>) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export type BlockSpec<T extends BlockConfig, B extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    config: T;
+    implementation: TiptapBlockImplementation<T, B, I, S>;
+};
+type NamesMatch<Blocks extends Record<string, BlockConfig>> = Blocks extends {
+    [Type in keyof Blocks]: Type extends string ? Blocks[Type] extends {
+        type: Type;
+    } ? Blocks[Type] : never : never;
+} ? Blocks : never;
+export type BlockSchema = NamesMatch<Record<string, BlockConfig>>;
+export type BlockSpecs = Record<string, BlockSpec<any, any, InlineContentSchema, StyleSchema>>;
+export type BlockImplementations = Record<string, TiptapBlockImplementation<any, any, any, any>>;
+export type BlockSchemaFromSpecs<T extends BlockSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type BlockSchemaWithBlock<BType extends string, C extends BlockConfig> = {
+    [k in BType]: C;
+};
+export type TableContent<I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = {
+    type: "tableContent";
+    rows: {
+        cells: InlineContent<I, S>[][];
+    }[];
+};
+export type BlockFromConfigNoChildren<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = {
+    id: string;
+    type: B["type"];
+    props: Props<B["propSchema"]>;
+    content: B["content"] extends "inline" ? InlineContent<I, S>[] : B["content"] extends "table" ? TableContent<I, S> : B["content"] extends "none" ? undefined : never;
+};
+export type BlockFromConfig<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = BlockFromConfigNoChildren<B, I, S> & {
+    children: Block<BlockSchema, I, S>[];
+};
+type BlocksWithoutChildren<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    [BType in keyof BSchema]: BlockFromConfigNoChildren<BSchema[BType], I, S>;
+};
+export type Block<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = BlocksWithoutChildren<BSchema, I, S>[keyof BSchema] & {
+    children: Block<BSchema, I, S>[];
+};
+export type SpecificBlock<BSchema extends BlockSchema, BType extends keyof BSchema, I extends InlineContentSchema, S extends StyleSchema> = BlocksWithoutChildren<BSchema, I, S>[BType] & {
+    children: Block<BSchema, I, S>[];
+};
+/** CODE FOR PARTIAL BLOCKS, analogous to above
+ *
+ * Partial blocks are convenience-wrappers to make it easier to
+ *create/update blocks in the editor.
+ *
+ */
+export type PartialTableContent<I extends InlineContentSchema, S extends StyleSchema = StyleSchema> = {
+    type: "tableContent";
+    rows: {
+        cells: PartialInlineContent<I, S>[];
+    }[];
+};
+type PartialBlockFromConfigNoChildren<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = {
+    id?: string;
+    type?: B["type"];
+    props?: Partial<Props<B["propSchema"]>>;
+    content?: B["content"] extends "inline" ? PartialInlineContent<I, S> : B["content"] extends "table" ? PartialTableContent<I, S> : undefined;
+};
+type PartialBlocksWithoutChildren<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = {
+    [BType in keyof BSchema]: PartialBlockFromConfigNoChildren<BSchema[BType], I, S>;
+};
+export type PartialBlock<BSchema extends BlockSchema, I extends InlineContentSchema, S extends StyleSchema> = PartialBlocksWithoutChildren<BSchema, I, S>[keyof PartialBlocksWithoutChildren<BSchema, I, S>] & Partial<{
+    children: PartialBlock<BSchema, I, S>[];
+}>;
+export type SpecificPartialBlock<BSchema extends BlockSchema, I extends InlineContentSchema, BType extends keyof BSchema, S extends StyleSchema> = PartialBlocksWithoutChildren<BSchema, I, S>[BType] & {
+    children?: Block<BSchema, I, S>[];
+};
+export type PartialBlockFromConfig<B extends BlockConfig, I extends InlineContentSchema, S extends StyleSchema> = PartialBlockFromConfigNoChildren<B, I, S> & {
+    children?: Block<BlockSchema, I, S>[];
+};
+export type BlockIdentifier = {
+    id: string;
+} | string;
+export {};

package/types/src/schema/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./blocks/createSpec";
+export * from "./blocks/internal";
+export * from "./blocks/types";
+export * from "./inlineContent/createSpec";
+export * from "./inlineContent/internal";
+export * from "./inlineContent/types";
+export * from "./propTypes";
+export * from "./styles/createSpec";
+export * from "./styles/internal";
+export * from "./styles/types";

package/types/src/schema/inlineContent/createSpec.d.ts

@@ -0,0 +1,21 @@
+import { ParseRule } from "@tiptap/pm/model";
+import { StyleSchema } from "../styles/types";
+import { CustomInlineContentConfig, InlineContentConfig, InlineContentFromConfig, InlineContentSpec } from "./types";
+export type CustomInlineContentImplementation<T extends InlineContentConfig, S extends StyleSchema> = {
+    render: (
+    /**
+     * The custom inline content to render
+     */
+    inlineContent: InlineContentFromConfig<T, S>
+    /**
+     * The BlockNote editor instance
+     * This is typed generically. If you want an editor with your custom schema, you need to
+     * cast it manually, e.g.: `const e = editor as BlockNoteEditor<typeof mySchema>;`
+     */
+    ) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export declare function getInlineContentParseRules(config: CustomInlineContentConfig): ParseRule[];
+export declare function createInlineContentSpec<T extends CustomInlineContentConfig, S extends StyleSchema>(inlineContentConfig: T, inlineContentImplementation: CustomInlineContentImplementation<T, S>): InlineContentSpec<T>;

package/types/src/schema/inlineContent/internal.d.ts

@@ -0,0 +1,28 @@
+import { KeyboardShortcutCommand, Node } from "@tiptap/core";
+import { PropSchema, Props } from "../propTypes";
+import { CustomInlineContentConfig, InlineContentConfig, InlineContentImplementation, InlineContentSchemaFromSpecs, InlineContentSpecs } from "./types";
+export declare function addInlineContentAttributes<IType extends string, PSchema extends PropSchema>(element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+}, inlineContentType: IType, inlineContentProps: Props<PSchema>, propSchema: PSchema): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};
+export declare function addInlineContentKeyboardShortcuts<T extends CustomInlineContentConfig>(config: T): {
+    [p: string]: KeyboardShortcutCommand;
+};
+export declare function createInternalInlineContentSpec<T extends InlineContentConfig>(config: T, implementation: InlineContentImplementation<T>): {
+    config: T;
+    implementation: InlineContentImplementation<T>;
+};
+export declare function createInlineContentSpecFromTipTapNode<T extends Node, P extends PropSchema>(node: T, propSchema: P): {
+    config: {
+        type: T["name"];
+        propSchema: P;
+        content: "styled" | "none";
+    };
+    implementation: {
+        node: Node<any, any>;
+    };
+};
+export declare function getInlineContentSchemaFromSpecs<T extends InlineContentSpecs>(specs: T): InlineContentSchemaFromSpecs<T>;

package/types/src/schema/inlineContent/types.d.ts

@@ -0,0 +1,62 @@
+import { Node } from "@tiptap/core";
+import { PropSchema, Props } from "../propTypes";
+import { StyleSchema, Styles } from "../styles/types";
+export type CustomInlineContentConfig = {
+    type: string;
+    content: "styled" | "none";
+    readonly propSchema: PropSchema;
+};
+export type InlineContentConfig = CustomInlineContentConfig | "text" | "link";
+export type InlineContentImplementation<T extends InlineContentConfig> = T extends "link" | "text" ? undefined : {
+    node: Node;
+};
+export type InlineContentSpec<T extends InlineContentConfig> = {
+    config: T;
+    implementation: InlineContentImplementation<T>;
+};
+export type InlineContentSchema = Record<string, InlineContentConfig>;
+export type InlineContentSpecs = {
+    text: {
+        config: "text";
+        implementation: undefined;
+    };
+    link: {
+        config: "link";
+        implementation: undefined;
+    };
+} & Record<string, InlineContentSpec<InlineContentConfig>>;
+export type InlineContentSchemaFromSpecs<T extends InlineContentSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type CustomInlineContentFromConfig<I extends CustomInlineContentConfig, S extends StyleSchema> = {
+    type: I["type"];
+    props: Props<I["propSchema"]>;
+    content: I["content"] extends "styled" ? StyledText<S>[] : I["content"] extends "plain" ? string : I["content"] extends "none" ? undefined : never;
+};
+export type InlineContentFromConfig<I extends InlineContentConfig, S extends StyleSchema> = I extends "text" ? StyledText<S> : I extends "link" ? Link<S> : I extends CustomInlineContentConfig ? CustomInlineContentFromConfig<I, S> : never;
+export type PartialCustomInlineContentFromConfig<I extends CustomInlineContentConfig, S extends StyleSchema> = {
+    type: I["type"];
+    props?: Props<I["propSchema"]>;
+    content: I["content"] extends "styled" ? StyledText<S>[] | string : I["content"] extends "plain" ? string : I["content"] extends "none" ? undefined : never;
+};
+export type PartialInlineContentFromConfig<I extends InlineContentConfig, S extends StyleSchema> = I extends "text" ? string | StyledText<S> : I extends "link" ? PartialLink<S> : I extends CustomInlineContentConfig ? PartialCustomInlineContentFromConfig<I, S> : never;
+export type StyledText<T extends StyleSchema> = {
+    type: "text";
+    text: string;
+    styles: Styles<T>;
+};
+export type Link<T extends StyleSchema> = {
+    type: "link";
+    href: string;
+    content: StyledText<T>[];
+};
+export type PartialLink<T extends StyleSchema> = Omit<Link<T>, "content"> & {
+    content: string | Link<T>["content"];
+};
+export type InlineContent<I extends InlineContentSchema, T extends StyleSchema> = InlineContentFromConfig<I[keyof I], T>;
+type PartialInlineContentElement<I extends InlineContentSchema, T extends StyleSchema> = PartialInlineContentFromConfig<I[keyof I], T>;
+export type PartialInlineContent<I extends InlineContentSchema, T extends StyleSchema> = PartialInlineContentElement<I, T>[] | string;
+export declare function isLinkInlineContent<T extends StyleSchema>(content: InlineContent<any, T>): content is Link<T>;
+export declare function isPartialLinkInlineContent<T extends StyleSchema>(content: PartialInlineContentElement<any, T>): content is PartialLink<T>;
+export declare function isStyledTextInlineContent<T extends StyleSchema>(content: PartialInlineContentElement<any, T>): content is StyledText<T>;
+export {};

package/types/src/schema/propTypes.d.ts

@@ -0,0 +1,8 @@
+export type PropSpec<PType extends boolean | number | string> = {
+    values?: readonly PType[];
+    default: PType;
+};
+export type PropSchema = Record<string, PropSpec<boolean | number | string>>;
+export type Props<PSchema extends PropSchema> = {
+    [PName in keyof PSchema]: PSchema[PName]["default"] extends boolean ? PSchema[PName]["values"] extends readonly boolean[] ? PSchema[PName]["values"][number] : boolean : PSchema[PName]["default"] extends number ? PSchema[PName]["values"] extends readonly number[] ? PSchema[PName]["values"][number] : number : PSchema[PName]["default"] extends string ? PSchema[PName]["values"] extends readonly string[] ? PSchema[PName]["values"][number] : string : never;
+};

package/types/src/schema/styles/createSpec.d.ts

@@ -0,0 +1,13 @@
+import { ParseRule } from "@tiptap/pm/model";
+import { StyleConfig, StyleSpec } from "./types";
+export type CustomStyleImplementation<T extends StyleConfig> = {
+    render: T["propSchema"] extends "boolean" ? () => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    } : (value: string) => {
+        dom: HTMLElement;
+        contentDOM?: HTMLElement;
+    };
+};
+export declare function getStyleParseRules(config: StyleConfig): ParseRule[];
+export declare function createStyleSpec<T extends StyleConfig>(styleConfig: T, styleImplementation: CustomStyleImplementation<T>): StyleSpec<T>;

package/types/src/schema/styles/internal.d.ts

@@ -0,0 +1,22 @@
+import { Attributes, Mark } from "@tiptap/core";
+import { StyleConfig, StyleImplementation, StylePropSchema, StyleSchemaFromSpecs, StyleSpecs } from "./types";
+export declare function stylePropsToAttributes(propSchema: StylePropSchema): Attributes;
+export declare function addStyleAttributes<SType extends string, PSchema extends StylePropSchema>(element: {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+}, styleType: SType, styleValue: PSchema extends "boolean" ? undefined : string, propSchema: PSchema): {
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+};
+export declare function createInternalStyleSpec<T extends StyleConfig>(config: T, implementation: StyleImplementation): {
+    config: T;
+    implementation: StyleImplementation;
+};
+export declare function createStyleSpecFromTipTapMark<T extends Mark, P extends StylePropSchema>(mark: T, propSchema: P): {
+    config: {
+        type: T["name"];
+        propSchema: P;
+    };
+    implementation: StyleImplementation;
+};
+export declare function getStyleSchemaFromSpecs<T extends StyleSpecs>(specs: T): StyleSchemaFromSpecs<T>;

package/types/src/schema/styles/types.d.ts

@@ -0,0 +1,21 @@
+import { Mark } from "@tiptap/core";
+export type StylePropSchema = "boolean" | "string";
+export type StyleConfig = {
+    type: string;
+    readonly propSchema: StylePropSchema;
+};
+export type StyleImplementation = {
+    mark: Mark;
+};
+export type StyleSpec<T extends StyleConfig> = {
+    config: T;
+    implementation: StyleImplementation;
+};
+export type StyleSchema = Record<string, StyleConfig>;
+export type StyleSpecs = Record<string, StyleSpec<StyleConfig>>;
+export type StyleSchemaFromSpecs<T extends StyleSpecs> = {
+    [K in keyof T]: T[K]["config"];
+};
+export type Styles<T extends StyleSchema> = {
+    [K in keyof T]?: T[K]["propSchema"] extends "boolean" ? boolean : T[K]["propSchema"] extends "string" ? string : never;
+};

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

@@ -1,5 +1,7 @@
 import { Plugin, PluginKey } from "prosemirror-state";
 import { BlockNoteEditor } from "../../../BlockNoteEditor";
+import { InlineContentSchema } from "../../../extensions/Blocks/api/inlineContent/types";
+import { StyleSchema } from "../../../extensions/Blocks/api/styles/types";
 import { BaseUiElementState } from "../../BaseUiElementTypes";
 import { SuggestionItem } from "./SuggestionItem";
 export type SuggestionsMenuState<T extends SuggestionItem> = BaseUiElementState & {
@@ -25,9 +27,9 @@ type SuggestionPluginState<T extends SuggestionItem> = {
  * - This version hides some unnecessary complexity from the user of the plugin.
  * - This version handles key events differently
  */
-export declare const setupSuggestionsMenu: <T extends SuggestionItem, BSchema extends Record<string, import("../../../extensions/Blocks/api/blockTypes").BlockSpec<string, import("../../../extensions/Blocks/api/blockTypes").PropSchema, boolean>>>(editor: BlockNoteEditor<BSchema>, updateSuggestionsMenu: (suggestionsMenuState: SuggestionsMenuState<T>) => void, pluginKey: PluginKey, defaultTriggerCharacter: string, items?: (query: string) => T[], onSelectItem?: (props: {
+export declare const setupSuggestionsMenu: <T extends SuggestionItem, BSchema extends Record<string, import("../../../extensions/Blocks/api/blocks/types").BlockConfig>, I extends InlineContentSchema, S extends StyleSchema>(editor: BlockNoteEditor<BSchema, I, S>, updateSuggestionsMenu: (suggestionsMenuState: SuggestionsMenuState<T>) => void, pluginKey: PluginKey, defaultTriggerCharacter: string, items?: (query: string) => T[], onSelectItem?: (props: {
     item: T;
-    editor: BlockNoteEditor<BSchema>;
+    editor: BlockNoteEditor<BSchema, I, S>;
 }) => void) => {
     plugin: Plugin<SuggestionPluginState<T>>;
     itemCallback: (item: T) => void;

package/types/src/util/EventEmitter.d.ts

@@ -0,0 +1,11 @@
+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>): () => void;
+    protected emit<EventName extends StringKeyOf<T>>(event: EventName, ...args: CallbackType<T, EventName>): void;
+    off<EventName extends StringKeyOf<T>>(event: EventName, fn?: CallbackFunction<T, EventName>): void;
+    protected removeAllListeners(): void;
+}
+export {};

package/types/src/util/browser.d.ts

@@ -0,0 +1,3 @@
+export declare const isAppleOS: () => boolean;
+export declare function formatKeyboardShortcut(shortcut: string): string;
+export declare function mergeCSSClasses(...classes: string[]): string;

package/types/src/util/string.d.ts

@@ -0,0 +1 @@
+export declare function camelToDataKebab(str: string): string;

package/types/src/util/typescript.d.ts

@@ -0,0 +1,3 @@
+export declare class UnreachableCaseError extends Error {
+    constructor(val: never);
+}