@bloklabs/vue 1.16.1 → 2.1.0

package/src/BlockPortalHost.ts

@@ -1,46 +0,0 @@
-// src/vue/BlockPortalHost.ts
-import { defineComponent, h, Teleport, Fragment, onErrorCaptured, type PropType } from 'vue';
-
-import type { BlockPortalRegistry } from './block-portal-registry';
-
-/**
- * Wraps a single block's render so a throw inside it can't tear down the whole
- * editor's render tree. `onErrorCaptured` returning false stops propagation.
- * Authored as a render function (no `.vue` SFC) per the adapter invariant.
- */
-const BlockErrorBoundary = defineComponent({
-  name: 'BlockErrorBoundary',
-  setup(_props, { slots }) {
-    onErrorCaptured(() => false);
-
-    return () => slots.default?.();
-  },
-});
-
-/**
- * The single shared render tree that teleports each registered Vue block into
- * its Blok-owned host element. Mounted once per editor (by `BlokContent`), it
- * iterates the reactive registry and emits one `<Teleport>` per entry — so all
- * blocks share one reconciler and the surrounding app's provide/inject context
- * (Teleport preserves the component render context, not the DOM target's).
- */
-export const BlockPortalHost = defineComponent({
-  name: 'BlockPortalHost',
-  props: {
-    registry: { type: Object as PropType<BlockPortalRegistry>, required: true },
-  },
-  setup(props) {
-    return () =>
-      h(
-        Fragment,
-        // Iterating the reactive Map tracks it, so register/unregister re-renders.
-        Array.from(props.registry.entries.entries()).map(([id, entry]) =>
-          h(Teleport, { key: id, to: entry.hostEl }, [
-            h(BlockErrorBoundary, null, {
-              default: () => h(entry.component, entry.props),
-            }),
-          ])
-        )
-      );
-  },
-});

package/src/BlokContent.ts

@@ -1,103 +0,0 @@
-import {
-  computed,
-  defineComponent,
-  h,
-  onMounted,
-  onBeforeUnmount,
-  provide,
-  ref,
-  toRaw,
-  watch,
-  type PropType,
-} from 'vue';
-import { getHolder } from './holder-map';
-import { getRegistry } from './registry-map';
-import { BlockPortalHost } from './BlockPortalHost';
-import { BLOK_EDITOR_INSTANCE } from './blok-instance';
-import type { Blok } from '@/types';
-
-/**
- * Provides the DOM mount point for a Blok editor. Renders a `<div>` and adopts
- * the editor's detached holder element into it (the Vue analog of React's
- * `BlokContent`). When `editor` is null it renders an empty div for layout
- * stability. The holder subtree is owned entirely by core — Vue's renderer never
- * manages its children, so the container is always rendered with no vnode
- * children and the holder is appended/removed imperatively.
- *
- * `toRaw` unwraps the editor before the holder-map lookup: Vue stores the object
- * prop behind a reactive proxy, and the holder WeakMap is keyed by the raw Blok
- * instance (Risk R0 — Vue proxies must never be used as identity keys).
- */
-export const BlokContent = defineComponent({
-  name: 'BlokContent',
-  props: {
-    editor: {
-      type: Object as PropType<Blok | null>,
-      default: null,
-    },
-  },
-  setup(props) {
-    const container = ref<HTMLDivElement | null>(null);
-
-    // Publish the live instance to everything rendered beneath — including every
-    // `createVueBlock` block, because <Teleport> preserves the COMPONENT render
-    // context. That is what lets a block call `useBlocks(useBlokInstance())`
-    // without the host prop-drilling the instance into it. `toRaw` for the same
-    // reason the holder lookup uses it (Risk R0): the prop may arrive behind a
-    // reactive proxy, and consumers compare the instance BY IDENTITY.
-    provide(
-      BLOK_EDITOR_INSTANCE,
-      computed(() => (props.editor === null ? null : toRaw(props.editor)))
-    );
-
-    const adopt = (editor: Blok | null): void => {
-      if (container.value === null || editor === null) {
-        return;
-      }
-
-      const holder = getHolder(toRaw(editor));
-
-      if (holder === undefined) {
-        return;
-      }
-
-      container.value.appendChild(holder);
-    };
-
-    const detach = (editor: Blok | null): void => {
-      if (editor === null) {
-        return;
-      }
-
-      getHolder(toRaw(editor))?.remove();
-    };
-
-    onMounted(() => {
-      adopt(props.editor);
-    });
-
-    watch(
-      () => props.editor,
-      (next, previous) => {
-        detach(previous ?? null);
-        adopt(next);
-      }
-    );
-
-    onBeforeUnmount(() => {
-      detach(props.editor);
-    });
-
-    return () => {
-      const editorVal = props.editor;
-      // The shared portal host for `createVueBlock` tools (when this editor has
-      // one). It emits ONLY <Teleport> anchors — no real DOM in the container —
-      // so the imperatively-appended holder is undisturbed and the container
-      // stays a single root for attribute fallthrough. Registry-less editors
-      // (vanilla-only) render the bare div exactly as before.
-      const registry = editorVal === null ? undefined : getRegistry(toRaw(editorVal));
-
-      return h('div', { ref: container }, registry === undefined ? [] : [h(BlockPortalHost, { registry })]);
-    };
-  },
-});

package/src/BlokEditor.ts

@@ -1,326 +0,0 @@
-import { computed, defineComponent, getCurrentInstance, h, onUpdated, ref, watch, type PropType } from 'vue';
-import { useBlok } from './useBlok';
-import { BlokContent } from './BlokContent';
-import { getContentBaseline } from './content-baseline-map';
-import { BLOK_EDITOR_CONFIG_KEYS } from './config-keys';
-import type {
-  API,
-  BlockMutationEvent,
-  BlokConfig,
-  EditorWidth,
-  OutputData,
-  ResolvedTheme,
-  ThemeMode,
-} from '@/types';
-import type { UseBlokConfig } from './types';
-
-/**
- * Calls emit-mapped listeners read from a vnode's props. Vue stores one as a
- * function, or as an array when several are bound to the same event.
- * @param vnodeProps - the component vnode's props
- * @param keys - listener keys, e.g. `onSave`
- * @param data - the payload
- */
-const callVnodeListeners = (vnodeProps: Record<string, unknown> | null, keys: string[], data: OutputData): void => {
-  const listeners: unknown[] = keys.flatMap((key) => vnodeProps?.[key] ?? []);
-
-  for (const listener of listeners) {
-    if (typeof listener === 'function') {
-      (listener as (payload: OutputData) => void)(data);
-    }
-  }
-};
-
-/**
- * The blessed all-in-one component for embedding Blok in Vue. Wires `useBlok`
- * and `BlokContent`, maps Vue emits onto the core config callbacks (gated on
- * listener presence, since their mere presence makes core do extra work), and
- * threads the return-valued transform hooks through.
- *
- * Every declared prop is removed from `$attrs`, so any extra attribute
- * (`id`/`class`/`aria-*`/`data-*`) falls through to the editor container.
- */
-export const BlokEditor = defineComponent({
-  name: 'BlokEditor',
-  // Bind fallthrough attrs explicitly onto the container (below) instead of
-  // relying on implicit double-fallthrough through BlokContent.
-  inheritAttrs: false,
-  // Reactive config + seed props. `default: undefined` on the boolean props keeps
-  // an unset prop `undefined` (Vue otherwise coerces absent Boolean props to
-  // false), so `provideBlok` defaults can apply and core can coerce.
-  props: {
-    autofocus: { type: Boolean as PropType<boolean | undefined>, default: undefined },
-    defaultBlock: { type: String, default: undefined },
-    dataModel: { type: String as PropType<BlokConfig['dataModel']>, default: undefined },
-    placeholder: { type: [String, Boolean] as PropType<string | false>, default: undefined },
-    sanitizer: { type: Object as PropType<BlokConfig['sanitizer']>, default: undefined },
-    hideToolbar: { type: Boolean as PropType<boolean | undefined>, default: undefined },
-    toolbarPosition: { type: String as PropType<BlokConfig['toolbarPosition']>, default: undefined },
-    maxHistoryLength: { type: Number, default: undefined },
-    historyDebounceTime: { type: Number, default: undefined },
-    newGroupDelay: { type: Number, default: undefined },
-    globalUndoRedo: { type: Boolean as PropType<boolean | undefined>, default: undefined },
-    tools: { type: Object as PropType<BlokConfig['tools']>, default: undefined },
-    data: { type: Object as PropType<OutputData>, default: undefined },
-    minHeight: { type: Number, default: undefined },
-    loader: { type: [Boolean, Object] as PropType<BlokConfig['loader']>, default: undefined },
-    logLevel: { type: String as PropType<BlokConfig['logLevel']>, default: undefined },
-    // [Boolean, Object]: the object form ({ hideControls }) must not be dropped
-    // or dev-warned — it always means read-only enabled (reactive contract).
-    readOnly: { type: [Boolean, Object] as PropType<BlokConfig['readOnly']>, default: undefined },
-    i18n: { type: Object as PropType<BlokConfig['i18n']>, default: undefined },
-    link: { type: Object as PropType<BlokConfig['link']>, default: undefined },
-    linkPaste: { type: Object as PropType<BlokConfig['linkPaste']>, default: undefined },
-    inlineToolbar: { type: [Array, Boolean] as PropType<string[] | boolean>, default: undefined },
-    inlineEmoji: { type: Boolean as PropType<boolean | undefined>, default: undefined },
-    find: { type: [Boolean, Object] as PropType<BlokConfig['find']>, default: undefined },
-    tunes: { type: Array as PropType<string[]>, default: undefined },
-    style: { type: Object as PropType<BlokConfig['style']>, default: undefined },
-    theme: { type: String as PropType<ThemeMode>, default: undefined },
-    scrollToBlock: { type: Object as PropType<BlokConfig['scrollToBlock']>, default: undefined },
-    user: { type: Object as PropType<BlokConfig['user']>, default: undefined },
-    resolveUser: { type: Function as PropType<BlokConfig['resolveUser']>, default: undefined },
-    notifierPosition: { type: String as PropType<BlokConfig['notifierPosition']>, default: undefined },
-    notifier: { type: Function as PropType<BlokConfig['notifier']>, default: undefined },
-    width: { type: String as PropType<EditorWidth>, default: undefined },
-    onBeforeRender: { type: Function as PropType<BlokConfig['onBeforeRender']>, default: undefined },
-    onBeforePaste: { type: Function as PropType<BlokConfig['onBeforePaste']>, default: undefined },
-    // Return-valued hook (the boolean is the "handled" signal), so it is a
-    // declared prop copied into the config — not an emit-mapped callback.
-    onEnter: { type: Function as PropType<BlokConfig['onEnter']>, default: undefined },
-    // Fire-and-forget submit hook (Enter-to-send) — a declared prop copied into
-    // config, delivering the serialized document.
-    onSubmit: { type: Function as PropType<BlokConfig['onSubmit']>, default: undefined },
-    // Fire-and-forget error channel — a plain declared prop copied into config.
-    onError: { type: Function as PropType<BlokConfig['onError']>, default: undefined },
-    onImageFailure: { type: Function as PropType<BlokConfig['onImageFailure']>, default: undefined },
-    /** Host-supplied per-type block migrations applied at load. */
-    migrations: { type: Object as PropType<BlokConfig['migrations']>, default: undefined },
-    /** Editor-level uploader, routed by asset kind (images, video, audio, files). */
-    uploader: { type: Object as PropType<BlokConfig['uploader']>, default: undefined },
-    /** Convert uploaded photos and videos into several formats, rendered best-first. */
-    media: { type: Object as PropType<BlokConfig['media']>, default: undefined },
-    /** Base URL of a service speaking Blok's upload and unfurl contracts. */
-    server: { type: String as PropType<BlokConfig['server']>, default: undefined },
-    /** Endpoint in your app that mints a short-lived access pass for the current user. */
-    ticket: { type: String as PropType<BlokConfig['ticket']>, default: undefined },
-    /** Load on mount and save on change, against your own endpoint. */
-    persistence: { type: Object as PropType<BlokConfig['persistence']>, default: undefined },
-    /** Real-time multiplayer against the server's sync service. Mutually exclusive with persistence. */
-    collaboration: { type: Object as PropType<BlokConfig['collaboration']>, default: undefined },
-    /** Your app's id for this document; tabs showing the same id stay in sync. Mount-fixed. */
-    documentId: { type: String as PropType<BlokConfig['documentId']>, default: undefined },
-    /** Live sync between tabs of this browser. On by default. */
-    tabSync: { type: [Boolean, Object] as PropType<BlokConfig['tabSync']>, default: undefined },
-    /** Opt-in: clicks on the host page below the editor append a block. */
-    captureClicksBelowEditor: { type: Boolean as PropType<boolean | undefined>, default: undefined },
-    /** Changing this prop's identity destroys and recreates the editor. */
-    recreateKey: { type: null as unknown as PropType<unknown> },
-  },
-  emits: {
-    ready: (_instance: unknown): boolean => true,
-    change: (_payload: { api: API; event: BlockMutationEvent | BlockMutationEvent[] }): boolean => true,
-    save: (_data: OutputData): boolean => true,
-    'update:data': (_data: OutputData): boolean => true,
-    'after-render': (_api: API): boolean => true,
-    'theme-change': (_theme: ResolvedTheme): boolean => true,
-    'blocks-rendered': (_payload: unknown): boolean => true,
-    'block-rendered': (_payload: unknown): boolean => true,
-  },
-  setup(props, { emit, expose, attrs }) {
-    const instance = getCurrentInstance();
-
-    /**
-     * The `onXxx` keys currently on the component's vnode, as a sorted, stable
-     * string. Emit-mapped listeners (`@change`, `@save`, `v-model:data`,
-     * `@after-render`, …) are not declared props, so `vnode.props` is the only
-     * place they exist.
-     */
-    const readListenerKeys = (): string => {
-      const vnodeProps = instance?.vnode.props;
-
-      if (vnodeProps == null) {
-        return '';
-      }
-
-      return Object.keys(vnodeProps)
-        .filter((key) => key.startsWith('on'))
-        .sort()
-        .join('|');
-    };
-
-    /**
-     * Reactive mirror of `readListenerKeys()`. `vnode.props` is a plain object
-     * Vue swaps out on each patch — reading it tracks nothing, so a host that
-     * added or removed a listener WITHOUT also changing a reactive prop never
-     * re-ran the config snapshot and the flip was silently lost (core reads
-     * callback PRESENCE as intent: `onSave` arms the change pipeline).
-     *
-     * This ref is the missing reactive source. It is READ by `hasListener` (so
-     * every watcher that snapshots the config depends on it) and WRITTEN only
-     * from `onUpdated` — never from the snapshot itself, which would make the
-     * read its own write and self-trigger an endless update loop. Storing the
-     * key set rather than a counter makes "bump only on a genuine presence
-     * change" structural: re-assigning an equal string is inert.
-     *
-     * One case stays out of reach, and it is Vue's, not the ref's:
-     * `hasPropsChanged` skips keys that name a declared emit, so REPLACING one
-     * emit listener with a different one while the vnode's prop count and every
-     * other prop stay identical (`@change` out, `@save` in, nothing else moving)
-     * skips the child update entirely — no hook fires anywhere. Anything that
-     * also changes the prop count, including plain add/remove, updates.
-     */
-    const listenerKeys = ref(readListenerKeys());
-
-    onUpdated(() => {
-      listenerKeys.value = readListenerKeys();
-    });
-
-    /** Listener presence (the Vue analog of Angular's `output.observed`). */
-    const hasListener = (handlerKey: string): boolean =>
-      listenerKeys.value.split('|').includes(handlerKey);
-
-    /**
-     * Snapshot the props + gated emit-callbacks into a `UseBlokConfig`. App-wide
-     * `provideBlok` defaults are merged in by `useBlok` (the lifecycle engine),
-     * so this component stays thin and the escape-hatch path honors defaults too
-     * — mirroring React, where only `useBlok` merges.
-     */
-    const buildConfig = (): UseBlokConfig => {
-      const config: Record<string, unknown> = {};
-
-      for (const key of BLOK_EDITOR_CONFIG_KEYS) {
-        const value = props[key];
-
-        if (value !== undefined) {
-          config[key] = value;
-        }
-      }
-
-      if (hasListener('onChange')) {
-        config.onChange = (api: API, event: BlockMutationEvent | BlockMutationEvent[]): void => {
-          emit('change', { api, event });
-        };
-      }
-
-      // onSave makes core serialize on every change batch — wire it only when a
-      // v-model:data binding or an explicit @save listener consumes it.
-      if (hasListener('onSave') || hasListener('onUpdate:data')) {
-        config.onSave = (data: OutputData): void => {
-          // Vue drops emits once unmounted, but destroy()'s final save lands
-          // after that, so call the listeners straight from the vnode.
-          if (instance?.isUnmounted === true) {
-            callVnodeListeners(instance.vnode.props, ['onUpdate:data', 'onSave'], data);
-
-            return;
-          }
-
-          emit('update:data', data);
-          emit('save', data);
-        };
-      }
-
-      if (hasListener('onAfterRender')) {
-        config.onAfterRender = (api: API): void => {
-          emit('after-render', api);
-        };
-      }
-
-      if (hasListener('onThemeChange')) {
-        config.onThemeChange = (resolved: ResolvedTheme): void => {
-          emit('theme-change', resolved);
-        };
-      }
-
-      return config;
-    };
-
-    const editor = useBlok(
-      () => buildConfig(),
-      () => props.recreateKey
-    );
-
-    // Subscribe to the editor's rendered-lifecycle events once it exists (gated
-    // on the emits being listened). `onCleanup` unsubscribes when the instance is
-    // replaced or the component unmounts. `listenerKeys` is a source too, so a
-    // listener added after mount subscribes instead of waiting for a recreate —
-    // presence is re-read from scratch each run, and the cleanup keeps the
-    // subscriptions balanced.
-    watch([editor, listenerKeys], ([ed], _previous, onCleanup) => {
-      if (ed === null) {
-        return;
-      }
-
-      const subscriptions: Array<[string, (payload?: unknown) => void]> = [];
-
-      if (hasListener('onBlocksRendered')) {
-        const handler = (payload?: unknown): void => emit('blocks-rendered', payload);
-
-        ed.on('blocks:rendered', handler);
-        subscriptions.push(['blocks:rendered', handler]);
-      }
-
-      if (hasListener('onBlockRendered')) {
-        const handler = (payload?: unknown): void => emit('block-rendered', payload);
-
-        ed.on('block:rendered', handler);
-        subscriptions.push(['block:rendered', handler]);
-      }
-
-      onCleanup(() => {
-        for (const [name, handler] of subscriptions) {
-          ed.off(name, handler);
-        }
-      });
-    });
-
-    // Emit `ready` once per editor, after the instance is published to the ref
-    // (and to `expose` below), so a consumer reading the instance inside the
-    // handler — or via a template ref — sees the live editor. The last-emitted
-    // instance is held in an object to avoid `let` reassignment.
-    const readyState: { last: typeof editor.value } = { last: null };
-
-    watch(editor, (ed) => {
-      if (ed !== null && ed !== readyState.last) {
-        readyState.last = ed;
-        emit('ready', ed);
-      }
-    });
-
-    // Curated imperative facade (delegates to the live instance; no-ops until
-    // ready). `instance` is live (null before ready, the Blok after).
-    expose({
-      instance: computed(() => editor.value),
-      save: (): ReturnType<NonNullable<typeof editor.value>['save']> | undefined => editor.value?.save(),
-      confirmLeave: (): Promise<boolean> => editor.value?.confirmLeave() ?? Promise.resolve(true),
-      focus: (atEnd?: boolean): void => {
-        editor.value?.focus(atEnd);
-      },
-      /**
-       * Replace the editor content.
-       *
-       * Safe to mix with a controlled `data` prop: the rendered document
-       * becomes the adapter's content baseline once the call lands, so a later
-       * `data` change back to the previous document still re-renders instead of
-       * being deduped against a baseline the editor no longer reflects.
-       * Recorded only on the RESOLVED path — a failed render leaves the editor
-       * on its previous content, and a baseline naming content it never showed
-       * would dedupe away the correcting update.
-       * @param data - the document to render
-       */
-      render: (data: OutputData): Promise<void> | undefined => {
-        const ed = editor.value;
-
-        if (ed === null) {
-          return undefined;
-        }
-
-        return ed.render(data).then(() => {
-          getContentBaseline(ed)?.markRendered(data);
-        });
-      },
-    });
-
-    return () => h(BlokContent, { editor: editor.value, ...attrs });
-  },
-});

package/src/block-portal-registry.ts

@@ -1,93 +0,0 @@
-// src/vue/block-portal-registry.ts
-import { markRaw, reactive, type Component } from 'vue';
-
-/**
- * Tool-config key carrying the editor's portal registry into a `createVueBlock`
- * tool. The tool is constructed by CORE (outside any Vue `setup`), so it cannot
- * `inject()` — `useBlok` injects the editor-scoped registry through each
- * vue-block tool's `config`, and the tool reads it here.
- */
-export const BLOK_PORTAL_REGISTRY_CONFIG_KEY = '__blokPortalRegistry';
-
-/**
- * One mounted Vue block in the portal registry. `hostEl` is the Blok-owned
- * `toolRenderedElement` (tagged `data-blok-mutation-free`) the component is
- * teleported into; `props` is a REACTIVE object so `setProps` updates the
- * rendered block in place (no remount).
- */
-export interface BlockPortalEntry {
-  hostEl: HTMLElement;
-  component: Component;
-  props: Record<string, unknown>;
-}
-
-/**
- * Per-editor registry of Vue blocks. A single shared {@link BlockPortalHost}
- * renders one `<Teleport>` per entry, so every block lives in ONE render tree
- * (shared provide/inject + app plugins, one effect scope) — the TipTap
- * `VueNodeViewRenderer` pattern, not a Vue app per block.
- */
-export interface BlockPortalRegistry {
-  /** Reactive set of entries the host iterates (keyed by block id). */
-  readonly entries: ReadonlyMap<string, BlockPortalEntry>;
-  /**
-   * Register (or replace) the entry for `id`. Idempotent: a second register
-   * for the same id replaces the entry rather than mounting a duplicate.
-   */
-  register(id: string, entry: BlockPortalEntry): void;
-  /**
-   * Remove the entry for `id`. Safe (no-op) when absent.
-   *
-   * Pass the caller's own `hostEl` to make the removal OWNERSHIP-CHECKED: the
-   * entry is deleted only when it is still the one that host registered. Core
-   * composes a replacement block (which registers under the SAME id) BEFORE it
-   * destroys the block it replaces, so a superseded tool's `removed()`/
-   * `destroy()` teardown arrives after the live entry is already in place —
-   * without the check it deletes that live entry and the holder stays empty.
-   */
-  unregister(id: string, hostEl?: HTMLElement): void;
-  /** Merge `props` into the live entry's reactive props (in-place update). */
-  setProps(id: string, props: Record<string, unknown>): void;
-}
-
-/**
- * Create a fresh portal registry. One per editor instance (associated via the
- * registry map, mirroring the holder WeakMap), so multiple editors on a page
- * never cross-render each other's blocks.
- */
-export const createBlockPortalRegistry = (): BlockPortalRegistry => {
-  // Vue's reactive Map tracks iteration (entries/size), so the host re-renders
-  // on register/unregister.
-  const entries = reactive(new Map<string, BlockPortalEntry>());
-
-  return {
-    entries: entries,
-    register(id: string, entry: BlockPortalEntry): void {
-      // markRaw so the reactive Map (which must still track add/delete) does NOT
-      // deep-proxy the entry — a proxied component DEFINITION or DOM host would
-      // break rendering ("received a Component made reactive"). Per-entry prop
-      // reactivity, when needed, lives on the `props` object itself.
-      // set() replaces an existing entry — idempotent, never duplicates.
-      entries.set(id, markRaw(entry));
-    },
-    unregister(id: string, hostEl?: HTMLElement): void {
-      // A superseded owner may not evict the entry that replaced it.
-      if (hostEl !== undefined && entries.get(id)?.hostEl !== hostEl) {
-        return;
-      }
-
-      entries.delete(id);
-    },
-    setProps(id: string, props: Record<string, unknown>): void {
-      const entry = entries.get(id);
-
-      if (entry === undefined) {
-        return;
-      }
-
-      // Mutate the reactive props object in place so the mounted component
-      // re-renders without being remounted (preserving its internal state).
-      Object.assign(entry.props, props);
-    },
-  };
-};

package/src/blocks-snapshot.ts

@@ -1,17 +0,0 @@
-// src/vue/blocks-snapshot.ts
-//
-// The block-tree data types, pure flat-index resolvers, AND the `UseBlocksApi`
-// connection contract are framework-agnostic and live in the shared core module
-// (`components/utils/blocks-tree`). The Vue `useBlocks` is a thin reactivity
-// wrapper over the shared `createBlocksApiForEditor`, so it exposes the IDENTICAL
-// surface as the React adapter — this file re-exports those shapes (no Vue-local
-// redefinition, so the two adapters cannot drift).
-export type {
-  BlockNode,
-  CaretTarget,
-  InsertPosition,
-  InsertSpec,
-  TreeInsertSpec,
-  MoveTarget,
-  UseBlocksApi,
-} from '@bloklabs/core/adapters';

package/src/blok-instance.ts

@@ -1,40 +0,0 @@
-import { inject, shallowRef, type InjectionKey, type ShallowRef } from 'vue';
-import type { Blok } from '@/types';
-
-/**
- * Injection key carrying the LIVE editor instance down to everything
- * `BlokContent` renders — which, because `<Teleport>` preserves the COMPONENT
- * render context (not the DOM target's), includes every `createVueBlock` block
- * mounted through the editor's shared `BlockPortalHost`.
- *
- * The provided ref is null until the instance exists, matching `useBlok`'s own
- * pre-ready contract.
- */
-export const BLOK_EDITOR_INSTANCE: InjectionKey<Readonly<ShallowRef<Blok | null>>> =
-  Symbol('BLOK_EDITOR_INSTANCE');
-
-/** Stable "no editor here" ref for components rendered outside a BlokContent. */
-const NO_EDITOR: Readonly<ShallowRef<Blok | null>> = shallowRef(null);
-
-/**
- * The live Blok instance a component is rendered inside, as a ref, or a ref of
- * null before it exists. Inside a `createVueBlock` block this is the block's OWN
- * editor — so a block can drive the tree it lives in without the host
- * prop-drilling the instance into it:
- *
- * ```ts
- * const blocks = useBlocks(useBlokInstance());
- * const children = computed(() => blocks.getChildren(ctx.block.id));
- * ```
- *
- * That pairing is also what makes a container block REACTIVE to its own child
- * tree: `useBlocks` refreshes on the editor's `block changed` event, which core
- * emits for every structural mutation — including children the adapter itself
- * never sees (a pasted paragraph, a Tab-indent from the keyboard).
- *
- * Call it inside `setup`. Outside a `BlokContent`/`BlokEditor` subtree it
- * returns a ref of null.
- */
-export function useBlokInstance(): Readonly<ShallowRef<Blok | null>> {
-  return inject(BLOK_EDITOR_INSTANCE, NO_EDITOR);
-}