@witchcraft/editor 0.0.5 → 0.0.7

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

@@ -0,0 +1,170 @@
+import { debounce } from "@alanscodelog/utils/debounce";
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { Editor } from "@tiptap/vue-3";
+import { isProxy } from "vue";
+import { convertTransactionForFullState } from "./utils/convertTransactionForFullState.js";
+import { getEmbedJson } from "./utils/getEmbedJson.js";
+import { getEmbedNodeFromDoc } from "./utils/getEmbedNodeFromDoc.js";
+export class DocumentApi {
+  _callbacks = { update: [], saved: [], saving: [] };
+  _load;
+  _save;
+  _saveQueue = {};
+  save;
+  _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).
+   */
+  _refCounter;
+  getSuggestions;
+  getEmbedTitle;
+  postEditorInit;
+  // editor + updateState does not work :/
+  preEditorInit = (_docId, options, state) => {
+    options.content = state.doc.toJSON();
+    return options;
+  };
+  updateFilter = () => true;
+  editor;
+  constructor({
+    editorOptions,
+    getTitle,
+    getSuggestions,
+    load,
+    save,
+    saveDebounce = 1e3,
+    cache,
+    refCounter,
+    postEditorInit,
+    preEditorInit,
+    updateFilter
+  }) {
+    this.updateFilter = updateFilter;
+    this.getEmbedTitle = getTitle ? ({ docId, blockId }) => getTitle(docId, blockId) : ({ docId, blockId }) => `${docId}${blockId ? `#${blockId}` : ""}`;
+    this._load = load;
+    this._cache = cache;
+    this._refCounter = refCounter;
+    this._save = save;
+    const debouncedSave = debounce(this._saveDocument.bind(this), saveDebounce, {
+      queue: this._saveQueue,
+      // even though save is async, promisified debounce is slightly more expensive because it creates a new function with every call
+      // and we don't really need that
+      promisify: false
+    });
+    this.save = function save2(docId) {
+      for (const cb of this._callbacks.saving) {
+        cb(docId);
+      }
+      debouncedSave(docId);
+    };
+    this.postEditorInit = postEditorInit ?? (() => {
+    });
+    if (preEditorInit) this.preEditorInit = preEditorInit;
+    this.getSuggestions = getSuggestions;
+    this.editor = new Editor({
+      ...editorOptions,
+      extensions: [...editorOptions.extensions],
+      injectCSS: false
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  async _saveDocument(docId) {
+    if (this._save) {
+      await this._save(docId);
+      for (const cb of this._callbacks.saved) {
+        cb(docId);
+      }
+    } else {
+      console.warn("No save function provided, ignoring save request.");
+    }
+  }
+  updateDocument(embedId, tr, updaterSymbol) {
+    if (this.updateFilter && this.updateFilter(tr) === false) return;
+    const stateBefore = this.getFromCache(embedId, { errorIfNotFound: true });
+    const modifiedTr = convertTransactionForFullState(stateBefore, tr);
+    const newState = stateBefore.apply(modifiedTr);
+    this._cache.set(embedId.docId, newState);
+    for (const cb of this._callbacks.update) {
+      cb(embedId, modifiedTr, stateBefore, newState, updaterSymbol);
+    }
+  }
+  addEventListener(type, cb) {
+    this._callbacks[type].push(cb);
+  }
+  removeEventListener(type, cb) {
+    const cbIndex = this._callbacks[type].indexOf(cb);
+    if (cbIndex === -1) {
+      throw new Error("Tried to remove a callback that was not registered.");
+    }
+    this._callbacks[type].splice(cbIndex, 1);
+  }
+  unload({ docId }) {
+    this._refCounter.unload(docId);
+  }
+  _loading = {};
+  async load({ docId }) {
+    this._loading[docId] ??= this._loadInternal({ docId });
+    const res = await this._loading[docId];
+    if (res === void 0) unreachable();
+    this._loading[docId] = void 0;
+    this._refCounter.load(docId, res);
+    if (isProxy(res.state)) {
+      throw new Error("State cannot be a reactive proxy. You can use toRaw as a temporary workaround but you should ideally not make it reactive");
+    }
+    this._cache.set(docId, res.state);
+    return res;
+  }
+  async _loadInternal({ docId }) {
+    const cachedState = this.getFromCache({ docId }, { errorIfNotFound: false });
+    if (isProxy(cachedState)) {
+      throw new Error("State cannot be a reactive proxy. You can use toRaw as a temporary workaround but you should ideally not make it reactive");
+    }
+    if (cachedState) {
+      const res = { state: cachedState };
+      this._refCounter.load(docId, res);
+      return res;
+    }
+    const schema = this.editor.schema;
+    const loaded = await this._load(
+      docId,
+      schema,
+      [...this.editor.extensionManager.plugins]
+    );
+    let state = loaded.state;
+    const tr = state.tr;
+    tr.setMeta("addToHistory", false);
+    for (const plugin of state.plugins) {
+      if (plugin.spec.stateInit) {
+        plugin.spec.stateInit(tr);
+      }
+    }
+    state = state.apply(tr);
+    return { data: loaded.data, state };
+  }
+  getFullState(docId) {
+    return this.getFromCache(docId, { errorIfNotFound: true });
+  }
+  getFromCache({ docId }, options) {
+    const cached = this._cache.get(docId);
+    if (cached) return cached;
+    if (options?.errorIfNotFound) {
+      throw new Error(`Could not find cached state for document ${docId}. Expected document to be loaded.`);
+    }
+    if (isProxy(cached)) {
+      throw new Error("State cannot be a reactive proxy. You can use toRaw as a temporary workaround but you should ideally not make it reactive");
+    }
+    return void 0;
+  }
+  getEmbeddedContent(embedId) {
+    const state = this.getFullState(embedId);
+    const json = state.doc.toJSON();
+    const nodeWanted = getEmbedNodeFromDoc(json, embedId.blockId);
+    if (embedId.blockId && !nodeWanted) {
+      return void 0;
+    } else {
+      return getEmbedJson(nodeWanted) ?? json;
+    }
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { Content, Editor, EditorOptions } from "@tiptap/core";
+import { type Ref, type ShallowRef } from "vue";
+import type { DocumentApiInterface } from "../types.js";
+/**
+    * Provides two ways to load content into the editor.
+    *
+    * The simple one, which is just to provide a content ref.
+    *
+    * And the more advanced one which uses the document api to load the content. This requires passing the embed api and an id to load.
+    *
+    * The second option is usually the best, as multiple editors can load the same content and it's automatically kept in sync. See {@link DocumentApi} for more info.
+    */
+export declare function useEditorContent(editor: ShallowRef<Editor | undefined>, content: Ref<Content | undefined>, id: Ref<string | undefined>, documentApi: DocumentApiInterface | undefined, recreate: (modifyOptions?: (options: Partial<EditorOptions>) => Partial<EditorOptions>) => void): void;

package/dist/runtime/pm/features/DocumentApi/composables/useEditorContent.js

@@ -0,0 +1,76 @@
+import { nextTick, onBeforeUnmount, watch } from "vue";
+import { convertTrForInstance } from "../utils/convertTrForInstance.js";
+export function useEditorContent(editor, content, id, documentApi, recreate) {
+  const selfSymbol = Symbol(`self${Math.random()}`);
+  function onTransaction({ transaction: tr }) {
+    if (!documentApi || !id.value || !tr.docChanged || tr.getMeta("ignore")) {
+      return;
+    }
+    tr.setMeta("no-step-convert", true);
+    documentApi.updateDocument({ docId: id.value }, tr, selfSymbol);
+  }
+  const onUpdateDocument = (embedId, tr, __, ___, symbol) => {
+    if (symbol !== selfSymbol && !tr.getMeta("ignore") && tr.docChanged && embedId.docId === id.value) {
+      tr.setMeta("ignore", true);
+      const convertedTr = convertTrForInstance(
+        tr,
+        editor.value.state
+      );
+      editor.value?.view.dispatch(convertedTr);
+    }
+    if (tr.docChanged) {
+      void documentApi?.save(embedId.docId);
+    }
+  };
+  let attached = false;
+  async function load(changed) {
+    if (content.value) {
+      editor.value?.commands.setContent(content.value);
+    } else if (documentApi) {
+      if (changed && id.value) {
+        await documentApi.load({ docId: id.value });
+        const state = documentApi.getFullState({ docId: id.value });
+        recreate((options) => documentApi.preEditorInit?.(id.value, { ...options }, state));
+        await nextTick(async () => {
+          editor.value.on("transaction", onTransaction);
+          documentApi.addEventListener("update", onUpdateDocument);
+          documentApi.postEditorInit(id.value, editor.value);
+          attached = true;
+        });
+      }
+    }
+  }
+  function unload(oldId) {
+    if (oldId !== void 0 && documentApi) {
+      documentApi.unload({ docId: oldId });
+      if (attached) {
+        documentApi.removeEventListener("update", onUpdateDocument);
+        editor.value?.off("transaction", onTransaction);
+        attached = false;
+      }
+    }
+  }
+  watch([content, id, editor], async ([_newContent, newId], [_oldContent, oldId]) => {
+    if (!editor.value) {
+      return;
+    }
+    if (!content.value && (!id.value || !documentApi)) {
+      throw new Error("No content or id and document api provided.");
+    }
+    if (id.value && !documentApi) {
+      throw new Error("Id provided but no document api provided.");
+    }
+    if (oldId !== void 0 && newId !== oldId && documentApi) {
+      unload(oldId);
+      await load(true);
+    } else if (_newContent) {
+      await load(false);
+    }
+  }, { deep: false });
+  void load(true);
+  onBeforeUnmount(() => {
+    if (id.value) {
+      unload(id.value);
+    }
+  });
+}

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

@@ -0,0 +1,23 @@
+import type { EditorOptions } from "@tiptap/core";
+import { EditorState } from "@tiptap/pm/state";
+import { type Ref } from "vue";
+import type { DocumentApiInterface } from "../types.js";
+type Cache = Record<string, {
+    state?: EditorState;
+    count: number;
+}>;
+/** Creates a simple instance of the DocumentApi for testing purposes. */
+export declare function useTestDocumentApi(editorOptions: Partial<EditorOptions>, embeds: Record<string, {
+    content: any;
+    title?: string;
+}>, { loadDelay }?: {
+    loadDelay?: number;
+}): {
+    cache: Ref<Cache>;
+    documentApi: DocumentApiInterface;
+    embeds: Record<string, {
+        content: any;
+        title?: string;
+    }>;
+};
+export {};

package/dist/runtime/pm/features/DocumentApi/composables/useTestDocumentApi.js

@@ -0,0 +1,70 @@
+import { delay } from "@alanscodelog/utils/delay";
+import { keys } from "@alanscodelog/utils/keys";
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { createDocument, generateJSON } from "@tiptap/core";
+import { EditorState } from "@tiptap/pm/state";
+import { ref, toRaw } from "vue";
+import { testExtensions } from "../../../testSchema.js";
+import { DocumentApi } from "../DocumentApi.js";
+export function useTestDocumentApi(editorOptions, embeds, { loadDelay = 0 } = {}) {
+  const cache = ref({});
+  const documentApi = new DocumentApi({
+    editorOptions,
+    getSuggestions: async (searchString) => {
+      const res = [];
+      for (const docId of keys(embeds)) {
+        const title = embeds[docId].title ?? docId;
+        if (title.includes(searchString)) {
+          res.push({ title, docId });
+        }
+      }
+      if (loadDelay) {
+        await delay(loadDelay);
+      }
+      return res;
+    },
+    getTitle: (docId, blockId) => (embeds[docId]?.title ?? docId) + (blockId ? `#${blockId}` : ""),
+    cache: {
+      get(docId) {
+        return toRaw(cache.value[docId]?.state);
+      },
+      set(docId, state) {
+        cache.value[docId].state = state;
+      }
+    },
+    load: async (docId, schema, plugins) => {
+      if (loadDelay) {
+        await delay(loadDelay);
+      }
+      if (!embeds[docId]) {
+        throw new Error(`No embed found for docId ${docId} in: ${JSON.stringify(embeds, null, "	")}`);
+      }
+      const json = generateJSON(embeds[docId].content, testExtensions);
+      const doc = createDocument(json, schema);
+      const state = EditorState.create({
+        doc,
+        schema,
+        plugins
+      });
+      return { state };
+    },
+    refCounter: {
+      load(docId, loaded) {
+        cache.value[docId] ??= { ...loaded, count: 0 };
+        cache.value[docId].count++;
+      },
+      unload: (docId) => {
+        if (cache.value[docId]) {
+          if (cache.value[docId].count === 1) {
+            delete cache.value[docId];
+          } else {
+            cache.value[docId].count--;
+          }
+        } else {
+          unreachable();
+        }
+      }
+    }
+  });
+  return { documentApi, cache, embeds };
+}

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

@@ -0,0 +1,133 @@
+import type { Content, Editor, EditorOptions } from "@tiptap/core";
+import type { EditorState, Transaction } from "@tiptap/pm/state";
+import type { InjectionKey } from "vue";
+export declare const documentApiInjectionKey: InjectionKey<DocumentApiInterface>;
+export type DocId = {
+    docId: string;
+};
+export type BlockId = {
+    blockId?: string;
+};
+/** When the user initially creates an embed, it's docId will be undefined. */
+export type MaybeEmbedId = Partial<DocId> & BlockId;
+export type EmbedId = DocId & BlockId;
+export type OnUpdateDocumentCallback = (embedId: DocId, tr: Transaction, oldEditorState: EditorState, newEditorState: EditorState, selfSymbol?: symbol) => void;
+export type OnSaveDocumentCallback = (docId: string) => void;
+export type DocumentApiInterface<T extends Record<string, any> = Record<string, any>> = {
+    /** Debounced save (to storage) function. Use the event listeners to get notified when saving finishes. */
+    save: (docId: string) => void;
+    getEmbeddedContent: (embedId: EmbedId) => Content | undefined;
+    getFromCache: (docId: DocId, options?: {
+        errorIfNotFound?: boolean;
+    }) => EditorState | undefined;
+    /** Load should be called the first time, before attempting to load the state. */
+    getFullState: (docId: DocId) => EditorState;
+    /** Like {@link DocumentApi.preEditorInit}, but after initializing and loading the document (and before the transaction listeners are added). */
+    postEditorInit: (docId: string, editor: Editor) => void;
+    /**
+     * Sets options before initializing the editor. By default just does `options.content = state.doc.toJSON()`, but can be useful when managing the document state in some other way (e.g. collab.
+     *
+     * Also useful for creating per-doc instances for certain extensions, such as Collaboration.
+     *
+     * This is a bit tricky to do normally since the editor component initializes the editor before the document is loaded and is re-used (the wrapper Editor *component*, not the editor) when the document changes.
+     *
+     * So this hook can be used to add these additional per-doc instances of extensions. Be sure to clone the properties you are modifying. They are only shallow cloned before being passed to the function.
+     *
+     * ```ts
+     * preEditorInit(docId, options: Partial<EditorOptions>, state: EditorState) {
+     * 	// we do not need to set options.content when using collab
+     * 	// so no options.content = state.doc.toJSON()
+     * 	const ydoc = cache.value[docId].ydoc
+     * 	// it's suggested you add the collab extension only here
+     *		// otherwise you would have to initially configure it with a dummy document
+     * 	const collabExt = Collaboration.configure({
+     * 		document: ydoc
+     * 	}) as any
+     * 	options.extensions = [
+     * 		...(options.extensions ?? []),
+     * 		collabExt
+     * 	]
+     * 	return options
+     * },
+     * load: async (
+     * 	docId: string,
+     * 	schema: Schema,
+     * 	plugins: Plugin[],
+     * ) => {
+     * 	if (cache.value[docId]?.state) {
+     * 		return { state: toRaw(cache.value[docId].state) }
+     * 	}
+     * 	const doc = getFromYourDb(docId)
+     * 	const decoded = toUint8Array(doc.contentBinary)
+     * 	const yDoc = new Y.Doc()
+     * 	Y.applyUpdate(yDoc, decoded)
+     *
+     * 	const yjs = initProseMirrorDoc(yDoc.getXmlFragment("prosemirror"), schema)
+     * 	const state = EditorState.create({
+     * 		doc: yjs.doc,
+     * 		schema,
+     * 		plugins:[
+     * 			...plugins,
+     * 			// the document api's yjs instance
+     * 			ySyncPlugin(yDoc.getXmlFragment("prosemirror"), {mapping:yjs.mapping}),
+     * 		]
+     * 	})
+     * 	// return the state and any additional data we want refCounter.load to be called with.
+     * 	return { state, doc, yDoc }
+     * },
+     * updateFilter(tr:Transaction) {
+     * 	const meta = tr.getMeta(ySyncPluginKey)
+     * 	if (meta) return false
+     * 	return true
+     * },
+     * ```
+     * See {@link DocumentApi.updateFilter} for why yjs (and other syncronization mechanisms) might need to ignore transactions.
+     */
+    preEditorInit: (docId: string, options: Partial<EditorOptions>, state: EditorState) => Partial<EditorOptions>;
+    /**
+     * Return false to ignore the transaction.
+     *
+     * This is useful when using a secondary syncronization mechanism, such as yjs.
+     *
+     * If you load all editors of a file with yjs's plugin and point to the same ydoc, yjs's plugin will sync them. But that means that when the DocumentApi tries to sync the transactions they will have already been applied and the document update will fail.
+     *
+     * So we have to ignore all of yjs's transactions, but NOT transactions from partially embedded docs => full state, as these do not pass through yjs.
+     */
+    updateFilter?: (tr: Transaction) => boolean | undefined;
+    updateDocument: (embedId: DocId, tr: Transaction, selfSymbol?: 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;
+    /** For the embedded document picker, should return suggestions for the search string. */
+    getSuggestions: (searchString: string) => Promise<{
+        title: string;
+        docId: string;
+    }[]>;
+    /** How to format the title of the embedded document. Defaults to docId#blockId */
+    getEmbedTitle: (embedId: EmbedId) => string;
+    /**
+     * Tells the document api how to load an unloaded document and any additional data. Whatever this function returns will be passed to the refCounter.load option in the default DocumentApi implementation.
+     *
+     * ```ts
+     *	 load: async ( docId: string, schema: Schema, plugins: Plugin[],) => {
+     * 	const dbDoc = getFromYourDb(docId)
+     *
+     * 	const state = EditorState.create({
+     * 		doc: yjs.doc,
+     * 		schema,
+     * 		plugins
+     * 	})
+     * 	// return the state and any additional data we want to cache
+     * 	return { state, data: { dbDoc } }
+     * },
+     * ```
+     * See {@link DocumentApi.preEditorInit} for how to set this up with sync (e.g. yjs).
+     */
+    load: (docId: DocId) => Promise<{
+        state: EditorState;
+        data?: T;
+    }>;
+    /** Notifies the document api that an editor has unloaded the document. */
+    unload: (docId: DocId) => void;
+};

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

@@ -0,0 +1 @@
+export const documentApiInjectionKey = Symbol("documentApiInjectionKey");

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

@@ -0,0 +1,3 @@
+import type { EditorState, Transaction } from "@tiptap/pm/state";
+import type { EmbedId } from "../types.js";
+export declare function convertFullTransactionForPartialState(state: EditorState, tr: Transaction, embedId: EmbedId): Transaction | undefined;

package/dist/runtime/pm/features/DocumentApi/utils/convertFullTransactionForPartialState.js

@@ -0,0 +1,37 @@
+import { Step } from "@tiptap/pm/transform";
+import { copyMeta } from "./copyMeta.js";
+import { getStateEmbedRange } from "./getStateEmbedRange.js";
+import { getDiffReplacementRange } from "../../../utils/getDiffReplacementRange.js";
+export function convertFullTransactionForPartialState(state, tr, embedId) {
+  const blockId = embedId.blockId;
+  if (!blockId) {
+    const steps = JSON.parse(
+      JSON.stringify(tr.steps)
+    ).map((step) => Step.fromJSON(state.schema, step));
+    const intTr2 = state.tr;
+    copyMeta(tr, intTr2);
+    intTr2.setMeta("ignore", true);
+    for (const step of steps) {
+      intTr2.step(step);
+    }
+    return intTr2;
+  }
+  const { start: nodeStartExisting } = getStateEmbedRange(state.doc, embedId);
+  const { start: nodeStart } = getStateEmbedRange(
+    tr.doc,
+    embedId
+  );
+  if (nodeStart === void 0 || nodeStartExisting === void 0) return void 0;
+  const intTr = state.tr;
+  copyMeta(tr, intTr);
+  intTr.setMeta("ignore", true);
+  const existingNode = state.doc.nodeAt(nodeStartExisting);
+  const newNode = tr.doc.nodeAt(nodeStart);
+  const convertedNewNode = newNode ? state.schema.nodeFromJSON(newNode.toJSON()) : void 0;
+  if (!existingNode || !convertedNewNode) return void 0;
+  const diff = getDiffReplacementRange(existingNode, convertedNewNode, nodeStartExisting - 1);
+  if (diff) {
+    intTr.replace(2 + diff.start, 2 + diff.end, convertedNewNode.slice(diff.sliceStart, diff.sliceEnd));
+  }
+  return intTr;
+}

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

@@ -0,0 +1,4 @@
+import type { EditorState, Transaction } from "@tiptap/pm/state";
+export declare function convertTrForInstance(tr: Transaction, 
+/** We convert to the schema from this state. */
+otherState: EditorState): Transaction;

package/dist/runtime/pm/features/DocumentApi/utils/convertTrForInstance.js

@@ -0,0 +1,13 @@
+import { Step } from "@tiptap/pm/transform";
+import { copyMeta } from "./copyMeta.js";
+export function convertTrForInstance(tr, otherState) {
+  const extTr = otherState.tr;
+  copyMeta(tr, extTr);
+  const steps = JSON.parse(
+    JSON.stringify(tr.steps)
+  ).map((step) => Step.fromJSON(otherState.schema, step));
+  for (const step of steps) {
+    extTr.step(step);
+  }
+  return extTr;
+}

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

@@ -0,0 +1,2 @@
+import type { EditorState, Transaction } from "@tiptap/pm/state";
+export declare function convertTransactionForFullState(state: EditorState, tr: Transaction): Transaction;

package/dist/runtime/pm/features/DocumentApi/utils/convertTransactionForFullState.js

@@ -0,0 +1,22 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { Step, StepMap } from "@tiptap/pm/transform";
+import { copyMeta } from "./copyMeta.js";
+import { getStateEmbedRange } from "./getStateEmbedRange.js";
+export function convertTransactionForFullState(state, tr) {
+  const steps = tr.getMeta("no-schema-convert") ? tr.steps : JSON.parse(
+    JSON.stringify(tr.steps)
+  ).map((step) => Step.fromJSON(state.schema, step));
+  const extTr = state.tr;
+  copyMeta(tr, extTr);
+  const trSubId = tr.doc.nodeAt(1)?.attrs.blockId;
+  if (!trSubId && !tr.getMeta("no-step-convert")) {
+    unreachable();
+  }
+  const embedRange = trSubId ? getStateEmbedRange(tr.doc, trSubId) : void 0;
+  const offsetMap = embedRange && !tr.getMeta("no-step-convert") ? StepMap.offset(embedRange.start !== void 0 ? embedRange.start - 1 : 0) : void 0;
+  for (const step of steps) {
+    const mapped = offsetMap ? step.map(offsetMap) : step;
+    extTr.step(mapped);
+  }
+  return extTr;
+}

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

@@ -0,0 +1,2 @@
+import type { Transaction } from "@tiptap/pm/state";
+export declare function copyMeta(from: Transaction, to: Transaction): void;

package/dist/runtime/pm/features/DocumentApi/utils/copyMeta.js

@@ -0,0 +1,6 @@
+import { keys } from "@alanscodelog/utils/keys";
+export function copyMeta(from, to) {
+  for (const key of keys(from.meta)) {
+    to.setMeta(key, from.getMeta(key));
+  }
+}

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

@@ -0,0 +1 @@
+export declare function getEmbedJson(nodeWanted: Record<string, any> | undefined): Record<string, any> | undefined;

package/dist/runtime/pm/features/DocumentApi/utils/getEmbedJson.js

@@ -0,0 +1,14 @@
+export function getEmbedJson(nodeWanted) {
+  if (nodeWanted) {
+    return {
+      type: "doc",
+      content: [
+        {
+          type: "list",
+          content: [nodeWanted]
+        }
+      ]
+    };
+  }
+  return void 0;
+}

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

@@ -0,0 +1 @@
+export declare function getEmbedNodeFromDoc(json: Record<string, any>, subId: string | undefined): Record<string, any> | undefined;

package/dist/runtime/pm/features/DocumentApi/utils/getEmbedNodeFromDoc.js

@@ -0,0 +1,14 @@
+import { walk } from "@alanscodelog/utils/walk";
+export function getEmbedNodeFromDoc(json, subId) {
+  if (!subId) return;
+  let nodeWanted;
+  walk(json.content, (el) => {
+    if (!nodeWanted && el && el.type === "item") {
+      if (el.attrs.blockId === subId) {
+        nodeWanted = el;
+      }
+    }
+    return el;
+  }, { before: true });
+  return nodeWanted;
+}

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

@@ -0,0 +1,9 @@
+import type { Node } from "@tiptap/pm/model";
+import type { BlockId } from "../types.js";
+export declare function getStateEmbedRange(doc: Node, blockId: BlockId): {
+    start: number;
+    end: number;
+} | {
+    start: undefined;
+    end: undefined;
+};

package/dist/runtime/pm/features/DocumentApi/utils/getStateEmbedRange.js

@@ -0,0 +1,19 @@
+export function getStateEmbedRange(doc, blockId) {
+  const id = blockId.blockId;
+  let start;
+  let end;
+  doc.nodesBetween(0, doc.content.size, (node, pos) => {
+    if (start === void 0 && node.type.name === "item" && node.attrs.blockId === id) {
+      start = pos;
+      end = pos + node.nodeSize;
+      return false;
+    }
+    if (start !== void 0) return false;
+    return true;
+  });
+  if (start === void 0 || end === void 0) {
+    return { start: void 0, end: void 0 };
+  } else {
+    return { start, end };
+  }
+}

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

@@ -0,0 +1,2 @@
+import type { EmbedId, MaybeEmbedId } from "../types.js";
+export declare function isEmbedId(embedId: MaybeEmbedId): embedId is EmbedId;

package/dist/runtime/pm/features/DocumentApi/utils/isEmbedId.js

@@ -0,0 +1,3 @@
+export function isEmbedId(embedId) {
+  return embedId.docId !== void 0;
+}