@bloklabs/react 1.16.1 → 2.1.0

package/src/block-portal-registry.ts

@@ -1,161 +0,0 @@
-import type { ComponentType } from 'react';
-
-/**
- * Tool-config key carrying the editor's portal registry into a
- * `createReactBlock` tool. The tool is constructed by CORE (outside any React
- * render), so it cannot read context — `useBlok` injects the editor-scoped
- * registry through each react-block tool's `config`, and the tool reads it here.
- */
-export const BLOK_PORTAL_REGISTRY_CONFIG_KEY = '__blokPortalRegistry';
-
-/**
- * Tool-config key carrying the name the tool was registered under in the
- * consumer's `tools` map (injected next to the registry). The factory needs it
- * to associate portal entries with their tool so live config updates can be
- * routed; it is stripped (with the registry key) before the sanitized config
- * reaches the component.
- */
-export const BLOK_TOOL_NAME_CONFIG_KEY = '__blokToolName';
-
-/**
- * One mounted React block in the portal registry. `hostEl` is the Blok-owned
- * `toolRenderedElement` (tagged `data-blok-mutation-free`) the component is
- * portaled into; `props` is replaced immutably by `setProps` so the mounted
- * component re-renders in place (no remount).
- */
-export interface BlockPortalEntry {
-  hostEl: HTMLElement;
-  component: ComponentType<Record<string, unknown>>;
-  props: Record<string, unknown>;
-  /** Name the tool is registered under — routes per-tool live config updates. */
-  toolName?: string;
-}
-
-/**
- * Per-editor registry of React blocks. A single shared `BlockPortalHost`
- * renders one `createPortal` per entry, so every block lives in ONE React tree
- * (shared context, one reconciler) — the TipTap ReactNodeViewRenderer pattern,
- * not a `createRoot` per block.
- *
- * Shaped as an external store (`subscribe`/`getSnapshot`) so the host can read
- * it through `useSyncExternalStore`. The snapshot is immutable: every mutation
- * replaces it, and `getSnapshot` is referentially stable between mutations.
- */
-export interface BlockPortalRegistry {
-  /**
-   * 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 entry's props (in-place update, no remount). */
-  setProps(id: string, props: Record<string, unknown>): void;
-  /**
-   * Replace the `config` prop of every entry registered under `toolName`, and
-   * remember it so entries registered LATER start from this latest config
-   * instead of their construction-time snapshot.
-   */
-  setToolConfig(toolName: string, config: Record<string, unknown>): void;
-  /** Subscribe to snapshot changes; returns the unsubscribe function. */
-  subscribe(listener: () => void): () => void;
-  /** Current immutable snapshot (stable identity until the next mutation). */
-  getSnapshot(): ReadonlyMap<string, BlockPortalEntry>;
-}
-
-/**
- * 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 => {
-  const state = {
-    snapshot: new Map<string, BlockPortalEntry>() as ReadonlyMap<string, BlockPortalEntry>,
-  };
-  const listeners = new Set<() => void>();
-  /** Latest per-tool config, applied to mounted entries and future registers. */
-  const toolConfigs = new Map<string, Record<string, unknown>>();
-
-  const commit = (next: Map<string, BlockPortalEntry>): void => {
-    state.snapshot = next;
-    listeners.forEach(listener => listener());
-  };
-
-  return {
-    register(id: string, entry: BlockPortalEntry): void {
-      const next = new Map(state.snapshot);
-      const liveConfig = entry.toolName === undefined ? undefined : toolConfigs.get(entry.toolName);
-
-      next.set(
-        id,
-        liveConfig === undefined ? entry : { ...entry, props: { ...entry.props, config: liveConfig } }
-      );
-      commit(next);
-    },
-    unregister(id: string, hostEl?: HTMLElement): void {
-      const current = state.snapshot.get(id);
-
-      if (current === undefined) {
-        return;
-      }
-
-      // A superseded owner may not evict the entry that replaced it.
-      if (hostEl !== undefined && current.hostEl !== hostEl) {
-        return;
-      }
-
-      const next = new Map(state.snapshot);
-
-      next.delete(id);
-      commit(next);
-    },
-    setProps(id: string, props: Record<string, unknown>): void {
-      const current = state.snapshot.get(id);
-
-      if (current === undefined) {
-        return;
-      }
-
-      const next = new Map(state.snapshot);
-
-      next.set(id, { ...current, props: { ...current.props, ...props } });
-      commit(next);
-    },
-    setToolConfig(toolName: string, config: Record<string, unknown>): void {
-      toolConfigs.set(toolName, config);
-
-      const matching = [...state.snapshot].filter(([, entry]) => entry.toolName === toolName);
-
-      if (matching.length === 0) {
-        return;
-      }
-
-      const next = new Map(state.snapshot);
-
-      for (const [id, entry] of matching) {
-        next.set(id, { ...entry, props: { ...entry.props, config } });
-      }
-
-      commit(next);
-    },
-    subscribe(listener: () => void): () => void {
-      listeners.add(listener);
-
-      return (): void => {
-        listeners.delete(listener);
-      };
-    },
-    getSnapshot(): ReadonlyMap<string, BlockPortalEntry> {
-      return state.snapshot;
-    },
-  };
-};

package/src/blocks-snapshot.ts

@@ -1,27 +0,0 @@
-// packages/react/src/blocks-snapshot.ts
-//
-// The block-tree connection types and pure resolution helpers are
-// framework-agnostic and now live in a shared core module so the React, Vue,
-// and Angular adapters — and core's own per-block `BlockAPI` — resolve flat
-// insert/move indices through ONE battle-tested implementation (the parity
-// requirement: author once, reuse everywhere). This file re-exports them so
-// existing React imports (`./blocks-snapshot`) keep working unchanged.
-export {
-  snapshotNodes,
-  resolveInsertIndex,
-  resolveMoveIndex,
-  parentMap,
-  isDescendantOf,
-} from '@bloklabs/core/adapters';
-
-export type {
-  BlockNode,
-  CaretTarget,
-  InsertPosition,
-  InsertSpec,
-  TreeInsertSpec,
-  MoveTarget,
-  BlocksReader,
-  IndexReader,
-  UseBlocksApi,
-} from '@bloklabs/core/adapters';

package/src/blok-instance-context.ts

@@ -1,35 +0,0 @@
-import { createContext, useContext } from 'react';
-import type { Blok } from '@/types';
-
-/**
- * Carries the LIVE editor instance down to everything `BlokContent` renders —
- * which, because `createPortal` preserves the COMPONENT tree's context (not the
- * DOM target's), includes every `createReactBlock` block mounted through the
- * editor's shared `BlockPortalHost`.
- *
- * Null until the instance exists (SSR, first render, between recreations),
- * matching `useBlok`'s own pre-ready contract.
- */
-export const BlokInstanceContext = createContext<Blok | null>(null);
-
-/**
- * The live Blok instance a component is rendered inside, or null before it
- * exists. Inside a `createReactBlock` component 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:
- *
- * ```tsx
- * const blocks = useBlocks(useBlokInstance());
- * const children = blocks.getChildren(block.id);
- * ```
- *
- * That pairing is also what makes a container block REACTIVE to its own child
- * tree: `useBlocks` re-renders 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).
- *
- * Outside a `BlokContent`/`BlokEditor` subtree it returns null.
- */
-export function useBlokInstance(): Blok | null {
-  return useContext(BlokInstanceContext);
-}

package/src/config-keys.ts

@@ -1,72 +0,0 @@
-import type { UseBlokConfig } from './types';
-
-/**
- * Keys that belong to the editor config (consumed by `useBlok`). Any prop on
- * `BlokEditor` whose key is NOT in this set is treated as a container div
- * attribute and spread onto the underlying element (mirrors `BlokContent`).
- *
- * Keep in sync with `UseBlokConfig`. The two compile-time guards below fail the
- * `yarn lint:types` typecheck if this list drifts.
- */
-export const USE_BLOK_CONFIG_KEYS = [
-  'autofocus',
-  'defaultBlock',
-  'dataModel',
-  'placeholder',
-  'sanitizer',
-  'hideToolbar',
-  'toolbarPosition',
-  'maxHistoryLength',
-  'historyDebounceTime',
-  'newGroupDelay',
-  'globalUndoRedo',
-  'tools',
-  'data',
-  'minHeight',
-  'loader',
-  'logLevel',
-  'readOnly',
-  'i18n',
-  'link',
-  'linkPaste',
-  'onBeforePaste',
-  'onReady',
-  'onChange',
-  'onSave',
-  'onError',
-  'onImageFailure',
-  'onEnter',
-  'onSubmit',
-  'onBeforeRender',
-  'onAfterRender',
-  'inlineToolbar',
-  'inlineEmoji',
-  'find',
-  'tunes',
-  'style',
-  'theme',
-  'onThemeChange',
-  'scrollToBlock',
-  'user',
-  'resolveUser',
-  'notifierPosition',
-  'notifier',
-  'width',
-  'migrations',
-  'uploader',
-  'media',
-  'server',
-  'ticket',
-  'persistence',
-  'collaboration',
-  'documentId',
-  'tabSync',
-  'captureClicksBelowEditor',
-] as const satisfies readonly (keyof UseBlokConfig)[];
-
-/**
- * Compile error if a `UseBlokConfig` key is missing from the list above.
- * (`satisfies` only proves each entry is a valid key; this proves coverage.)
- */
-type _MissingConfigKey = Exclude<keyof UseBlokConfig, (typeof USE_BLOK_CONFIG_KEYS)[number]>;
-const _exhaustive: _MissingConfigKey extends never ? true : never = true;

package/src/content-baseline-map.ts

@@ -1,38 +0,0 @@
-import type { LooseOutputData, OutputData } from '@/types';
-
-/**
- * The controlled-content bookkeeping `useBlok` keeps for one editor: the
- * baseline it believes the editor currently reflects, plus the window of
- * payloads the editor emitted through `onSave`.
- *
- * The declarative `data` effect dedupes against both, which is only sound while
- * that effect is the ONLY thing changing the content. An imperative
- * `useBlokHandle().clear()` / `.render()` moves the editor out from under the
- * bookkeeping: without this channel, restoring a document the editor itself
- * emitted is dismissed as an echo and never rendered — the editor stays empty
- * while React state says otherwise. Registered per instance (mirrors the holder
- * / portal-registry WeakMaps) so the handle can reach it from the editor alone.
- */
-export interface ContentBaseline {
-  /**
-   * Records `content` as what the editor now reflects and drops every remembered
-   * emitted payload — content the editor emitted BEFORE an out-of-band change is
-   * no longer content it holds, so it must not no-op a later controlled restore.
-   * @param content - the document the editor now reflects
-   */
-  markRendered(content: OutputData | LooseOutputData | null): void;
-}
-
-const baselines = new WeakMap<WeakKey, ContentBaseline>();
-
-export function setContentBaseline(editor: WeakKey, baseline: ContentBaseline): void {
-  baselines.set(editor, baseline);
-}
-
-export function getContentBaseline(editor: WeakKey): ContentBaseline | undefined {
-  return baselines.get(editor);
-}
-
-export function removeContentBaseline(editor: WeakKey): void {
-  baselines.delete(editor);
-}