@markput/react 0.10.1 → 0.12.0

package/index.d.ts

@@ -1,6 +1,14 @@
+import * as _$react from "react";
 import { CSSProperties, ComponentType, ElementType, ReactNode, Ref, RefObject } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
+//#region src/augment.d.ts
+declare module '@markput/core' {
+  interface SlotRegistry {
+    default: ElementType;
+  }
+} //# sourceMappingURL=augment.d.ts.map
+//#endregion
 //#region ../../core/src/features/parsing/parser/constants.d.ts
 /**
  * Constants for ParserV2 - modern markup parser with nesting support
@@ -10758,7 +10766,7 @@ declare function denote(value: string, callback: (mark: MarkToken) => string, ma
 //#region ../../core/src/features/arrownav/ArrowNavFeature.d.ts
 declare class ArrowNavFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10767,7 +10775,7 @@ declare class ArrowNavFeature {
 //#region ../../core/src/features/block-editing/BlockEditFeature.d.ts
 declare class BlockEditFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10808,7 +10816,7 @@ declare class BlockRegistry {
 //#region ../../core/src/features/clipboard/CopyFeature.d.ts
 declare class CopyFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10817,7 +10825,7 @@ declare class CopyFeature {
 //#region ../../core/src/features/drag/DragFeature.d.ts
 declare class DragFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10826,7 +10834,7 @@ declare class DragFeature {
 //#region ../../core/src/features/editable/ContentEditableFeature.d.ts
 declare class ContentEditableFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10836,7 +10844,7 @@ declare class ContentEditableFeature {
 //#region ../../core/src/features/events/SystemListenerFeature.d.ts
 declare class SystemListenerFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10845,7 +10853,7 @@ declare class SystemListenerFeature {
 //#region ../../core/src/features/focus/FocusFeature.d.ts
 declare class FocusFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10853,7 +10861,7 @@ declare class FocusFeature {
 //#endregion
 //#region ../../core/src/shared/classes/MarkputHandler.d.ts
 declare class MarkputHandler {
-  private store;
+  private readonly store;
   constructor(store: Store);
   get container(): HTMLDivElement | null;
   get overlay(): HTMLElement | null;
@@ -10876,8 +10884,8 @@ declare class NodeProxy {
   get isSpan(): boolean;
   get isMark(): boolean;
   get isEditable(): boolean;
-  get isCaretAtBeginning(): boolean | undefined;
-  get isCaretAtEnd(): boolean | undefined;
+  get isCaretAtBeginning(): boolean;
+  get isCaretAtEnd(): boolean;
   get index(): number;
   get caret(): number;
   set caret(value: number);
@@ -10897,30 +10905,20 @@ declare class NodeProxy {
 interface Signal<T> {
   (): T;
   (value: T | undefined): void;
-  use(): T;
 }
-/**
- * Derives a plain-value object type from an object of signals.
- * `{ foo: Signal<string>, bar: Signal<number> }` → `{ foo: string, bar: number }`
- */
-type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : never };
+type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
 interface Computed<T> {
   (): T;
-  use(): T;
 }
 interface Event<T = void> {
-  /** Emit — always fires even when payload reference is unchanged. */
   (payload: T): void;
-  /** Read/subscribe — auto-tracks inside effects. Returns latest payload or undefined. */
   read(): T | undefined;
-  /** Framework hook bridge. */
-  use(): T | undefined;
 }
 //#endregion
 //#region ../../core/src/features/input/InputFeature.d.ts
 declare class InputFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10929,7 +10927,7 @@ declare class InputFeature {
 //#region ../../core/src/features/overlay/OverlayFeature.d.ts
 declare class OverlayFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
@@ -10938,23 +10936,30 @@ declare class OverlayFeature {
 //#region ../../core/src/features/parsing/ParseFeature.d.ts
 declare class ParseFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
   sync(): void;
-  hasChanged(): boolean;
 }
 //#endregion
 //#region ../../core/src/features/selection/TextSelectionFeature.d.ts
 declare class TextSelectionFeature {
   #private;
-  private store;
+  private readonly store;
   constructor(store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
+//#region ../../core/src/features/slots/types.d.ts
+interface MarkSlot {
+  (): (token: Token) => readonly [Slot, Record<string, unknown>];
+}
+interface OverlaySlot {
+  (): (option?: CoreOption, defaultComponent?: Slot) => readonly [Slot, Record<string, unknown>];
+}
+//#endregion
 //#region ../../core/src/store/Store.d.ts
 declare class Store {
   readonly key: KeyGenerator;
@@ -10963,70 +10968,71 @@ declare class Store {
     focus: NodeProxy;
     input: NodeProxy;
   };
-  readonly state: {
-    tokens: Signal<Token[]>;
+  readonly props: {
     value: Signal<string | undefined>;
     defaultValue: Signal<string | undefined>;
-    previousValue: Signal<string | undefined>;
-    innerValue: Signal<string | undefined>;
-    recovery: Signal<Recovery | undefined>;
-    selecting: Signal<"drag" | "all" | undefined>;
-    drag: Signal<boolean | {
-      alwaysShowHandle: boolean;
-    }>;
-    overlayMatch: Signal<OverlayMatch | undefined>;
-    overlayTrigger: Signal<((option: CoreOption) => string | undefined) | undefined>;
-    showOverlayOn: Signal<OverlayTrigger>;
     onChange: Signal<((value: string) => void) | undefined>;
     options: Signal<CoreOption[]>;
     readOnly: Signal<boolean>;
-    Span: Signal<unknown>;
-    Mark: Signal<unknown>;
-    Overlay: Signal<unknown>;
+    layout: Signal<"inline" | "block">;
+    draggable: Signal<boolean | DraggableConfig>;
+    showOverlayOn: Signal<OverlayTrigger>;
+    Span: Signal<_$react.ElementType | undefined>;
+    Mark: Signal<_$react.ElementType | undefined>;
+    Overlay: Signal<_$react.ElementType | undefined>;
     className: Signal<string | undefined>;
     style: Signal<CSSProperties$1 | undefined>;
     slots: Signal<CoreSlots | undefined>;
     slotProps: Signal<CoreSlotProps | undefined>;
   };
+  readonly state: {
+    tokens: Signal<Token[]>;
+    previousValue: Signal<string | undefined>;
+    innerValue: Signal<string | undefined>;
+    recovery: Signal<Recovery | undefined>;
+    container: Signal<HTMLDivElement | null>;
+    overlay: Signal<HTMLElement | null>;
+    selecting: Signal<"drag" | "all" | undefined>;
+    overlayMatch: Signal<OverlayMatch | undefined>;
+  };
   readonly computed: {
     hasMark: Computed<boolean>;
+    isBlock: Computed<boolean>;
+    isDraggable: Computed<boolean>;
     parser: Computed<Parser | undefined>;
-    containerClass: Computed<string | undefined>;
-    containerStyle: Computed<unknown>;
-  };
-  readonly slot: {
-    container: Slot;
-    block: Slot;
-    span: Slot;
+    currentValue: Computed<string>;
+    containerComponent: Computed<Slot>;
+    containerProps: Computed<{
+      className: string | undefined;
+      style?: CSSProperties$1;
+      [key: string]: unknown;
+    }>;
+    blockComponent: Computed<Slot>;
+    blockProps: Computed<Record<string, unknown> | undefined>;
+    spanComponent: Computed<Slot>;
+    spanProps: Computed<Record<string, unknown> | undefined>;
     overlay: OverlaySlot;
     mark: MarkSlot;
   };
-  readonly event: {
+  readonly emit: {
     /** Fires after user input or programmatic mark change — triggers serialization, `onChange`, and re-parse */change: Event<void>; /** Triggers a re-parse of tokens from the current content */
-    parse: Event<void>; /** Removes a mark token from editor content */
-    delete: Event<{
+    reparse: Event<void>; /** Removes a mark token from editor content */
+    markRemove: Event<{
       token: Token;
     }>; /** Fires when the user selects an overlay option — annotates markup into the current input span */
-    select: Event<{
+    overlaySelect: Event<{
       mark: Token;
       match: OverlayMatch;
     }>; /** Dismisses the overlay by clearing the current `overlayMatch` */
-    clearOverlay: Event<void>; /** Probes the caret/text position for overlay trigger patterns and shows overlay if matched */
-    checkOverlay: Event<void>; /** Syncs `contentEditable` attributes and `textContent` of child elements to match token state */
-    sync: Event<void>; /** Restores the caret position after a DOM re-render using the saved recovery state */
-    recoverFocus: Event<void>; /** Dispatches drag-mode row operations (reorder, add, delete, duplicate) */
-    dragAction: Event<DragAction>; /** Signals the framework component has received new props — triggers conditional re-parse if value/options changed */
-    updated: Event<void>; /** Fires after the framework has committed new token elements to the DOM — kicks off sync and focus recovery */
-    afterTokensRendered: Event<void>; /** Lifecycle: editor component added to the DOM — enables all features */
+    overlayClose: Event<void>; /** Post-render DOM alignment: aligns `contentEditable` attributes and `textContent` of child elements to token state. Emitted synchronously by `FocusFeature` inside the `rendered` handler (framework layout-effect phase). Load-bearing for post-commit DOM consistency — do not delete without reproducing this timing. */
+    sync: Event<void>; /** Dispatches drag-mode row operations (reorder, add, delete, duplicate) */
+    drag: Event<DragAction>; /** Fires after the framework has committed new token elements to the DOM — kicks off sync and focus recovery */
+    rendered: Event<void>; /** Lifecycle: editor component added to the DOM — enables all features */
     mounted: Event<void>; /** Lifecycle: editor component removed from the DOM — disables all features and cleans up subscriptions */
     unmounted: Event<void>;
   };
-  readonly refs: {
-    container: HTMLDivElement | null;
-    overlay: HTMLElement | null;
-  };
   readonly handler: MarkputHandler;
-  readonly features: {
+  readonly feature: {
     overlay: OverlayFeature;
     focus: FocusFeature;
     input: InputFeature;
@@ -11040,10 +11046,26 @@ declare class Store {
     parse: ParseFeature;
   };
   constructor();
-  setState(values: Partial<SignalValues<typeof this.state>>): void;
+  setProps(values: Partial<SignalValues<typeof this.props>>): void;
 }
 //#endregion
 //#region ../../core/src/shared/types.d.ts
+/**
+ * Registry interface used as a module-augmentation target. Framework packages
+ * add a `default` property whose type is the framework's component type.
+ *
+ * @example React augmentation
+ * declare module '@markput/core' {
+ *   interface SlotRegistry {
+ *     default: import('react').ElementType
+ *   }
+ * }
+ *
+ * Without augmentation, `Slot` falls back to `unknown`.
+ */
+interface SlotRegistry {}
+/** Framework-provided component type. Resolves to `unknown` unless `SlotRegistry` is augmented. */
+type Slot = keyof SlotRegistry extends never ? unknown : SlotRegistry[keyof SlotRegistry];
 /**
  * Core option for markups - Framework-agnostic configuration.
  * Extended by framework-specific Option types (e.g., React Option).
@@ -11116,9 +11138,9 @@ type OverlayTrigger = Array<'change' | 'selectionChange'> | 'change' | 'selectio
 type CSSProperties$1 = Properties<string | number>;
 type DataAttributes = Record<`data${Capitalize<string>}`, string | number | boolean | undefined>;
 interface CoreSlots {
-  container?: unknown;
-  block?: unknown;
-  span?: unknown;
+  container?: Slot;
+  block?: Slot;
+  span?: Slot;
 }
 interface CoreSlotProps {
   container?: Record<string, unknown> & {
@@ -11134,6 +11156,9 @@ interface CoreSlotProps {
     style?: CSSProperties$1;
   };
 }
+interface DraggableConfig {
+  alwaysShowHandle?: boolean;
+}
 type DragAction = {
   type: 'reorder';
   source: number;
@@ -11149,25 +11174,11 @@ type DragAction = {
   index: number;
 };
 interface DragActions {
-  dragAction: {
+  drag: {
     (action: DragAction): void;
   };
 }
 //#endregion
-//#region ../../core/src/features/slots/types.d.ts
-interface Slot {
-  use(): readonly unknown[];
-  get(): readonly unknown[];
-}
-interface MarkSlot {
-  use(token: Token): readonly unknown[];
-  get(token: Token): readonly unknown[];
-}
-interface OverlaySlot {
-  use(option?: CoreOption, defaultComponent?: unknown): readonly unknown[];
-  get(option?: CoreOption, defaultComponent?: unknown): readonly unknown[];
-}
-//#endregion
 //#region ../../core/src/features/mark/MarkHandler.d.ts
 interface RefAccessor<T> {
   current: T | null;
@@ -11325,13 +11336,14 @@ interface MarkedInputProps<TMarkProps = MarkProps, TOverlayProps extends CoreOpt
   onChange?: (value: string) => void;
   /** Read-only mode */
   readOnly?: boolean;
-  /** Enable drag mode: each individual token (mark or text) becomes its own draggable row.
-   * One mark per row, one text fragment per row.
-   * Adjacent marks need no separator; adjacent text rows are separated by `\n\n`.
+  /** Layout mode: 'inline' renders tokens in a single flow, 'block' stacks each token as its own row.
+   * @default 'inline'
    */
-  drag?: boolean | {
-    alwaysShowHandle: boolean;
-  };
+  layout?: 'inline' | 'block';
+  /** Enable drag interaction on block rows. Only effective when layout='block'.
+   * @default false
+   */
+  draggable?: boolean | DraggableConfig;
 }
 declare function MarkedInput<TMarkProps = MarkProps, TOverlayProps extends CoreOption['overlay'] = OverlayProps>(props: MarkedInputProps<TMarkProps, TOverlayProps>): _$react_jsx_runtime0.JSX.Element;
 //#endregion
@@ -11349,10 +11361,16 @@ interface OverlayHandler {
     value: string;
     meta?: string;
   }) => void;
-  match: OverlayMatch<Option>;
+  match: OverlayMatch<Option> | undefined;
   ref: RefObject<HTMLElement | null>;
 }
 declare function useOverlay(): OverlayHandler;
 //#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, useOverlay };
+//#region src/lib/hooks/useMarkput.d.ts
+type Selectable<T> = Signal<T> | Computed<T>;
+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 };
 //# sourceMappingURL=index.d.ts.map