@portabletext/editor 8.0.1 → 8.0.3

package/lib/{behavior.types.action-CcO4rAdL.d.ts → behavior.types.action-C6D8CCF9.d.ts}

@@ -1633,98 +1633,6 @@ type SetSelectionOperation = {
  * @beta
  */
 type EngineOperation = InsertOperation | SetOperation | UnsetOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
-type DecoratedRange = Range & {
-  rangeDecoration: RangeDecoration;
-};
-/**
- * The operation channel is the single place to observe every `EngineOperation` the
- * engine applies.
- *
- * Guarantees:
- *
- * - Listeners run synchronously, in subscription order.
- * - `before` listeners run before the operation touches the editor state,
- *   `after` listeners run once the operation (including any normalization it
- *   triggered) has been fully applied.
- * - Normalization fixes re-enter `editor.apply`, so a fix operation's events
- *   fire nested between the triggering operation's `before` and `after`
- *   events — a fix's `after` listeners run before the triggering
- *   operation's.
- */
-type OperationOrigin = 'local' | 'remote' | 'undo' | 'redo' | 'normalization';
-type OperationEvent = {
-  /**
-   * The operation object is enriched in place during apply — `inverse` gets
-   * populated and inserted nodes may be re-keyed — so `after` listeners
-   * observe the final operation.
-   */
-  operation: EngineOperation;
-  /**
-   * `editor.snapshot.context.value` captured at apply entry. Operations
-   * replace the value array instead of mutating it, so this reference keeps
-   * pointing at the pre-apply value.
-   */
-  beforeValue: Array<PortableTextBlock>;
-  /**
-   * `editor.snapshot.context.selection` captured at apply entry. Selections
-   * are replaced, not mutated, so this reference stays pre-apply.
-   */
-  beforeSelection: EditorSelection;
-  /**
-   * Whether `editor.operations` already held unflushed operations at apply
-   * entry.
-   */
-  operationsInProgress: boolean;
-  isNormalizingNode: boolean;
-  isPatching: boolean;
-  isProcessingRemoteChanges: boolean;
-  isUndoing: boolean;
-  isRedoing: boolean;
-  withHistory: boolean;
-  undoStepId: string | undefined;
-  /**
-   * Derived from the engine flags above, for declarative filtering.
-   */
-  origin: OperationOrigin;
-};
-type OperationListener = (event: OperationEvent) => void;
-/**
- * The `Location` interface is a union of the ways to refer to a specific
- * location in a document: paths, points or ranges.
- *
- * Methods will often accept a `Location` instead of requiring only a `Path`,
- * `Point` or `Range`. This eliminates the need for developers to manage
- * converting between the different interfaces in their own code base.
- */
-type Location = Path | Point | Range;
-/**
- * `PathRef` objects keep a specific path in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date path value.
- */
-interface PathRef {
-  current: Path | null;
-  affinity: 'forward' | 'backward' | null;
-  unref(): Path | null;
-}
-interface PathRefInterface {
-  transform: (ref: PathRef, op: EngineOperation) => void;
-}
-declare const PathRef: PathRefInterface;
-/**
- * `PointRef` objects keep a specific point in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date point value.
- */
-interface PointRef {
-  current: Point | null;
-  affinity: TextDirection | null;
-  unref(): Point | null;
-}
-interface PointRefInterface {
-  transform: (ref: PointRef, op: EngineOperation) => void;
-}
-declare const PointRef: PointRefInterface;
 /**
  * `RangeRef` objects keep a specific range in a document synced over time as new
  * operations are applied to the editor. You can access their `current` property
@@ -1735,40 +1643,6 @@ interface RangeRef {
   affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
   unref(): Range | null;
 }
-/**
- * The `Editor` interface stores all the state of a editor. It is extended
- * by plugins that wish to add their own helpers and implement new behaviors.
- */
-interface BaseEditor {
-  operations: EngineOperation[];
-  operationListeners: {
-    before: Array<OperationListener>;
-    after: Array<OperationListener>;
-  };
-  dirtyPaths: Path[];
-  dirtyPathKeys: Set<string>;
-  flushing: boolean;
-  normalizing: boolean;
-  pathRefs: Set<PathRef>;
-  pointRefs: Set<PointRef>;
-  rangeRefs: Set<RangeRef>;
-  apply: (operation: EngineOperation) => void;
-  normalizeNode: (entry: [Editor$1 | Node$1, Path], options?: {
-    operation?: EngineOperation;
-  }) => void;
-  onChange: (options?: {
-    operation?: EngineOperation;
-  }) => void;
-  shouldNormalize: ({ iteration, dirtyPaths, operation }: {
-    iteration: number;
-    initialDirtyPathsLength: number;
-    dirtyPaths: Path[];
-    operation?: EngineOperation;
-  }) => boolean;
-  select: (target: Location) => void;
-  setSelection: (props: Partial<Range>) => void;
-}
-type Editor$1 = BaseEditor & DOMEditor & PortableTextEditorEngine;
 type StringDiff = {
   start: number;
   end: number;
@@ -1902,6 +1776,132 @@ interface DOMEditorInterface {
   }) => T extends true ? Range | null : Range;
 }
 declare const DOMEditor: DOMEditorInterface;
+/**
+ * The `Location` interface is a union of the ways to refer to a specific
+ * location in a document: paths, points or ranges.
+ *
+ * Methods will often accept a `Location` instead of requiring only a `Path`,
+ * `Point` or `Range`. This eliminates the need for developers to manage
+ * converting between the different interfaces in their own code base.
+ */
+type Location = Path | Point | Range;
+/**
+ * `PathRef` objects keep a specific path in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date path value.
+ */
+interface PathRef {
+  current: Path | null;
+  affinity: 'forward' | 'backward' | null;
+  unref(): Path | null;
+}
+interface PathRefInterface {
+  transform: (ref: PathRef, op: EngineOperation) => void;
+}
+declare const PathRef: PathRefInterface;
+/**
+ * `PointRef` objects keep a specific point in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date point value.
+ */
+interface PointRef {
+  current: Point | null;
+  affinity: TextDirection | null;
+  unref(): Point | null;
+}
+interface PointRefInterface {
+  transform: (ref: PointRef, op: EngineOperation) => void;
+}
+declare const PointRef: PointRefInterface;
+/**
+ * The `Editor` interface stores all the state of a editor. It is extended
+ * by plugins that wish to add their own helpers and implement new behaviors.
+ */
+interface BaseEditor {
+  operations: EngineOperation[];
+  operationListeners: {
+    before: Array<OperationListener>;
+    after: Array<OperationListener>;
+  };
+  dirtyPaths: Path[];
+  dirtyPathKeys: Set<string>;
+  flushing: boolean;
+  normalizing: boolean;
+  pathRefs: Set<PathRef>;
+  pointRefs: Set<PointRef>;
+  rangeRefs: Set<RangeRef>;
+  apply: (operation: EngineOperation) => void;
+  normalizeNode: (entry: [Editor$1 | Node$1, Path], options?: {
+    operation?: EngineOperation;
+  }) => void;
+  onChange: (options?: {
+    operation?: EngineOperation;
+  }) => void;
+  shouldNormalize: ({ iteration, dirtyPaths, operation }: {
+    iteration: number;
+    initialDirtyPathsLength: number;
+    dirtyPaths: Path[];
+    operation?: EngineOperation;
+  }) => boolean;
+  select: (target: Location) => void;
+  setSelection: (props: Partial<Range>) => void;
+}
+type Editor$1 = BaseEditor & DOMEditor & PortableTextEditorEngine;
+/**
+ * The operation channel is the single place to observe every `EngineOperation` the
+ * engine applies.
+ *
+ * Guarantees:
+ *
+ * - Listeners run synchronously, in subscription order.
+ * - `before` listeners run before the operation touches the editor state,
+ *   `after` listeners run once the operation (including any normalization it
+ *   triggered) has been fully applied.
+ * - Normalization fixes re-enter `editor.apply`, so a fix operation's events
+ *   fire nested between the triggering operation's `before` and `after`
+ *   events — a fix's `after` listeners run before the triggering
+ *   operation's.
+ */
+type OperationOrigin = 'local' | 'remote' | 'undo' | 'redo' | 'normalization';
+type OperationEvent = {
+  /**
+   * The operation object is enriched in place during apply — `inverse` gets
+   * populated and inserted nodes may be re-keyed — so `after` listeners
+   * observe the final operation.
+   */
+  operation: EngineOperation;
+  /**
+   * `editor.snapshot.context.value` captured at apply entry. Operations
+   * replace the value array instead of mutating it, so this reference keeps
+   * pointing at the pre-apply value.
+   */
+  beforeValue: Array<PortableTextBlock>;
+  /**
+   * `editor.snapshot.context.selection` captured at apply entry. Selections
+   * are replaced, not mutated, so this reference stays pre-apply.
+   */
+  beforeSelection: EditorSelection;
+  /**
+   * Whether `editor.operations` already held unflushed operations at apply
+   * entry.
+   */
+  operationsInProgress: boolean;
+  isNormalizingNode: boolean;
+  isPatching: boolean;
+  isProcessingRemoteChanges: boolean;
+  isUndoing: boolean;
+  isRedoing: boolean;
+  withHistory: boolean;
+  undoStepId: string | undefined;
+  /**
+   * Derived from the engine flags above, for declarative filtering.
+   */
+  origin: OperationOrigin;
+};
+type OperationListener = (event: OperationEvent) => void;
+type DecoratedRange = Range & {
+  rangeDecoration: RangeDecoration;
+};
 type HistoryItem = {
   operations: EngineOperation[];
   timestamp: Date;
@@ -3395,4 +3395,4 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
 export { BehaviorGuard as $, defineBlockObject as $t, PortableTextSpan$1 as A, Annotation as At, usePortableTextEditor as B, DecoratorRender as Bt, ListDefinition as C, EditorSchema as Ct, PortableTextBlock$1 as D, RegisteredInlineObject as Dt, Patch$1 as E, RegisteredContainer as Et, defineSchema as F, BlockObjectRenderProps as Ft, Editor as G, RegistrableNode as Gt, useEditorSelector as H, InlineObject as Ht, BlockOffset as I, Container as It, EditorEmittedEvent as J, SpanRenderProps as Jt, EditorConfig as K, Span as Kt, useEditor as L, ContainerRender as Lt, SchemaDefinition$1 as M, AnnotationRenderProps as Mt, StyleDefinition as N, BlockObject as Nt, PortableTextChild$1 as O, RegisteredPositional as Ot, StyleSchemaType as P, BlockObjectRender as Pt, defineBehavior as Q, defineAnnotation as Qt, defaultKeyGenerator as R, ContainerRenderProps as Rt, InlineObjectSchemaType as S, Node$1 as St, OfDefinition$1 as T, RegisteredBlockObject as Tt, EditorProvider as U, InlineObjectRender as Ut, EditorSelector as V, DecoratorRenderProps as Vt, EditorProviderProps as W, InlineObjectRenderProps as Wt, Operation as X, TextBlockRender as Xt, MutationEvent as Y, TextBlock as Yt, Behavior as Z, TextBlockRenderProps as Zt, BlockObjectSchemaType as _, PortableTextEditable as _t, forward as a, AnnotationPath as an, EditorSelectionPoint as at, FieldDefinition$1 as b, PortableTextEditor as bt, CustomBehaviorEvent as c, KeyedSegment as cn, OnPasteFn as ct, SyntheticBehaviorEvent as d, PasteData as dt, defineContainer as en, EditorContext as et, PatchesEvent as f, RangeDecoration as ft, BlockObjectDefinition as g, ScrollSelectionIntoViewFunction as gt, BaseDefinition as h, RenderPlaceholderFunction as ht, execute as i, defineTextBlock as in, EditorSelection as it, PortableTextTextBlock$1 as j, AnnotationRender as jt, PortableTextObject$1 as k, RegisteredSpan as kt, InsertPlacement as l, Path as ln, OnPasteResult as lt, AnnotationSchemaType as m, RenderEditableFunction as mt, BehaviorActionSet as n, defineInlineObject as nn, AddedAnnotationPaths as nt, raise$1 as o, BlockPath as on, InvalidValueResolution as ot, AnnotationDefinition as p, RangeDecorationOnMovedDetails as pt, EditorEvent as q, SpanRender as qt, effect as r, defineSpan as rn, EditableAPIDeleteOptions as rt, BehaviorEvent as s, ChildPath as sn, OnCopyFn as st, BehaviorAction as t, defineDecorator as tn, EditorSnapshot as tt, NativeBehaviorEvent as u, PathSegment as un, OnPasteResultOrPromise as ut, DecoratorDefinition as v, PortableTextEditableProps as vt, ListSchemaType as w, Containers as wt, InlineObjectDefinition as x, TraversalSnapshot as xt, DecoratorSchemaType as y, HotkeyOptions as yt, usePortableTextEditorSelection as z, Decorator as zt };
-//# sourceMappingURL=behavior.types.action-CcO4rAdL.d.ts.map
+//# sourceMappingURL=behavior.types.action-C6D8CCF9.d.ts.map

package/lib/behavior.types.action-C6D8CCF9.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavior.types.action-C6D8CCF9.d.ts","names":[],"sources":["../src/internal-utils/mime-type.ts","../src/type-utils.ts","../src/converters/converter.types.ts","../src/types/paths.ts","../src/renderers/renderer.types.ts","../src/schema/container-types.ts","../src/editor/editor-schema.ts","../src/engine/interfaces/node.ts","../src/traversal/traversal-snapshot.ts","../src/editor/PortableTextEditor.tsx","../src/types/options.ts","../src/editor/Editable.tsx","../src/types/editor.ts","../src/engine/types/types.ts","../src/engine/interfaces/point.ts","../src/engine/interfaces/range.ts","../src/engine/interfaces/operation.ts","../src/engine/interfaces/range-ref.ts","../src/engine/dom/utils/diff-text.ts","../src/engine/dom/utils/dom.ts","../src/engine/dom/plugin/dom-editor.ts","../src/engine/interfaces/location.ts","../src/engine/interfaces/path-ref.ts","../src/engine/interfaces/point-ref.ts","../src/engine/interfaces/editor.ts","../src/engine/core/operation-channel.ts","../src/editor/range-decorations-machine.ts","../src/types/editor-engine.ts","../src/editor/editor-snapshot.ts","../src/behaviors/behavior.types.guard.ts","../src/behaviors/behavior.types.behavior.ts","../src/types/operation.ts","../src/editor/relay.ts","../src/editor.ts","../src/editor/editor-provider.tsx","../src/editor/editor-selector.ts","../src/editor/usePortableTextEditor.ts","../src/editor/usePortableTextEditorSelection.tsx","../src/utils/key-generator.ts","../src/editor/use-editor.ts","../src/types/block-offset.ts","../src/priority/priority.types.ts","../src/behaviors/behavior.config.ts","../src/editor/editor-machine.ts","../src/internal-utils/event-position.ts","../src/types/block-with-optional-key.ts","../src/behaviors/behavior.types.event.ts","../src/editor/editor-dom.ts","../src/behaviors/behavior.types.action.ts"],"mappings":"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"}

package/lib/behaviors/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-CcO4rAdL.js";
+import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-C6D8CCF9.js";
 export { type Behavior, type BehaviorAction, type BehaviorActionSet, type BehaviorEvent, type BehaviorGuard, type CustomBehaviorEvent, type InsertPlacement, type NativeBehaviorEvent, type SyntheticBehaviorEvent, defineBehavior, effect, execute, forward, raise };

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-import { $t as defineBlockObject, A as PortableTextSpan, At as Annotation, B as usePortableTextEditor, Bt as DecoratorRender, C as ListDefinition, Ct as EditorSchema, D as PortableTextBlock, Dt as RegisteredInlineObject, E as Patch, Et as RegisteredContainer, F as defineSchema, Ft as BlockObjectRenderProps, G as Editor, Gt as RegistrableNode, H as useEditorSelector, Ht as InlineObject, I as BlockOffset, It as Container, J as EditorEmittedEvent, Jt as SpanRenderProps, K as EditorConfig, Kt as Span, L as useEditor, Lt as ContainerRender, M as SchemaDefinition, Mt as AnnotationRenderProps, N as StyleDefinition, Nt as BlockObject, O as PortableTextChild, Ot as RegisteredPositional, P as StyleSchemaType, Pt as BlockObjectRender, Qt as defineAnnotation, R as defaultKeyGenerator, Rt as ContainerRenderProps, S as InlineObjectSchemaType, T as OfDefinition, Tt as RegisteredBlockObject, U as EditorProvider, Ut as InlineObjectRender, V as EditorSelector, Vt as DecoratorRenderProps, W as EditorProviderProps, Wt as InlineObjectRenderProps, X as Operation, Xt as TextBlockRender, Y as MutationEvent, Yt as TextBlock, Zt as TextBlockRenderProps, _ as BlockObjectSchemaType, _t as PortableTextEditable, an as AnnotationPath, at as EditorSelectionPoint, b as FieldDefinition, bt as PortableTextEditor, ct as OnPasteFn, dt as PasteData, en as defineContainer, et as EditorContext, f as PatchesEvent, ft as RangeDecoration, g as BlockObjectDefinition, gt as ScrollSelectionIntoViewFunction, h as BaseDefinition, ht as RenderPlaceholderFunction, in as defineTextBlock, it as EditorSelection, j as PortableTextTextBlock, jt as AnnotationRender, k as PortableTextObject, kt as RegisteredSpan, ln as Path, lt as OnPasteResult, m as AnnotationSchemaType, mt as RenderEditableFunction, nn as defineInlineObject, nt as AddedAnnotationPaths, on as BlockPath, ot as InvalidValueResolution, p as AnnotationDefinition, pt as RangeDecorationOnMovedDetails, q as EditorEvent, qt as SpanRender, rn as defineSpan, rt as EditableAPIDeleteOptions, sn as ChildPath, st as OnCopyFn, tn as defineDecorator, tt as EditorSnapshot, ut as OnPasteResultOrPromise, v as DecoratorDefinition, vt as PortableTextEditableProps, w as ListSchemaType, wt as Containers, x as InlineObjectDefinition, y as DecoratorSchemaType, yt as HotkeyOptions, z as usePortableTextEditorSelection, zt as Decorator } from "./behavior.types.action-CcO4rAdL.js";
+import { $t as defineBlockObject, A as PortableTextSpan, At as Annotation, B as usePortableTextEditor, Bt as DecoratorRender, C as ListDefinition, Ct as EditorSchema, D as PortableTextBlock, Dt as RegisteredInlineObject, E as Patch, Et as RegisteredContainer, F as defineSchema, Ft as BlockObjectRenderProps, G as Editor, Gt as RegistrableNode, H as useEditorSelector, Ht as InlineObject, I as BlockOffset, It as Container, J as EditorEmittedEvent, Jt as SpanRenderProps, K as EditorConfig, Kt as Span, L as useEditor, Lt as ContainerRender, M as SchemaDefinition, Mt as AnnotationRenderProps, N as StyleDefinition, Nt as BlockObject, O as PortableTextChild, Ot as RegisteredPositional, P as StyleSchemaType, Pt as BlockObjectRender, Qt as defineAnnotation, R as defaultKeyGenerator, Rt as ContainerRenderProps, S as InlineObjectSchemaType, T as OfDefinition, Tt as RegisteredBlockObject, U as EditorProvider, Ut as InlineObjectRender, V as EditorSelector, Vt as DecoratorRenderProps, W as EditorProviderProps, Wt as InlineObjectRenderProps, X as Operation, Xt as TextBlockRender, Y as MutationEvent, Yt as TextBlock, Zt as TextBlockRenderProps, _ as BlockObjectSchemaType, _t as PortableTextEditable, an as AnnotationPath, at as EditorSelectionPoint, b as FieldDefinition, bt as PortableTextEditor, ct as OnPasteFn, dt as PasteData, en as defineContainer, et as EditorContext, f as PatchesEvent, ft as RangeDecoration, g as BlockObjectDefinition, gt as ScrollSelectionIntoViewFunction, h as BaseDefinition, ht as RenderPlaceholderFunction, in as defineTextBlock, it as EditorSelection, j as PortableTextTextBlock, jt as AnnotationRender, k as PortableTextObject, kt as RegisteredSpan, ln as Path, lt as OnPasteResult, m as AnnotationSchemaType, mt as RenderEditableFunction, nn as defineInlineObject, nt as AddedAnnotationPaths, on as BlockPath, ot as InvalidValueResolution, p as AnnotationDefinition, pt as RangeDecorationOnMovedDetails, q as EditorEvent, qt as SpanRender, rn as defineSpan, rt as EditableAPIDeleteOptions, sn as ChildPath, st as OnCopyFn, tn as defineDecorator, tt as EditorSnapshot, ut as OnPasteResultOrPromise, v as DecoratorDefinition, vt as PortableTextEditableProps, w as ListSchemaType, wt as Containers, x as InlineObjectDefinition, y as DecoratorSchemaType, yt as HotkeyOptions, z as usePortableTextEditorSelection, zt as Decorator } from "./behavior.types.action-C6D8CCF9.js";
 export { type AddedAnnotationPaths, type Annotation, type AnnotationDefinition, type AnnotationPath, type AnnotationRender, type AnnotationRenderProps, type AnnotationSchemaType, type BaseDefinition, type BlockObject, type BlockObjectDefinition, type BlockObjectRender, type BlockObjectRenderProps, type BlockObjectSchemaType, type BlockOffset, type BlockPath, type ChildPath, type Container, type ContainerRender, type ContainerRenderProps, type Containers, type Decorator, type DecoratorDefinition, type DecoratorRender, type DecoratorRenderProps, type DecoratorSchemaType, type EditableAPIDeleteOptions, type Editor, type EditorConfig, type EditorContext, type EditorEmittedEvent, type EditorEvent, EditorProvider, type EditorProviderProps, type EditorSchema, type EditorSelection, type EditorSelectionPoint, type EditorSelector, type EditorSnapshot, type FieldDefinition, type HotkeyOptions, type InlineObject, type InlineObjectDefinition, type InlineObjectRender, type InlineObjectRenderProps, type InlineObjectSchemaType, type InvalidValueResolution, type ListDefinition, type ListSchemaType, type MutationEvent, type OfDefinition, type OnCopyFn, type OnPasteFn, type OnPasteResult, type OnPasteResultOrPromise, type Operation, type PasteData, type Patch, type PatchesEvent, type Path, type PortableTextBlock, type PortableTextChild, PortableTextEditable, type PortableTextEditableProps, PortableTextEditor, type PortableTextObject, type PortableTextSpan, type PortableTextTextBlock, type RangeDecoration, type RangeDecorationOnMovedDetails, type RegisteredBlockObject, type RegisteredContainer, type RegisteredInlineObject, type RegisteredPositional, type RegisteredSpan, type RegistrableNode, type RenderEditableFunction, type RenderPlaceholderFunction, type SchemaDefinition, type ScrollSelectionIntoViewFunction, type Span, type SpanRender, type SpanRenderProps, type StyleDefinition, type StyleSchemaType, type TextBlock, type TextBlockRender, type TextBlockRenderProps, defineAnnotation, defineBlockObject, defineContainer, defineDecorator, defineInlineObject, defineSchema, defineSpan, defineTextBlock, defaultKeyGenerator as keyGenerator, useEditor, useEditorSelector, usePortableTextEditor, usePortableTextEditorSelection };

package/lib/index.js

@@ -1179,13 +1179,14 @@ function mapPointThroughStep(step, point, options = {}) {
 			};
 		}
 		case "rekey": {
-			let path;
-			for (let i = 0; i < point.path.length; i++) {
-				let segment = point.path[i];
-				isKeyedSegment(segment) && segment._key === step.oldKey && (path === void 0 && (path = [...point.path]), path[i] = { _key: step.newKey });
-			}
-			return path === void 0 ? point : {
-				path,
+			if (point.path.length <= step.path.length || !pathEquals(point.path.slice(0, step.path.length), step.path)) return point;
+			let segment = point.path[step.path.length];
+			return !isKeyedSegment(segment) || segment._key !== step.oldKey ? point : {
+				path: [
+					...step.path,
+					{ _key: step.newKey },
+					...point.path.slice(step.path.length + 1)
+				],
 				offset: point.offset
 			};
 		}
@@ -1303,6 +1304,7 @@ function operationToSteps(op) {
 				let oldKey = op.inverse?.type === "set" && typeof op.inverse.value == "string" ? op.inverse.value : void 0;
 				return oldKey ? [{
 					type: "rekey",
+					path: nodePath.slice(0, -1),
 					oldKey,
 					newKey: op.value
 				}] : [];
@@ -4187,7 +4189,8 @@ function transformRange(range, op, root, options = {}) {
 const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(input.editorEngine, (event) => {
 	event.operation.type !== "set.selection" && sendBack({
 		type: "engine operation",
-		operation: event.operation
+		operation: event.operation,
+		origin: event.origin
 	});
 }, { phase: "before" }), rangeDecorationsMachine = setup({
 	types: {
@@ -4243,7 +4246,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 					decoratedRange.rangeDecoration.onMoved?.({
 						newSelection: null,
 						rangeDecoration: decoratedRange.rangeDecoration,
-						origin: "local"
+						origin: event.origin === "remote" ? "remote" : "local"
 					});
 					continue;
 				}
@@ -4251,7 +4254,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 				(newRange && newRange !== currentSelection || newRange === null && currentSelection) && decoratedRange.rangeDecoration.onMoved?.({
 					newSelection: newRange,
 					rangeDecoration: decoratedRange.rangeDecoration,
-					origin: "local"
+					origin: event.origin === "remote" ? "remote" : "local"
 				}), newRange !== null && rangeDecorationState.push({
 					...newRange || currentSelection,
 					rangeDecoration: {
@@ -6891,13 +6894,17 @@ function applyOperation(editor, op) {
 		case "set": {
 			let { path, value } = op;
 			if (!op.inverse && !editor.isProcessingRemoteChanges) {
-				let previousValue = getValue(editor.snapshot.context.value, path);
+				let previousValue = getValue(editor.snapshot.context.value, path), inversePath = path[path.length - 1] === "_key" && typeof value == "string" && isKeyedSegment(path[path.length - 2]) ? [
+					...path.slice(0, -2),
+					{ _key: value },
+					"_key"
+				] : path;
 				op.inverse = previousValue === void 0 ? {
 					type: "unset",
-					path
+					path: inversePath
 				} : {
 					type: "set",
-					path,
+					path: inversePath,
 					value: previousValue
 				};
 			}
@@ -7674,23 +7681,20 @@ function setNodeProperties(editor, props, path) {
 	keyIndex !== -1 && (keys.splice(keyIndex, 1), keys.unshift("_key"));
 	let currentPath = path;
 	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) if (propsRecord[key] != null) {
-		let hadProperty = nodeRecord.hasOwnProperty(key);
-		if (editor.apply({
+		let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
+		editor.apply({
 			type: "set",
 			path: [...currentPath, key],
 			value: propsRecord[key],
 			inverse: hadProperty ? {
 				type: "set",
-				path: [...currentPath, key],
+				path: inversePath,
 				value: nodeRecord[key]
 			} : {
 				type: "unset",
-				path: [...currentPath, key]
+				path: inversePath
 			}
-		}), key === "_key" && typeof propsRecord[key] == "string") {
-			let lastSegment = currentPath[currentPath.length - 1];
-			isKeyedSegment(lastSegment) && (currentPath = [...currentPath.slice(0, -1), { _key: propsRecord[key] }]);
-		}
+		}), renamedPath && (currentPath = renamedPath);
 	} else nodeRecord.hasOwnProperty(key) && editor.apply({
 		type: "unset",
 		path: [...currentPath, key],
@@ -13131,16 +13135,24 @@ const abstractAnnotationBehaviors = [
 			let previousBlock = {
 				node: previousSibling.node,
 				path: previousSibling.path
-			};
+			}, previousBlockEndPoint = getBlockEndPoint({
+				context: snapshot.context,
+				block: previousBlock
+			}), { renamedBlock, renameActions } = planMergeKeyRenames({
+				context: snapshot.context,
+				mergingBlockPath: focusTextBlock.path,
+				mergingBlock: focusTextBlock.node,
+				destinationBlock: previousBlock.node
+			});
 			return {
-				previousBlockEndPoint: getBlockEndPoint({
-					context: snapshot.context,
-					block: previousBlock
-				}),
-				focusTextBlock
+				previousBlockEndPoint,
+				focusTextBlock,
+				renamedBlock,
+				renameActions
 			};
 		},
-		actions: [(_, { previousBlockEndPoint, focusTextBlock }) => [
+		actions: [(_, { previousBlockEndPoint, focusTextBlock, renamedBlock, renameActions }) => [
+			...renameActions,
 			raise$1({
 				type: "delete.block",
 				at: focusTextBlock.path
@@ -13154,7 +13166,7 @@ const abstractAnnotationBehaviors = [
 			}),
 			raise$1({
 				type: "insert.block",
-				block: focusTextBlock.node,
+				block: renamedBlock,
 				placement: "auto",
 				select: "start"
 			})
@@ -13223,20 +13235,32 @@ const abstractAnnotationBehaviors = [
 			}, focusTextBlock = getFocusTextBlock(adjustedSnapshot);
 			if (!focusTextBlock) return !1;
 			let nextSibling = getSibling(adjustedSnapshot, focusTextBlock.path, { direction: "next" });
-			return !nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlockNode(snapshot.context, nextSibling.node) ? !1 : { nextBlock: {
-				node: nextSibling.node,
-				path: nextSibling.path
-			} };
+			if (!nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlock(snapshot.context, nextSibling.node)) return !1;
+			let { renamedBlock, renameActions } = planMergeKeyRenames({
+				context: snapshot.context,
+				mergingBlockPath: nextSibling.path,
+				mergingBlock: nextSibling.node,
+				destinationBlock: focusTextBlock.node
+			});
+			return {
+				nextBlockPath: nextSibling.path,
+				renamedBlock,
+				renameActions
+			};
 		},
-		actions: [(_, { nextBlock }) => [raise$1({
-			type: "delete.block",
-			at: nextBlock.path
-		}), raise$1({
-			type: "insert.block",
-			block: nextBlock.node,
-			placement: "auto",
-			select: "none"
-		})]]
+		actions: [(_, { nextBlockPath, renamedBlock, renameActions }) => [
+			...renameActions,
+			raise$1({
+				type: "delete.block",
+				at: nextBlockPath
+			}),
+			raise$1({
+				type: "insert.block",
+				block: renamedBlock,
+				placement: "auto",
+				select: "none"
+			})
+		]]
 	}),
 	defineBehavior({
 		on: "delete.block",
@@ -13306,7 +13330,71 @@ const abstractAnnotationBehaviors = [
 			type: "delete"
 		})]]
 	})
-], mimeTypePriority = [
+];
+/**
+* A block merge folds `mergingBlock`'s children (and markDefs) into
+* `destinationBlock` by key. Any key the merging block shares with the
+* destination has to be renamed before the merge, or `insert.block`'s own
+* collision handling mints a fresh key for it, which reads on the wire as
+* that node being destroyed and a new one created instead of moved.
+*
+* Renames are raised as `set`/`child.set` events against the still-living
+* `mergingBlock`, so they land on the wire before the merge's `unset`.
+* `renamedBlock` mirrors the same renames applied to the value the caller
+* already captured, since raising the rename events now doesn't change
+* that captured value.
+*/
+function planMergeKeyRenames(args) {
+	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, destinationChildKeys = new Set(destinationBlock.children.map((child) => child._key)), destinationMarkDefKeys = new Set((destinationBlock.markDefs ?? []).map((markDef) => markDef._key)), markDefKeyMap = /* @__PURE__ */ new Map(), renamedMarkDefs = mergingBlock.markDefs?.map((markDef) => {
+		if (!destinationMarkDefKeys.has(markDef._key)) return markDef;
+		let newKey = context.keyGenerator();
+		return markDefKeyMap.set(markDef._key, newKey), {
+			...markDef,
+			_key: newKey
+		};
+	}), renameActions = [];
+	for (let markDef of mergingBlock.markDefs ?? []) {
+		let newKey = markDefKeyMap.get(markDef._key);
+		newKey && renameActions.push(raise$1({
+			type: "set",
+			at: [
+				...mergingBlockPath,
+				"markDefs",
+				{ _key: markDef._key },
+				"_key"
+			],
+			value: newKey
+		}));
+	}
+	let renamedChildren = mergingBlock.children.map((child) => {
+		let currentMarks = isSpan(context, child) ? child.marks : void 0, remappedMarks = currentMarks?.map((mark) => markDefKeyMap.get(mark) ?? mark), marksChanged = !!(remappedMarks && !isEqualMarks(remappedMarks, currentMarks)), newKey = destinationChildKeys.has(child._key) ? context.keyGenerator() : child._key, props = {};
+		return newKey !== child._key && (props._key = newKey), marksChanged && (props.marks = remappedMarks), Object.keys(props).length > 0 && renameActions.push(raise$1({
+			type: "child.set",
+			at: [
+				...mergingBlockPath,
+				"children",
+				{ _key: child._key }
+			],
+			props
+		})), marksChanged ? {
+			...child,
+			_key: newKey,
+			marks: remappedMarks
+		} : {
+			...child,
+			_key: newKey
+		};
+	});
+	return {
+		renamedBlock: {
+			...mergingBlock,
+			children: renamedChildren,
+			...mergingBlock.markDefs ? { markDefs: renamedMarkDefs } : {}
+		},
+		renameActions
+	};
+}
+const mimeTypePriority = [
 	"application/x-portable-text",
 	"application/json",
 	"text/markdown",