@markput/react 0.12.1 → 0.14.0

package/index.d.ts

@@ -10763,15 +10763,108 @@ declare function annotate(markup: Markup, params: {
  */
 declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#endregion
+//#region ../../core/src/shared/editorContracts.d.ts
+type TokenPath = readonly number[];
+type TokenAddress = {
+  readonly path: TokenPath;
+  readonly parseGeneration: number;
+};
+type Result<T, Reason extends string> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  reason: Reason;
+};
+type DomRef = (element: HTMLElement | null) => void;
+type RawRange = {
+  readonly start: number;
+  readonly end: number;
+};
+type RawSelection = {
+  readonly range: RawRange;
+  readonly direction?: 'forward' | 'backward';
+};
+type NodeLocationResult = Result<{
+  readonly address: TokenAddress;
+  readonly tokenElement: HTMLElement;
+  readonly textElement?: HTMLElement;
+  readonly rowElement?: HTMLElement;
+}, 'notIndexed' | 'outsideEditor' | 'control'>;
+type RawSelectionResult = Result<RawSelection, 'notIndexed' | 'outsideEditor' | 'control' | 'mixedBoundary' | 'invalidBoundary'>;
+type BoundaryPositionResult = Result<number, 'notIndexed' | 'outsideEditor' | 'control' | 'invalidBoundary' | 'composing'>;
+type EditResult = {
+  ok: true;
+  value: string;
+  accepted: 'immediate' | 'pendingControlledEcho';
+} | {
+  ok: false;
+  reason: 'readOnly' | 'invalidRange' | 'stale';
+};
+type CaretRecovery = {
+  readonly kind: 'caret';
+  readonly rawPosition: number;
+  readonly affinity?: 'before' | 'after';
+} | {
+  readonly kind: 'selection';
+  readonly selection: RawSelection;
+};
+type OptionalMarkFieldPatch = {
+  readonly kind: 'set';
+  readonly value: string;
+} | {
+  readonly kind: 'clear';
+};
+type MarkPatch = {
+  readonly value?: string;
+  readonly meta?: OptionalMarkFieldPatch;
+  readonly slot?: OptionalMarkFieldPatch;
+};
+type MarkSnapshot = {
+  readonly value: string;
+  readonly meta: string | undefined;
+  readonly slot: string | undefined;
+  readonly readOnly: boolean;
+};
+type MarkInfo = {
+  readonly address: TokenAddress;
+  readonly depth: number;
+  readonly hasNestedMarks: boolean;
+  readonly key: string;
+};
+type TokenShapeSnapshot = {
+  readonly kind: 'text';
+} | {
+  readonly kind: 'mark';
+  readonly descriptor: MarkupDescriptor;
+  readonly descriptorIndex: number;
+};
+type DomIndex = {
+  readonly generation: number;
+};
+type CaretLocation = {
+  readonly address: TokenAddress;
+  readonly role: 'row' | 'token' | 'text' | 'markDescendant';
+};
+type DomDiagnostic = {
+  readonly kind: 'missingRole' | 'stalePath' | 'outsideEditor' | 'controlBoundary' | 'mixedBoundary' | 'invalidBoundary' | 'renderReentry' | 'recoveryFailed' | 'missingContainer' | 'ambiguousStructure';
+  readonly path?: TokenPath;
+  readonly reason: string;
+};
+type EditSource = 'input' | 'paste' | 'cut' | 'overlay' | 'mark' | 'block' | 'drag';
+//#endregion
 //#region ../../core/src/features/caret/CaretFeature.d.ts
 declare class CaretFeature implements Feature {
   #private;
   private readonly _store;
-  readonly recovery: Signal<Recovery | undefined>;
+  readonly recovery: Signal<CaretRecovery | undefined>;
+  readonly location: Signal<CaretLocation | undefined>;
   readonly selecting: Signal<"drag" | "all" | undefined>;
   constructor(_store: Store);
   enable(): void;
   disable(): void;
+  placeAt(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
+  focus(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
 }
 //#endregion
 //#region ../../core/src/shared/signals/signal.d.ts
@@ -10855,10 +10948,22 @@ declare class ClipboardFeature {
 declare class DomFeature {
   #private;
   private readonly _store;
+  readonly index: Computed<DomIndex | undefined>;
+  readonly container: Signal<HTMLElement | null>;
+  readonly diagnostics: Event<DomDiagnostic>;
   constructor(_store: Store);
   enable(): void;
   disable(): void;
+  compositionStarted(): void;
+  compositionEnded(): void;
+  controlFor(ownerPath?: TokenPath): DomRef;
+  childrenFor(ownerPath: TokenPath): DomRef;
   reconcile(): void;
+  locateNode(node: Node): NodeLocationResult;
+  placeCaretAtRawPosition(rawPosition: number, affinity?: 'before' | 'after'): Result<void, 'notIndexed' | 'invalidBoundary'>;
+  focusAddress(address: TokenAddress, boundary?: 'start' | 'end'): Result<void, 'notIndexed' | 'stale'>;
+  rawPositionFromBoundary(node: Node, offset: number, affinity?: 'before' | 'after'): BoundaryPositionResult;
+  readRawSelection(): RawSelectionResult;
 }
 //#endregion
 //#region ../../core/src/features/drag/DragFeature.d.ts
@@ -10880,90 +10985,29 @@ declare class KeyboardFeature implements Feature {
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/shared/classes/MarkputHandler.d.ts
-declare class MarkputHandler {
-  private readonly store;
-  constructor(store: Store);
-  get container(): HTMLDivElement | null;
-  get overlay(): HTMLElement | null;
-  focus(): void;
-}
-//#endregion
-//#region ../../core/src/shared/classes/KeyGenerator.d.ts
-declare class KeyGenerator {
-  #private;
-  get(object: object): number | undefined;
-}
-//#endregion
-//#region ../../core/src/shared/classes/NodeProxy.d.ts
-declare class NodeProxy {
-  #private;
-  get target(): HTMLElement | undefined;
-  set target(value: Node | HTMLElement | EventTarget | undefined | null);
-  get next(): NodeProxy;
-  get prev(): NodeProxy;
-  get isSpan(): boolean;
-  get isMark(): boolean;
-  get isEditable(): boolean;
-  get isCaretAtBeginning(): boolean;
-  get isCaretAtEnd(): boolean;
-  get index(): number;
-  get caret(): number;
-  set caret(value: number);
-  get length(): number;
-  get content(): string;
-  set content(value: string | undefined);
-  get head(): HTMLElement | null;
-  get tail(): HTMLElement | null;
-  get isFocused(): boolean;
-  constructor(target: Node | EventTarget | null | undefined, store: Store);
-  setCaretToEnd(): void;
-  focus(): void;
-  clear(): void;
-}
-//#endregion
 //#region ../../core/src/features/lifecycle/LifecycleFeature.d.ts
 declare class LifecycleFeature implements Feature {
-  private readonly _store;
   readonly mounted: Event<void>;
   readonly unmounted: Event<void>;
   readonly rendered: Event<void>;
-  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/mark/MarkHandler.d.ts
-interface RefAccessor<T> {
-  current: T | null;
-}
-declare class MarkHandler<T extends HTMLElement = HTMLElement> {
+//#region ../../core/src/features/mark/MarkController.d.ts
+declare class MarkController {
   #private;
-  readonly ref: RefAccessor<T>;
-  constructor(param: {
-    ref: RefAccessor<T>;
-    store: Store;
-    token: MarkToken;
-  });
-  get readOnly(): boolean | undefined;
-  set readOnly(value: boolean | undefined);
-  get content(): string;
-  set content(value: string);
-  get value(): string | undefined;
-  set value(v: string | undefined);
+  private readonly store;
+  private readonly address;
+  private readonly snapshot;
+  constructor(store: Store, address: TokenAddress, snapshot: MarkSnapshot, shape: TokenShapeSnapshot);
+  static fromToken(store: Store, token: MarkToken): MarkController;
+  get value(): string;
   get meta(): string | undefined;
-  set meta(v: string | undefined);
   get slot(): string | undefined;
-  get depth(): number;
-  get hasChildren(): boolean;
-  get parent(): MarkToken | undefined;
-  get tokens(): Token[];
-  change: (props: {
-    content: string;
-    value?: string;
-    meta?: string;
-  }) => void;
-  remove: () => void;
+  get readOnly(): boolean;
+  remove(): EditResult;
+  update(patch: MarkPatch): EditResult;
 }
 //#endregion
 //#region ../../core/src/features/slots/types.d.ts
@@ -10977,7 +11021,6 @@ interface OverlaySlot {
 //#region ../../core/src/features/slots/SlotsFeature.d.ts
 declare class SlotsFeature implements Feature {
   private readonly _store;
-  readonly container: Signal<HTMLDivElement | null>;
   readonly isBlock: Computed<boolean>;
   readonly isDraggable: Computed<boolean>;
   readonly containerComponent: Computed<Slot>;
@@ -10997,23 +11040,14 @@ declare class SlotsFeature implements Feature {
 //#endregion
 //#region ../../core/src/features/mark/MarkFeature.d.ts
 declare class MarkFeature implements Feature {
-  #private;
   private readonly _store;
   readonly enabled: Computed<boolean>;
   readonly slot: MarkSlot;
-  readonly remove: Event<{
-    token: Token;
-  }>;
   constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/mark/types.d.ts
-interface MarkOptions {
-  controlled?: boolean;
-}
-//#endregion
 //#region ../../core/src/features/overlay/OverlayFeature.d.ts
 declare class OverlayFeature implements Feature {
   #private;
@@ -11031,40 +11065,72 @@ declare class OverlayFeature implements Feature {
   disable(): void;
 }
 //#endregion
+//#region ../../core/src/features/parsing/tokenIndex.d.ts
+type TokenIndex = {
+  readonly generation: number;
+  pathFor(token: Token): TokenPath | undefined;
+  addressFor(path: TokenPath): TokenAddress | undefined;
+  resolve(path: TokenPath): Token | undefined;
+  resolveAddress(address: TokenAddress, expected?: TokenShapeSnapshot): Result<Token, 'stale'>;
+  key(path: TokenPath): string;
+  equals(a: TokenPath, b: TokenPath): boolean;
+};
+//#endregion
 //#region ../../core/src/features/parsing/ParseFeature.d.ts
 declare class ParsingFeature implements Feature {
   #private;
   private readonly _store;
   readonly tokens: Signal<Token[]>;
+  readonly index: Computed<TokenIndex>;
   readonly parser: Computed<Parser | undefined>;
   readonly reparse: Event<void>;
   constructor(_store: Store);
+  parseValue(value: string): Token[];
+  acceptTokens(tokens: Token[]): void;
   enable(): void;
   disable(): void;
-  sync(): void;
+  sync(value?: string): void;
 }
 //#endregion
 //#region ../../core/src/features/value/ValueFeature.d.ts
 declare class ValueFeature implements Feature {
   #private;
   private readonly _store;
-  readonly last: Signal<string | undefined>;
-  readonly next: Signal<string | undefined>;
-  readonly current: Computed<string>;
+  readonly current: Signal<string>;
+  readonly isControlledMode: Computed<boolean>;
   readonly change: Event<void>;
   constructor(_store: Store);
   enable(): void;
   disable(): void;
+  replaceRange(range: RawRange, replacement: string, options?: {
+    recover?: CaretRecovery;
+    source?: EditSource;
+  }): EditResult;
+  replaceAll(next: string, options?: {
+    recover?: CaretRecovery;
+    source?: EditSource;
+  }): EditResult;
+}
+//#endregion
+//#region ../../core/src/shared/classes/MarkputHandler.d.ts
+declare class MarkputHandler {
+  private readonly store;
+  constructor(store: Store);
+  get container(): HTMLElement | null;
+  get overlay(): HTMLElement | null;
+  focus(): void;
+}
+//#endregion
+//#region ../../core/src/shared/classes/KeyGenerator.d.ts
+declare class KeyGenerator {
+  #private;
+  get(object: object): number | undefined;
 }
 //#endregion
 //#region ../../core/src/store/Store.d.ts
 declare class Store {
   readonly key: KeyGenerator;
   readonly blocks: BlockRegistry;
-  readonly nodes: {
-    focus: NodeProxy;
-    input: NodeProxy;
-  };
   readonly props: PropsFeature;
   readonly handler: MarkputHandler;
   readonly lifecycle: LifecycleFeature;
@@ -11151,21 +11217,12 @@ type OverlayMatch<TOption = CoreOption> = {
    * Html element, in which was a overlayMatch
    */
   node: Node;
-  /**
-   * Start position of a overlayMatch
-   */
-  index: number;
+  range: RawRange;
   /**
    * OverlayMatch's option
    */
   option: TOption;
 };
-type Recovery = {
-  anchor: NodeProxy;
-  isNext?: boolean;
-  caret: number;
-  childIndex?: number;
-};
 type OverlayTrigger = Array<'change' | 'selectionChange'> | 'change' | 'selectionChange' | 'none';
 type CSSProperties$1 = Properties<string | number>;
 type DataAttributes = Record<`data${Capitalize<string>}`, string | number | boolean | undefined>;
@@ -11346,7 +11403,10 @@ interface MarkedInputProps<TMarkProps = MarkProps, TOverlayProps extends CoreOpt
 declare function MarkedInput<TMarkProps = MarkProps, TOverlayProps extends CoreOption['overlay'] = OverlayProps>(props: MarkedInputProps<TMarkProps, TOverlayProps>): _$react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/lib/hooks/useMark.d.ts
-declare const useMark: <T extends HTMLElement = HTMLElement>(options?: MarkOptions) => MarkHandler<T>;
+declare const useMark: () => MarkController;
+//#endregion
+//#region src/lib/hooks/useMarkInfo.d.ts
+declare const useMarkInfo: () => MarkInfo;
 //#endregion
 //#region src/lib/hooks/useOverlay.d.ts
 interface OverlayHandler {
@@ -11370,5 +11430,5 @@ type ObjectSelector = Record<string, Selectable<unknown> | unknown>;
 declare function useMarkput<T>(selector: (store: Store) => Selectable<T>): T;
 declare function useMarkput<R extends ObjectSelector>(selector: (store: Store) => R): SignalValues<R>;
 //#endregion
-export { MarkHandler, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkput, useOverlay };
+export { MarkController, type MarkProps, type MarkToken, MarkedInput, type MarkedInputProps, MarkputHandler, type Markup, type Option, type OverlayHandler, type OverlayProps, type TextToken, type Token, annotate, denote, useMark, useMarkInfo, useMarkput, useOverlay };
 //# sourceMappingURL=index.d.ts.map