@witchcraft/editor 0.0.1

package/dist/runtime/pm/features/CommandsMenus/components/CommandBarItem.vue.d.ts

@@ -0,0 +1,12 @@
+import type { Editor } from "@tiptap/core";
+import { type CommandBarCommand } from "../types.js.js";
+type __VLS_Props = {
+    item: CommandBarCommand;
+    editor: Editor;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuGroup.d.vue.ts

@@ -0,0 +1,10 @@
+import type { CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    item: CommandGroup;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuGroup.vue

@@ -0,0 +1,55 @@
+<template>
+<div
+	class="group/command-group"
+	@mouseenter="popup.setReference(el);
+  showSubMenu = true"
+	@mouseleave="popup.setReference(null);
+  showSubMenu = false"
+>
+	<CommandMenuItem
+		:item="item"
+		v-extract-root-el="(_) => el = _"
+	/>
+	<!-- @vue-expect-error -->
+	<WPopup
+		:model-value="showSubMenu"
+		:preferred-horizontal="['right-most']"
+		:preferred-vertical="popupVerticalPositioner"
+		:position-modifier="popupPositionModifier"
+		:use-backdrop="false"
+		ref="popup"
+		@update:model-value="showSubMenu = $event"
+	>
+		<template #popup="{ extractEl }">
+			<div
+				:ref="extractEl"
+				@mouseleave="popup.setReference(null);
+  showSubMenu = false"
+			>
+				<CommandMenuList
+					:entries="item.variations"
+					class="ml-0 mt-0"
+					@close="emit('close')"
+				/>
+			</div>
+		</template>
+	</WPopup>
+</div>
+</template>
+
+<script setup>
+import WPopup from "@witchcraft/ui/components/LibPopup";
+import { vExtractRootEl } from "@witchcraft/ui/directives/vExtractRootEl";
+import { ref } from "vue";
+import CommandMenuItem from "./CommandMenuItem.vue";
+import CommandMenuList from "./CommandMenuList.vue";
+import { popupPositionModifier } from "../utils/popupPositionModifier.js";
+import { popupVerticalPositioner } from "../utils/popupVerticalPositioner.js";
+defineProps({
+  item: { type: null, required: true }
+});
+const el = ref(null);
+const showSubMenu = ref(false);
+const popup = ref();
+const emit = defineEmits(["close"]);
+</script>

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuGroup.vue.d.ts

@@ -0,0 +1,10 @@
+import type { CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    item: CommandGroup;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuItem.d.vue.ts

@@ -0,0 +1,11 @@
+import type { ItemMenuCommand } from "../../Blocks/types.js.js";
+import { type CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    item: ItemMenuCommand | CommandGroup;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuItem.vue

@@ -0,0 +1,58 @@
+<template>
+<div
+	class="
+		p-1
+	"
+	:title="item.type === 'command' ? item.description : void 0"
+>
+	<div
+		class="
+		group/menu-item
+		px-1
+		rounded-xs
+		hover:text-accent-700
+		dark:hover:text-accent-300
+		cursor-pointer
+	"
+		@click="handleClick"
+	>
+		<WIcon class="w-[1em] text-center">
+			<component
+				v-if="item.icon"
+				:is="'component' in item.icon ? item.icon.component : item.icon"
+				v-bind="'props' in item.icon ? { editor, ...item.icon.props } : { editor }"
+			/>
+		</WIcon>
+		{{ item.title }}
+		<i-fa-solid-chevron-right
+			v-if="item.type === 'group'"
+			class="
+				text-neutral-500
+				pl-2
+				group-hover/menu-item:text-accent-500
+			"
+		/>
+	</div>
+</div>
+</template>
+
+<script setup>
+import { inject } from "vue";
+import IFaSolidChevronRight from "~icons/fa-solid/chevron-right";
+import { commandExecuterInjectionKey, menuEditorInjectionKey } from "../types.js";
+const editor = inject(menuEditorInjectionKey);
+const props = defineProps({
+  item: { type: null, required: true }
+});
+const emit = defineEmits(["close"]);
+const executer = inject(commandExecuterInjectionKey);
+if (!executer) {
+  throw new Error("Command executer must be provided.");
+}
+function handleClick() {
+  if (props.item.type === "command") {
+    executer(props.item, editor.value);
+    emit("close");
+  }
+}
+</script>

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuItem.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ItemMenuCommand } from "../../Blocks/types.js.js";
+import { type CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    item: ItemMenuCommand | CommandGroup;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuList.d.vue.ts

@@ -0,0 +1,11 @@
+import type { ItemMenuCommand } from "../../Blocks/types.js";
+import type { CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    entries: (ItemMenuCommand | CommandGroup)[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuList.vue

@@ -0,0 +1,54 @@
+<template>
+<div
+	class="
+	commands-list
+	flex
+	flex-col
+	rounded-sm
+	border
+	bg-neutral-100
+	border-neutral-300
+	dark:bg-neutral-800
+	dark:border-neutral-700
+	m-1
+	[&>*:first-child]:border-t-0
+	[&>*:first-child]:rounded-t-sm
+	[&>*:last-child]:rounded-b-sm
+"
+>
+	<template
+		v-for="item in entries"
+		:key="item.type + item.title"
+	>
+		<div
+
+			class="
+			border-t
+			border-neutral-300
+		"
+		>
+			<div v-if="item.type === 'command'">
+				<CommandMenuItem
+					:item="item"
+					@close="emit('close')"
+				/>
+			</div>
+
+			<CommandMenuGroup
+				v-else-if="item.type === 'group'"
+				:item="item"
+				@close="emit('close')"
+			/>
+		</div>
+	</template>
+</div>
+</template>
+
+<script setup>
+import CommandMenuGroup from "./CommandMenuGroup.vue";
+import CommandMenuItem from "./CommandMenuItem.vue";
+defineProps({
+  entries: { type: Array, required: true }
+});
+const emit = defineEmits(["close"]);
+</script>

package/dist/runtime/pm/features/CommandsMenus/components/CommandMenuList.vue.d.ts

@@ -0,0 +1,11 @@
+import type { ItemMenuCommand } from "../../Blocks/types.js";
+import type { CommandGroup } from "../types.js.js";
+type __VLS_Props = {
+    entries: (ItemMenuCommand | CommandGroup)[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/TextIcon.d.vue.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    text: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/components/TextIcon.vue

@@ -0,0 +1,13 @@
+<template>
+<span v-bind="$attrs">
+	{{ text }}
+</span>
+</template>
+
+<script setup>
+import { useAttrs } from "vue";
+defineProps({
+  text: { type: String, required: true }
+});
+const $attrs = useAttrs();
+</script>

package/dist/runtime/pm/features/CommandsMenus/components/TextIcon.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    text: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/HighlightIcon.d.vue.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "@tiptap/core";
+import type { HighlightMarkOptions } from "../../Highlight/types.js.js";
+type __VLS_Props = {
+    editor: Editor;
+    colorSlot?: keyof HighlightMarkOptions["colors"] | string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/HighlightIcon.vue

@@ -0,0 +1,45 @@
+<template>
+<div
+	class=" flex justify-center items-center"
+>
+	<div
+		v-if="colorSlot !== void 0"
+		class=" w-[1rem] h-[1rem] rounded-full text-sm overflow-hidden"
+		:style="`background-color: ${color?.color}`"
+		:title="color?.name"
+	>
+		<FaSolidHighlighter class="mb-2 ml-1"/>
+	</div>
+	<div
+		v-else
+		class="
+		w-[1rem]
+		h-[1rem]
+		rounded-full
+		bg-neutral-100
+		dark:bg-neutral-900
+		border-2
+		border-dashed
+		border-neutral-500
+		flex justify-center items-center
+	"
+	/>
+</div>
+</template>
+
+<script setup>
+import { computed } from "vue";
+import FaSolidHighlighter from "~icons/lucide/highlighter";
+import { highlightPluginKey } from "../../Highlight/types.js";
+const props = defineProps({
+  editor: { type: null, required: true },
+  colorSlot: { type: null, required: false }
+});
+const color = computed(() => {
+  const colors = highlightPluginKey.getState(props.editor.state)?.colors;
+  if (colors && props.colorSlot !== void 0) {
+    return colors[props.colorSlot];
+  }
+  return void 0;
+});
+</script>

package/dist/runtime/pm/features/CommandsMenus/icons/HighlightIcon.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Editor } from "@tiptap/core";
+import type { HighlightMarkOptions } from "../../Highlight/types.js.js";
+type __VLS_Props = {
+    editor: Editor;
+    colorSlot?: keyof HighlightMarkOptions["colors"] | string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/SubscriptIcon.d.vue.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/SubscriptIcon.vue

@@ -0,0 +1,5 @@
+<template>
+<span>
+	X<sub class="pl-1">2</sub>
+</span>
+</template>

package/dist/runtime/pm/features/CommandsMenus/icons/SubscriptIcon.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/SuperscriptIcon.d.vue.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/icons/SuperscriptIcon.vue

@@ -0,0 +1,5 @@
+<template>
+<span>
+	X<sup class="pl-1">2</sup>
+</span>
+</template>

package/dist/runtime/pm/features/CommandsMenus/icons/SuperscriptIcon.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/CommandsMenus/types.d.ts

@@ -0,0 +1,61 @@
+import type { ChainedCommands, Editor } from "@tiptap/core";
+import { type EditorState, PluginKey } from "@tiptap/pm/state";
+import type { FunctionalComponent, InjectionKey, Ref } from "vue";
+export interface CommandBarExtensionOptions {
+    commandBar: CommandBarMenu;
+}
+export type Command<TRegularArgs extends any[] = any[], TFuncArgs extends ((editor: Editor, ...args: any[]) => any[]) = ((editor: Editor, ...args: any[]) => any[])> = {
+    type: "command";
+    command: keyof ChainedCommands;
+    title: string;
+    description?: string;
+    icon?: (new () => any) | FunctionalComponent | {
+        component: (new () => any) | FunctionalComponent;
+        props?: Record<string, any>;
+    };
+    /**
+     * Args to pass to the command.
+     *
+     * A function to determine those args can also be
+     * passed instead.
+     *
+     * What context is provided to the function depends on the meny.
+     */
+    args?: TRegularArgs | TFuncArgs;
+    /**
+     * Determines whether the entry should be shown.
+     *
+     * Note that while one can just use tiptap's `can()` method, some commands are
+     * expensive to execute, so it's better to just do a more generic lightweight check in those situations.
+     */
+    canShow?: (editorstate: EditorState) => boolean;
+};
+export type CommandGroup<T extends string | never = string, TCommand extends Command<any> = Command<any>, TNestable extends boolean = false> = {
+    icon?: (new () => any) | {
+        component: new () => any;
+        props?: Record<string, any>;
+    };
+    type: "group";
+    groupType?: T extends string ? T : never;
+    title: string;
+    variations: TNestable extends false ? TCommand[] : (TCommand | CommandGroup<T, TCommand, TNestable>)[];
+};
+export declare const menuEditorInjectionKey: InjectionKey<Ref<Editor>>;
+export declare const menuBlockIdInjectionKey: InjectionKey<Ref<string | undefined>>;
+export type CommandBarMenuState = {
+    state: boolean;
+    /** For internal use, the commandBar can't be opened if the editor isn't focused. */
+    canOpen: boolean;
+};
+export declare const commandBarMenuPluginKey: PluginKey<CommandBarMenuState>;
+export type CommandBarCommand = Command;
+export type CommandBarGroup = CommandGroup<"inline", /* todo | "dropdown" */ CommandBarCommand, false>;
+export type CommandBarMenu = {
+    enabled: true | false | Record<string, boolean>;
+    commands: (CommandBarCommand | CommandBarGroup)[];
+    options?: {
+        onlyOpenOnSelection?: boolean;
+    };
+};
+export type CommandExecuter = (item: Command, editor: Editor) => void;
+export declare const commandExecuterInjectionKey: InjectionKey<CommandExecuter>;

package/dist/runtime/pm/features/CommandsMenus/types.js

@@ -0,0 +1,5 @@
+import { PluginKey } from "@tiptap/pm/state";
+export const menuEditorInjectionKey = Symbol("menuEditorInjectionKey");
+export const menuBlockIdInjectionKey = Symbol("menuBlockIdInjectionKey");
+export const commandBarMenuPluginKey = new PluginKey("commandBarMenuPluginKey");
+export const commandExecuterInjectionKey = Symbol("commandExecuterInjectionKey");

package/dist/runtime/pm/features/CommandsMenus/utils/defaultCommandExecutor.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "@tiptap/core";
+import type { Command } from "../types.js.js";
+export declare function defaultCommandExecuter(item: Command, editor: Editor): void;

package/dist/runtime/pm/features/CommandsMenus/utils/defaultCommandExecutor.js

@@ -0,0 +1,11 @@
+import { castType } from "@alanscodelog/utils/castType";
+export function defaultCommandExecuter(item, editor) {
+  if (item.type === "command") {
+    const args = typeof item.args === "function" ? item.args(editor) : item.args ?? [];
+    editor.commands.command(({ commands }) => {
+      castType(item);
+      commands[item.command](...args);
+      return true;
+    });
+  }
+}

package/dist/runtime/pm/features/CommandsMenus/utils/findCommand.d.ts

@@ -0,0 +1,10 @@
+import type { Command, CommandGroup } from "../types.js.js";
+/**
+ * Deep search through a list of commands/command groups.
+ *
+ * The callback is passed each command
+ * and it's parent group if it has one..
+ *
+ * Returning true will stop the search.
+ */
+export declare function findCommand<TEntry extends Command | CommandGroup, TCommand extends Exclude<TEntry, CommandGroup>, TCommandGroup extends Exclude<TEntry, Command>>(commands: TEntry[], cb: (command: TCommand, parent: TCommandGroup | undefined) => boolean): boolean;

package/dist/runtime/pm/features/CommandsMenus/utils/findCommand.js

@@ -0,0 +1,16 @@
+import { castType } from "@alanscodelog/utils/castType";
+export function findCommand(commands, cb) {
+  const parent = arguments[2];
+  const internalFindCommand = findCommand;
+  for (const item of commands) {
+    if (item.type === "command") {
+      castType(item);
+      const res = cb(item, parent);
+      if (res) return true;
+    } else if (item.type === "group") {
+      const res = internalFindCommand(item.variations, cb, item);
+      if (res) return true;
+    }
+  }
+  return false;
+}

package/dist/runtime/pm/features/CommandsMenus/utils/popupPositionModifier.d.ts

@@ -0,0 +1,5 @@
+import type { PopupPositionModifier } from "@witchcraft/ui/types";
+/**
+    * Modifes the popup to have a max width and height if it doesn't fit in the window.
+    */
+export declare const popupPositionModifier: PopupPositionModifier;

package/dist/runtime/pm/features/CommandsMenus/utils/popupPositionModifier.js

@@ -0,0 +1,9 @@
+export const popupPositionModifier = (pos, _reference, popup, veil) => {
+  if (popup.height > veil.height) {
+    pos.maxHeight = veil.height;
+  }
+  if (popup.width > veil.width) {
+    pos.maxWidth = veil.width;
+  }
+  return pos;
+};

package/dist/runtime/pm/features/CommandsMenus/utils/popupVerticalPositioner.d.ts

@@ -0,0 +1,5 @@
+import type { PopupPositioner } from "@witchcraft/ui/types";
+/**
+    * Position the popup so it's top edge is at the item's top edge, UNLESS it hits the top  or bottom edges, in which case it'll shift the positioning, always keeping the top of the menu in view.
+    */
+export declare const popupVerticalPositioner: PopupPositioner;

package/dist/runtime/pm/features/CommandsMenus/utils/popupVerticalPositioner.js

@@ -0,0 +1,11 @@
+export const popupVerticalPositioner = (reference, popup, veil, space) => {
+  if (!reference) return 0;
+  const spaceBottomFromReferenceTop = veil.y + veil.height - reference.y;
+  if (space.top <= 0 || space.top + reference.width + space.bottom <= popup.height) {
+    return 0;
+  } else if (spaceBottomFromReferenceTop > popup.height) {
+    return reference.y;
+  } else {
+    return veil.y + veil.height - popup.height;
+  }
+};

package/dist/runtime/pm/features/Document/Document.d.ts

@@ -0,0 +1,3 @@
+import { Node } from "@tiptap/core";
+export declare const Document: Node<any, any>;
+export type NodeDocumentName = "doc";

package/dist/runtime/pm/features/Document/Document.js

@@ -0,0 +1,6 @@
+import { Node } from "@tiptap/core";
+export const Document = Node.create({
+  name: "doc",
+  topNode: true,
+  content: "list"
+});

package/dist/runtime/pm/features/DocumentApi/DocumentApi.d.ts

@@ -0,0 +1,85 @@
+import { type Content, Editor, type EditorOptions } from "@tiptap/core";
+import type { Schema } from "@tiptap/pm/model";
+import type { EditorState, Plugin, Transaction } from "@tiptap/pm/state";
+import type { DocId, DocumentApiInterface, EmbedId, OnSaveDocumentCallback, OnUpdateDocumentCallback } from "./types.js.js";
+/**
+ * Configures the document api which tells the editor how to load/unload/save/cache documents, including embedded ones.
+ *
+ * The cache implementation is left up to the user, hence why it's defined as a get/set interface. A load function must be provided for requesting uncached documents.
+ *
+ * `save` is optional, but you probably want to save. The function is automatically debounced the configured amount.
+ *
+ * **Any function that needs to return a document should return it unwrapped with toRaw if it was a ref or in a ref or reactive. **
+ *
+ * A `refCounter` object can be provided with the respective load/unload functions to be notified when embedded views load/unload documents to reference count them and unload them once no editors have them in use.
+ *
+ * It is safe to call load multiple times for the same document, the actual load function will only be called once per document, but the refCounter will be called multiple times.
+ *
+ * The `getTitle` function can be provided to customize the title of the embedded document. It's passed the full embed id and returns it as docId#blockId by default.
+ *
+ * If there are extensions that use onCreate to set state or have plugins that need to change the state on init with appendTransaction, they will not work since there is no view to initialize the plugins. To get around this, plugins can specify a stateInit function that will be called with a transaction from the initial loaded state which it can then modify while having access to `this` and the extension options.
+ *
+ * The api creates a default instance of the editor to copy plugins from, this can be replaced by passing your own editor instance.
+ *
+ * See {@link useTestDocumentApi} for an example of how to set things up.
+ */
+export declare class DocumentApi<T extends Record<string, any> = Record<string, any>> implements DocumentApiInterface<T> {
+    private readonly _callbacks;
+    private readonly _load;
+    private readonly _save?;
+    private readonly _saveQueue;
+    readonly save: DocumentApiInterface<T>["save"];
+    private readonly _cache;
+    /**
+     * The refCounter is called every time an editor loads or unloads a document. It's used to keep track of the number of editors that are using a document, and to unload it when no editors are using it.
+     *
+     * Note that you need not immediately unload the cached document. So long as the count is immediatly updated you can set a timeout to actually delete the cache entry (be sure to check the count it still 0 and you can delete it).
+     */
+    private readonly _refCounter;
+    getSuggestions: DocumentApiInterface["getSuggestions"];
+    getEmbedTitle: DocumentApiInterface["getEmbedTitle"];
+    postEditorInit: DocumentApiInterface["postEditorInit"];
+    preEditorInit: DocumentApiInterface["preEditorInit"];
+    updateFilter?: DocumentApiInterface["updateFilter"];
+    editor: Editor;
+    constructor({ editorOptions, getTitle, getSuggestions, load, save, saveDebounce, cache, refCounter, postEditorInit, preEditorInit, updateFilter }: {
+        /**
+         * The editor options for the internal instance to use to keep track of the document state. It should include the same extensions as the root editor.
+         */
+        editorOptions: Partial<EditorOptions>;
+        getTitle?: (docId: string, blockId?: string) => string;
+        getSuggestions: DocumentApiInterface["getSuggestions"];
+        load: (docId: string, schema: Schema, plugins: Plugin[]) => Promise<{
+            state: EditorState;
+            data?: T;
+        }>;
+        save?: DocumentApi["_save"];
+        saveDebounce?: number;
+        cache: DocumentApi["_cache"];
+        refCounter: DocumentApi<T>["_refCounter"];
+        postEditorInit?: DocumentApi["postEditorInit"];
+        preEditorInit?: DocumentApi["preEditorInit"];
+        updateFilter?: DocumentApi["updateFilter"];
+    });
+    _saveDocument(docId: string): Promise<void>;
+    updateDocument(embedId: DocId, tr: Transaction, updaterSymbol?: symbol): void;
+    addEventListener(type: "saving" | "saved", cb: OnSaveDocumentCallback): void;
+    addEventListener(type: "update", cb: OnUpdateDocumentCallback): void;
+    removeEventListener(type: "saving" | "saved", cb: OnSaveDocumentCallback): void;
+    removeEventListener(type: "update", cb: OnUpdateDocumentCallback): void;
+    unload({ docId }: DocId): void;
+    private readonly _loading;
+    load({ docId }: DocId): Promise<{
+        state: EditorState;
+        data?: T;
+    }>;
+    private _loadInternal;
+    getFullState(docId: DocId): EditorState;
+    getFromCache(docId: DocId, options?: {
+        errorIfNotFound: true;
+    }): EditorState;
+    getFromCache(docId: DocId, options?: {
+        errorIfNotFound?: boolean;
+    }): EditorState | undefined;
+    getEmbeddedContent(embedId: EmbedId): Content | undefined;
+}