@witchcraft/editor 0.0.1

package/src/runtime/pm/features/EmbeddedDocument/components/EmbeddedNodeView.vue

@@ -0,0 +1,187 @@
+<template>
+<!-- @vue-expect-error -->
+<node-view-wrapper
+	:class="`
+		group/embedded-doc
+		relative
+		after:pointer-events-none
+		after:content-['']
+		after:absolute after:inset-0
+		after:border after:border-neutral-500 after:rounded-sm
+		after:drop-shadow-xs
+		focus-within:after:border-accent-500
+		focus:after:border-accent-500
+	`"
+	tabindex="0"
+	v-bind="{
+		...node.attrs,
+		embedId: undefined,
+		embedDocId: node.attrs.embedId.docId,
+		embedBlockId: node.attrs.embedId.blockId
+	}"
+	@pointerdown="setEditorSelection"
+>
+	<div
+		class="text-sm relative"
+		contenteditable="false"
+	>
+		<div
+			class="bg-neutral-100 dark:bg-neutral-900 flex p-1 gap-2 no-wrap justify-between align-center"
+			contenteditable="false"
+		>
+			<div
+				v-if="name"
+				class="pl-1"
+			>
+				File: {{ name }}
+			</div>
+			<div
+				v-else
+				class="pl-1 text-center w-full"
+			>
+				Blank Embed
+			</div>
+			<!-- @vue-expect-error -->
+			<WButton
+				v-if="editor?.isEditable"
+				title="Change embed link."
+				:border="true"
+				@click="showChangeEmbed = true"
+			>
+				<WIcon><i-fa-solid-link class="w-[0.7rem]"/></WIcon>
+			</WButton>
+			<!-- @vue-expect-error -->
+			<WPopup
+				:use-backdrop="true"
+				:preferred-horizontal="['center-screen']"
+				:preferred-vertical="['center-screen']"
+				class="backdrop:bg-neutral-900/50 backdrop:dark:bg-neutral-100/50"
+				v-model="showChangeEmbed"
+			>
+				<template #popup="{	extractEl }">
+					<EmbeddedDocumentPicker
+						:is-shown="showChangeEmbed"
+						:embed-id="embedId"
+						v-extract-root-el="extractEl"
+						@submit="pickEmbed"
+						@cancel="showChangeEmbed = false"
+					/>
+				</template>
+				>
+			</WPopup>
+		</div>
+		<Transition>
+			<div
+				v-if="showUndoWarning"
+				class="absolute inset-0 bg-red-100 dark:bg-red-900 text-red-600 dark:text-red-400 px-2"
+				contenteditable="false"
+			>
+				Warning: Undo applied to document part that is not visible/embedded.
+			</div>
+		</Transition>
+	</div>
+
+	<div v-if="!name"/>
+	<div
+		v-else-if="isEmbeddedTooDeep"
+		class="px-2 text-center"
+		contenteditable="false"
+	>
+		Cannot preview nested content deeper than one level.
+	</div>
+	<div
+		v-else-if="isRecursivelyEmbedded"
+		class="px-2 text-center"
+		contenteditable="false"
+	>
+		Cannot preview recursively embedded content.
+	</div>
+
+	<template
+		v-else-if="content"
+	>
+		<component
+			:is-embedded="true"
+			:content="content"
+			:editor-options="editorOptions"
+			:is="editorComponent"
+			ref="editorWrapper"
+		/>
+	</template>
+	<div
+		v-else
+		class="px-2 text-center"
+	>
+		{{ isLoading ? "Loading..." : "Could not find reference to wanted block." }}
+	</div>
+</node-view-wrapper>
+</template>
+
+<script setup lang="ts">
+import { nodeViewProps, NodeViewWrapper } from "@tiptap/vue-3"
+import WIcon from "@witchcraft/ui/components/Icon"
+import WButton from "@witchcraft/ui/components/LibButton"
+import WPopup from "@witchcraft/ui/components/LibPopup"
+import { vExtractRootEl } from "@witchcraft/ui/directives/vExtractRootEl"
+import { computed, inject, ref, watch } from "vue"
+
+import EmbeddedDocumentPicker from "./EmbeddedDocumentPicker.vue"
+
+import IFaSolidLink from "~icons/fa-solid/link"
+
+import Editor from "../../../../components/Editor.vue"
+import type { MaybeEmbedId } from "../../DocumentApi/types.js"
+import { useEmbeddedEditor } from "../composables/useEmbeddedEditor.js"
+import { embeddedEditorComponentInjectionKey } from "../types.js"
+
+const props = defineProps(nodeViewProps)
+
+const editorComponent = inject(embeddedEditorComponentInjectionKey, Editor)
+const editorWrapper = ref<InstanceType<typeof Editor> | null>(null)
+// const el = ref<HTMLElement | null>(null)
+const innerEditor = computed(() => editorWrapper.value?.editor)
+
+const embedId = computed(() => props.node.attrs.embedId as MaybeEmbedId)
+const showChangeEmbed = ref(false)
+
+function pickEmbed(newEmbedId: MaybeEmbedId): void {
+	showChangeEmbed.value = false
+	props.updateAttributes({ ...props.node.attrs, embedId: { ...newEmbedId } })
+}
+
+function setEditorSelection(): void {
+	const pos = props.getPos()
+	if (props.editor.state.selection.from !== pos && pos) {
+		props.editor?.commands.setNodeSelection(pos)
+	}
+}
+
+function autoFocusOnSelection(): void {
+	if (props.editor.state.selection.from === props.getPos()
+		&& document.activeElement !== innerEditor.value?.view.dom
+	) {
+		innerEditor.value?.commands.focus()
+	}
+}
+
+watch([() => props.editor.state.selection.from, innerEditor], () => {
+	autoFocusOnSelection()
+})
+
+const {
+	content,
+	// api,
+	isEmbeddedTooDeep,
+	// isEmbeddedBlock,
+	isRecursivelyEmbedded,
+	showUndoWarning,
+	name,
+	isLoading,
+	editorOptions
+} = useEmbeddedEditor(
+	embedId,
+	innerEditor,
+	props.editor,
+	props.getPos
+)
+</script>

package/src/runtime/pm/features/EmbeddedDocument/composables/useEmbeddedEditor.ts

@@ -0,0 +1,302 @@
+import { castType } from "@alanscodelog/utils/castType"
+import type { Content, Editor, EditorOptions } from "@tiptap/core"
+import type { EditorState, Transaction } from "@tiptap/pm/state"
+import { computed, type ComputedRef, inject, onBeforeUnmount, onMounted, provide, type Ref, ref, type ShallowRef, watch } from "vue"
+
+import { getDiffReplacementRange } from "../../../utils/getDiffReplacementRange.js"
+import { type DocId, documentApiInjectionKey, type DocumentApiInterface, type EmbedId, type MaybeEmbedId, type OnUpdateDocumentCallback } from "../../DocumentApi/types.js"
+import { convertFullTransactionForPartialState } from "../../DocumentApi/utils/convertFullTransactionForPartialState.js"
+import { getStateEmbedRange } from "../../DocumentApi/utils/getStateEmbedRange.js"
+import { isEmbedId } from "../../DocumentApi/utils/isEmbedId.js"
+import { Embedded } from "../Embedded.js"
+import { embededEditorOptionsInjectionKey, isDeepEmbeddedInjectionKey, isEmbeddedBlockInjectionKey, isEmbeddedInjectionKey, parentEditorIdInjectionKey } from "../types.js"
+
+type WarningState = {
+	smallTimeout: number | undefined
+	timeout: number | undefined
+	justWarned: boolean
+}
+
+function defaultOnUndoWarning(
+	r: Ref<boolean>,
+	state: WarningState,
+	undoTimeouts: [number, number] = [50, 2000]
+): void {
+	clearTimeout(state.smallTimeout)
+	clearTimeout(state.timeout)
+	r.value = false
+	// the key is getting held
+	if (state.justWarned) {
+		r.value = true
+	}
+	state.justWarned = true
+
+	// makes it do a little flash
+	state.smallTimeout = setTimeout(() => {
+		state.justWarned = false
+		r.value = true
+		clearTimeout(state.timeout)
+		state.timeout = setTimeout(() => {
+			r.value = false
+		}, undoTimeouts[1]) as any as number
+	}, undoTimeouts[0]) as any as number
+}
+function defaultOnUndoOk(r: Ref<boolean>, state: WarningState): void {
+	clearTimeout(state.smallTimeout)
+	clearTimeout(state.timeout)
+	r.value = false
+}
+
+/** Sets up nearly everything for the embedded editor nodeview. */
+export function useEmbeddedEditor(
+	embedIdRef: ComputedRef<MaybeEmbedId> | Ref<MaybeEmbedId>,
+	/* The embedded editor instance. */
+	editor: ShallowRef<Editor | undefined>,
+	/* The root editor instance, for forwarding commands the embedded editor can't handle. See {@link Embedded}. */
+	rootEditor: Editor,
+	/** For forwarding commands the embedded editor can't handle. See {@link Embedded}. */
+	getPos: () => number | undefined,
+	{
+		undoTimeouts = [50, 2000],
+		selfSymbol = Symbol(`embedded-editor`),
+		onUndoWarning,
+		onUndoOk,
+		alwaysLoad = false,
+		injectIsEmbedded = true,
+		injectIsDeepEmbedded = true
+	}: {
+		/* The small and normal timeouts for the default undo warning functions. */
+		undoTimeouts?: [number, number]
+
+		/* This function will be called with the returned undoWarning ref when an undo would happen outside the embedded block.
+			*
+			* The default function will set the ref to false for 50ms (the small timeout), then true for 2000 (the normal timeout) so there is a brief flash with each undo. If it's called again before the 50ms, it will set the ref to true, so as to not flash when the undo key is held.
+			*/
+		onUndoWarning?: ((ref: Ref<boolean>) => void)
+		/* This function will be called with the returned undoWarning ref when an undo would happen inside the embedded block.
+			*
+			* The default function will set the ref to false and clear the timeouts of the default warning function.
+			* */
+		onUndoOk?: ((ref: Ref<boolean>) => void)
+		/* A symbol to identify the embedded node view instance by. */
+		selfSymbol?: symbol
+		/** By default, documents will not be loaded if they are embedded too deeply or recursively embedded. Passing true will ignore all checks and load them anyways. This also usually requires disabling the injections with the `injectIsEmbedded` and `injectIsDeepEmbedded` options. */
+		alwaysLoad?: boolean
+		/** By default, the composable injects the `isEmbedded*InjectionKey`s. Passing false will not inject them. */
+		injectIsEmbedded?: boolean
+		/** By default, the composable injects `isDeepEmbeddedInjectionKey` with true if it is false. Passing false will not inject it. */
+		injectIsDeepEmbedded?: boolean
+	} = {}
+): {
+	content: Ref<Content | null>
+	api: DocumentApiInterface
+	selfSymbol: symbol
+	isEmbeddedTooDeep: boolean
+	isEmbeddedBlock?: Ref<boolean>
+	isRecursivelyEmbedded: ComputedRef<boolean>
+	showUndoWarning: Ref<boolean>
+	/** If name is undefined, the embed is a new embed without a document id. */
+	name: ComputedRef<string | undefined>
+	isLoading: Ref<boolean>
+	/** The root editor needs to provide it's options so we can pass them to the embedded editor. If we don't, extra extensions (e.g. BaseShortcuts) and options won't be registered on the embedded editor. See the `embeddedEditorOptionsInjectionKey` for why `autofocus` is ommitted. */
+	editorOptions: Partial<Omit<EditorOptions, "autofocus">>
+} {
+	const showUndoWarning = ref(false)
+	const content = ref<Content | null>(null)
+	const api = inject(documentApiInjectionKey)
+	if (!api) {
+		throw new Error("No embed api provided.")
+	}
+
+	const editorOptions = inject(embededEditorOptionsInjectionKey)
+	if (!editorOptions) {
+		throw new Error("No editor options provided.")
+	}
+	editorOptions.extensions = [
+		...(editorOptions.extensions ?? []).filter(ext => ext.name !== Embedded.name),
+		Embedded.configure({
+			rootEditor,
+			getPos,
+			getEmbedId: () => embedIdRef.value
+		})
+	]
+
+	const isEmbeddedTooDeep = inject(isDeepEmbeddedInjectionKey, false)
+	if (injectIsDeepEmbedded && !isEmbeddedTooDeep) {
+		provide(isDeepEmbeddedInjectionKey, true)
+	}
+	const isEmbeddedBlock = computed(() => !!embedIdRef.value.blockId)
+	if (injectIsEmbedded) {
+		provide(isEmbeddedInjectionKey, true)
+		provide(isEmbeddedBlockInjectionKey, isEmbeddedBlock)
+	}
+
+	const parentId = inject(parentEditorIdInjectionKey, undefined)
+	const isRecursivelyEmbedded = computed(() => parentId?.value === embedIdRef.value.docId)
+
+	const isLoading = ref(false)
+
+	const name = computed(() => isEmbedId(embedIdRef.value) ? api.getEmbedTitle(embedIdRef.value) : undefined)
+
+	const warningState: WarningState = {
+		smallTimeout: undefined,
+		timeout: undefined,
+		justWarned: false
+	}
+	function forwardDispatchToFullState(tr?: Transaction): void {
+		castType<EmbedId>(embedIdRef.value)
+		const stateBefore = api!.getFromCache(embedIdRef.value)
+		if (!stateBefore) {
+			throw new Error("Expected stateBefore to exist.")
+		}
+		if (!tr) return
+		const diff = getDiffReplacementRange(stateBefore.doc, tr.doc)
+		const { start, end } = getStateEmbedRange(tr.doc, embedIdRef.value)
+		if (diff && end !== undefined && start !== undefined
+			&& (diff.start < start || diff.end > end)
+		) {
+			onUndoWarning
+				? onUndoWarning(showUndoWarning)
+				: defaultOnUndoWarning(showUndoWarning, warningState, undoTimeouts)
+		} else {
+			onUndoOk
+				? onUndoOk(showUndoWarning)
+				: defaultOnUndoOk(showUndoWarning, warningState)
+		}
+		// forwarded transactions bypass the on transaction hook
+		// so we set ignore to false
+		// and don't pass our symbol here
+		// so we can receive the transaction and update the embedded document
+		// we also don't convert the transaction's steps
+		tr.setMeta("no-step-convert", true)
+		tr.setMeta("no-schema-convert", true)
+		if (!embedIdRef.value.blockId) {
+			tr.setMeta("no-step-convert", true)
+		}
+		api!.updateDocument?.(
+			embedIdRef.value,
+			tr,
+			undefined
+		)
+	}
+	function onTransaction({ transaction }: { transaction: Transaction }): void {
+		castType<EmbedId>(embedIdRef.value)
+		if (!transaction.docChanged || transaction.getMeta("ignore")) {
+			return
+		}
+		if (!embedIdRef.value.blockId) {
+			transaction.setMeta("no-step-convert", true)
+		}
+		api!.updateDocument?.(
+			embedIdRef.value,
+			transaction,
+			selfSymbol
+		)
+	}
+
+	const onUpdateDocument: OnUpdateDocumentCallback = (
+		incomingEmbedId: DocId,
+		tr: Transaction,
+		_stateBefore: EditorState,
+		_incomingState: EditorState,
+		incomingSelfSymbol?: symbol
+	): void => {
+		castType<EmbedId>(embedIdRef.value)
+		if (
+			incomingSelfSymbol === selfSymbol
+			|| embedIdRef.value.docId !== incomingEmbedId.docId
+			|| !tr.docChanged
+			|| tr.getMeta("ignore")
+		) {
+			return
+		}
+		if (content.value) {
+			const convertedTr = convertFullTransactionForPartialState(
+				editor.value!.state!,
+				tr,
+				embedIdRef.value
+			)
+			if (convertedTr) {
+				if (!convertedTr.before.eq(editor.value!.state.doc)) {
+					return
+				}
+				editor.value!.view.dispatch(convertedTr)
+			} else {
+				// the link got broken, the node was deleted
+				unloadDocument(embedIdRef.value, { partial: true })
+			}
+		} else {
+			void loadDocument(embedIdRef.value, { partial: true })
+		}
+	}
+	let attached = false
+	async function loadDocument(embedId: MaybeEmbedId, { partial = false }: { partial?: boolean } = {}): Promise<void> {
+		if (!isEmbedId(embedId)) return
+		if (!alwaysLoad && (isRecursivelyEmbedded.value || isEmbeddedTooDeep)) return
+		if (!partial) {
+			isLoading.value = true
+			await api!.load(embedId)
+		}
+		const res = api!.getEmbeddedContent?.(embedId)
+		if (!res) return
+		if (!partial) {
+			api!.addEventListener?.("update", onUpdateDocument)
+		}
+		content.value = res
+
+		watch(editor, () => {
+			// void nextTick(() => {
+			// this needs to be set if the document changes
+			// because the editor gets unmounted and
+			// a new version of the extension
+			// without the callbacks is created
+			editor.value!.commands.setHistoryRedirect(
+				() => api!.getFromCache(embedId),
+				forwardDispatchToFullState
+			)
+			// wait for the editor to exist
+			editor.value?.on("transaction", onTransaction)
+			isLoading.value = false
+			attached = true
+		}, { once: true })
+	}
+	function unloadDocument(embedId: MaybeEmbedId, { partial = false }: { partial?: boolean } = {}): void {
+		if (!isEmbedId(embedId)) return
+		if (!alwaysLoad && (isRecursivelyEmbedded.value || isEmbeddedTooDeep)) return
+		editor.value?.off("transaction", onTransaction)
+		if (!partial && attached) {
+			api!.removeEventListener?.("update", onUpdateDocument)
+			api!.unload(embedId)
+			attached = false
+		}
+		// the extension is destroyed when the editor is unmounted
+		editor.value?.commands.setHistoryRedirect(undefined, undefined)
+		content.value = null
+	}
+
+	watch(embedIdRef, (newVal, oldVal) => {
+		if (newVal.docId !== oldVal.docId || newVal.blockId !== oldVal.blockId) {
+			unloadDocument(oldVal)
+			void loadDocument(newVal)
+		}
+	})
+
+	onMounted(async () => {
+		await loadDocument(embedIdRef.value)
+	})
+	onBeforeUnmount(() => {
+		unloadDocument(embedIdRef.value)
+	})
+	return {
+		content,
+		api,
+		selfSymbol,
+		isEmbeddedTooDeep,
+		isEmbeddedBlock,
+		isRecursivelyEmbedded,
+		showUndoWarning,
+		name,
+		isLoading,
+		editorOptions
+	}
+}

package/src/runtime/pm/features/EmbeddedDocument/types.ts

@@ -0,0 +1,61 @@
+import type { Dispatch, Editor, EditorOptions } from "@tiptap/core"
+import type { ComputedRef, InjectionKey, Ref } from "vue"
+
+import type { MaybeEmbedId } from "../DocumentApi/types.js"
+
+export interface EmbeddedDocumentNodeOptions extends WithOnTriggerByEmbeddedBlockOptions {
+	rootEditor: Editor
+	/** Provided by the embedded node view. */
+	getPos: () => number | undefined
+	getEmbedId: () => MaybeEmbedId
+}
+
+/** Tells the editor and embedded doc view whether it's deeply embedded (more than one level) or not. */
+export const isDeepEmbeddedInjectionKey = Symbol("isEmbeddedInjectionKey") as InjectionKey<boolean>
+/** Tells the editor and embedded doc view whether it's embedded or not. */
+export const isEmbeddedInjectionKey = Symbol("isEmbeddedInjectionKey") as InjectionKey<boolean>
+
+/* Tells the editor whether it's a single block embed so it can set the right class on the wrapper. See {@link isEmbeddedBlock}. */
+export const isEmbeddedBlockInjectionKey = Symbol("isEmbeddedBlockInjectionKey") as InjectionKey<ComputedRef<boolean> | Ref<boolean>>
+
+/** Injects the editor component to use for embedded editors. */
+export const embeddedEditorComponentInjectionKey = Symbol("embeddedEditorComponentInjectionKey") as InjectionKey<new (...args: any) => { editor?: Editor }>
+
+/** Injects the parent editor id so the embedded editor can know who is embedding it (to track recursive/disallowed embeds). */
+export const parentEditorIdInjectionKey = Symbol("parentEditorIdInjectionKey") as InjectionKey<Ref<string | undefined>>
+
+/**
+	* Injects the editor options so the embedded editor can use the same ones as it's parent.
+	*
+	* Note that autofocus is always disabled for embedded editors, hence it's omission.
+	*/
+export const embededEditorOptionsInjectionKey = Symbol("embededEditorOptionsInjectionKey") as InjectionKey<Partial<Omit<EditorOptions, "autofocus">>>
+
+export type WithOnTriggerByEmbeddedBlockOptions = {
+	/**
+	 * When the editor is embedded and it's embedding a single block, certain commands are nullified and just return true and do nothing because they would break the embedding (e.g. enter, split, indent, etc).
+	 *
+	 * All such commands forward to the `embeddedCommandRedirect` command if it's available (otherwise a warning is logged). The `Embedded` extension takes care of registering this redirect and can redirect some of the commands to the root editor, but not all of them.
+	 *
+	 * You can use this function to handle the redirection yourself. You will get passed both editor instances (root and embedded) to facilitate communication. If you can handle the command, you should return a boolean as with a regular command. Otherwise you can return undefined to let the default handler take care of it.
+	 *
+	 * Note that if the change moves the node, the component will get remounted and the embedded editor will no longer exist (to, for example, focus it).
+	 *
+	 * The included EmbeddedNodeView takes care of auto-focusing when the selection matches it's position. So as a workaround for focus at least, you can use `tr.setNodeSelection(nodePos + offset)`. Note the use of `offset`. The node's position will have probably changed depending on the command so you will need to know how much to offset it or have some way to find it's position again. While the embedId is provided, it's not guaranteed there is only one node embedding that id, there might be multiple. A better way is to first find the parent embedding item id before executing your command, note the `blockId`, then use it to find the node again.
+	 *
+	 * See {@link redirectFromEmbedded} for creating redirectable commands.
+	 */
+	embeddedBlockCommandRedirect?: (
+		commandName: string,
+		args: any,
+		context: {
+			editor: Editor
+			rootEditor: Editor
+			nodePos: number | undefined
+			embedId: MaybeEmbedId
+			dispatch: Dispatch
+		}
+	) => boolean | undefined
+}
+
+export type OnTriggerByEmbeddedBlock = WithOnTriggerByEmbeddedBlockOptions["embeddedBlockCommandRedirect"]

package/src/runtime/pm/features/EmbeddedDocument/utils/isEmbeddedBlock.ts

@@ -0,0 +1,12 @@
+import type { EditorView } from "@tiptap/pm/view"
+
+/**
+	* Returns whether the current view is a block embed embedded in another view.
+	*
+	* This is done by checking if the immediate parent has the class `editor-is-embedded-block` which the editor component adds when it receives the {@link isEmbeddedBlockInjectionKey} injection key.
+	*
+	* We cannot do this via state since a document can be both embedded and not embedded at the same time.
+	*/
+export function isEmbeddedBlock(view: EditorView): boolean {
+	return view.dom.parentElement?.classList.contains("editor-is-embedded-block") ?? false
+}

package/src/runtime/pm/features/EmbeddedDocument/utils/redirectFromEmbedded.ts

@@ -0,0 +1,48 @@
+import type { SingleCommands } from "@tiptap/core"
+import type { EditorView } from "@tiptap/pm/view"
+
+import { isEmbeddedBlock } from "./isEmbeddedBlock.js"
+
+/**
+ * Commands that can split a block or modify it's position (indent/unindent) should not be called when the editor is in embedded block mode.
+ *
+ * This takes care of redirecting the command if possible (see {@link WithOnTriggerByEmbeddedBlockOptions.onTriggerByEmbeddedBlock}), otherwise it logs a warning.
+ *
+ * If the command should not be called at all and offers no redirect, don't pass the redirect parameter and it will log a different warning.
+ *
+ * You can use it in a command like this:
+ *
+ * ```ts
+ * commandName: (arg:any) => ({ commands, view, dispatch  }) => {
+ *		const redirect = isEmbeddedBlock(view, "commandName", { args:[arg], view, commands, dispatch }))
+ * 	if (redirect.redirected) { return redirect.result }
+ * }
+ *  ```
+ */
+export function redirectFromEmbedded(
+	view: EditorView,
+	name: string,
+	redirect?: {
+		args: any[]
+		view: EditorView
+		commands: SingleCommands
+	}
+): { redirected: true, result: any } | { redirected: false } {
+	if (isEmbeddedBlock(view)) {
+		if (redirect && "embeddedCommandRedirect" in redirect.commands) {
+			const result = redirect.commands.embeddedCommandRedirect(
+				name,
+				redirect.args
+			)
+			return { redirected: true, result }
+		}
+
+		// eslint-disable-next-line no-console
+		console.warn(redirect
+			? `Command ${name} called from an embedded editor. This command supports command redirection, but no "embeddedCommandRedirect" command found. Command ignored (returning true to prevent further action).`
+			: `Command ${name} should not be called from an embedded editor. Command ignored (returning true to prevent further action).`
+		)
+		return { redirected: true, result: true }
+	}
+	return { redirected: false }
+}