@markput/react 0.11.0 → 0.12.1

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
@@ -10755,22 +10763,51 @@ declare function annotate(markup: Markup, params: {
  */
 declare function denote(value: string, callback: (mark: MarkToken) => string, markups: Markup[]): string;
 //#endregion
-//#region ../../core/src/features/arrownav/ArrowNavFeature.d.ts
-declare class ArrowNavFeature {
+//#region ../../core/src/features/caret/CaretFeature.d.ts
+declare class CaretFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly recovery: Signal<Recovery | undefined>;
+  readonly selecting: Signal<"drag" | "all" | undefined>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/block-editing/BlockEditFeature.d.ts
-declare class BlockEditFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
-  enable(): void;
-  disable(): void;
+//#region ../../core/src/shared/signals/signal.d.ts
+interface Signal<T> {
+  (): T;
+  (value: T | undefined): void;
+}
+type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
+interface Computed<T> {
+  (): T;
+}
+interface Event<T = void> {
+  (payload: T): void;
+  read(): T | undefined;
+}
+//#endregion
+//#region ../../core/src/features/props/PropsFeature.d.ts
+declare class PropsFeature {
+  private readonly _store;
+  readonly value: Signal<string | undefined>;
+  readonly defaultValue: Signal<string | undefined>;
+  readonly onChange: Signal<((value: string) => void) | undefined>;
+  readonly options: Signal<CoreOption[]>;
+  readonly readOnly: Signal<boolean>;
+  readonly layout: Signal<"inline" | "block">;
+  readonly draggable: Signal<boolean | DraggableConfig>;
+  readonly showOverlayOn: Signal<OverlayTrigger>;
+  readonly Span: Signal<_$react.ElementType | undefined>;
+  readonly Mark: Signal<_$react.ElementType | undefined>;
+  readonly Overlay: Signal<_$react.ElementType | undefined>;
+  readonly className: Signal<string | undefined>;
+  readonly style: Signal<CSSProperties$1 | undefined>;
+  readonly slots: Signal<CoreSlots | undefined>;
+  readonly slotProps: Signal<CoreSlotProps | undefined>;
+  constructor(_store: Store);
+  set(values: Partial<SignalValues<typeof this>>): void;
 }
 //#endregion
 //#region ../../core/src/store/BlockStore.d.ts
@@ -10805,17 +10842,8 @@ declare class BlockRegistry {
   get(token: object): BlockStore;
 }
 //#endregion
-//#region ../../core/src/features/clipboard/CopyFeature.d.ts
-declare class CopyFeature {
-  #private;
-  private readonly store;
-  constructor(store: Store);
-  enable(): void;
-  disable(): void;
-}
-//#endregion
-//#region ../../core/src/features/drag/DragFeature.d.ts
-declare class DragFeature {
+//#region ../../core/src/features/clipboard/ClipboardFeature.d.ts
+declare class ClipboardFeature {
   #private;
   private readonly store;
   constructor(store: Store);
@@ -10823,30 +10851,31 @@ declare class DragFeature {
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/editable/ContentEditableFeature.d.ts
-declare class ContentEditableFeature {
+//#region ../../core/src/features/dom/DomFeature.d.ts
+declare class DomFeature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
-  sync(): void;
+  reconcile(): void;
 }
 //#endregion
-//#region ../../core/src/features/events/SystemListenerFeature.d.ts
-declare class SystemListenerFeature {
+//#region ../../core/src/features/drag/DragFeature.d.ts
+declare class DragFeature {
   #private;
   private readonly store;
+  readonly action: Event<DragAction>;
   constructor(store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/focus/FocusFeature.d.ts
-declare class FocusFeature {
+//#region ../../core/src/features/keyboard/KeyboardFeature.d.ts
+declare class KeyboardFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
@@ -10893,65 +10922,141 @@ declare class NodeProxy {
   clear(): void;
 }
 //#endregion
-//#region ../../core/src/shared/signals/signal.d.ts
-interface Signal<T> {
-  (): T;
-  (value: T | undefined): void;
+//#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;
 }
-type SignalValues<T> = { [K in keyof T]: T[K] extends Signal<infer V> | Computed<infer V> ? V : T[K] };
-interface Computed<T> {
-  (): T;
+//#endregion
+//#region ../../core/src/features/mark/MarkHandler.d.ts
+interface RefAccessor<T> {
+  current: T | null;
 }
-interface Event<T = void> {
-  (payload: T): void;
-  read(): T | undefined;
+declare class MarkHandler<T extends HTMLElement = HTMLElement> {
+  #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);
+  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;
+}
+//#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/features/input/InputFeature.d.ts
-declare class InputFeature {
+//#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>;
+  readonly containerProps: Computed<{
+    className: string | undefined;
+    style?: CSSProperties$1;
+    [key: string]: unknown;
+  }>;
+  readonly blockComponent: Computed<Slot>;
+  readonly blockProps: Computed<Record<string, unknown> | undefined>;
+  readonly spanComponent: Computed<Slot>;
+  readonly spanProps: Computed<Record<string, unknown> | undefined>;
+  constructor(_store: Store);
+  enable(): void;
+  disable(): void;
+}
+//#endregion
+//#region ../../core/src/features/mark/MarkFeature.d.ts
+declare class MarkFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  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 {
+declare class OverlayFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly match: Signal<OverlayMatch | undefined>;
+  readonly element: Signal<HTMLElement | null>;
+  readonly slot: OverlaySlot;
+  readonly select: Event<{
+    mark: Token;
+    match: OverlayMatch;
+  }>;
+  readonly close: Event<void>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
 //#region ../../core/src/features/parsing/ParseFeature.d.ts
-declare class ParseFeature {
+declare class ParsingFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly tokens: Signal<Token[]>;
+  readonly parser: Computed<Parser | undefined>;
+  readonly reparse: Event<void>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
   sync(): void;
 }
 //#endregion
-//#region ../../core/src/features/selection/TextSelectionFeature.d.ts
-declare class TextSelectionFeature {
+//#region ../../core/src/features/value/ValueFeature.d.ts
+declare class ValueFeature implements Feature {
   #private;
-  private readonly store;
-  constructor(store: Store);
+  private readonly _store;
+  readonly last: Signal<string | undefined>;
+  readonly next: Signal<string | undefined>;
+  readonly current: Computed<string>;
+  readonly change: Event<void>;
+  constructor(_store: Store);
   enable(): void;
   disable(): void;
 }
 //#endregion
-//#region ../../core/src/features/slots/types.d.ts
-interface MarkSlot {
-  (): (token: Token) => readonly [unknown, unknown];
-}
-interface OverlaySlot {
-  (): (option?: CoreOption, defaultComponent?: unknown) => readonly [unknown, unknown];
-}
-//#endregion
 //#region ../../core/src/store/Store.d.ts
 declare class Store {
   readonly key: KeyGenerator;
@@ -10960,94 +11065,39 @@ declare class Store {
     focus: NodeProxy;
     input: NodeProxy;
   };
-  readonly props: {
-    value: Signal<string | undefined>;
-    defaultValue: Signal<string | undefined>;
-    onChange: Signal<((value: string) => void) | undefined>;
-    options: Signal<CoreOption[]>;
-    readOnly: Signal<boolean>;
-    layout: Signal<"inline" | "block">;
-    draggable: Signal<boolean | DraggableConfig>;
-    showOverlayOn: Signal<OverlayTrigger>;
-    Span: Signal<unknown>;
-    Mark: Signal<unknown>;
-    Overlay: Signal<unknown>;
-    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>;
-    selecting: Signal<"drag" | "all" | undefined>;
-    overlayMatch: Signal<OverlayMatch | undefined>;
-  };
-  readonly computed: {
-    hasMark: Computed<boolean>;
-    isBlock: Computed<boolean>;
-    isDraggable: Computed<boolean>;
-    parser: Computed<Parser | undefined>;
-    currentValue: Computed<string>;
-    containerComponent: Computed<unknown>;
-    containerProps: Computed<{
-      className: string | undefined;
-      style?: CSSProperties$1;
-      [key: string]: unknown;
-    }>;
-    blockComponent: Computed<unknown>;
-    blockProps: Computed<Record<string, unknown> | undefined>;
-    spanComponent: Computed<unknown>;
-    spanProps: Computed<Record<string, unknown> | undefined>;
-    overlay: OverlaySlot;
-    mark: MarkSlot;
-  };
-  readonly event: {
-    /** 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<{
-      token: Token;
-    }>; /** Fires when the user selects an overlay option — annotates markup into the current input span */
-    select: 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 */
-    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 props: PropsFeature;
   readonly handler: MarkputHandler;
-  readonly features: {
-    overlay: OverlayFeature;
-    focus: FocusFeature;
-    input: InputFeature;
-    blockEditing: BlockEditFeature;
-    arrowNav: ArrowNavFeature;
-    system: SystemListenerFeature;
-    textSelection: TextSelectionFeature;
-    contentEditable: ContentEditableFeature;
-    drag: DragFeature;
-    copy: CopyFeature;
-    parse: ParseFeature;
-  };
+  readonly lifecycle: LifecycleFeature;
+  readonly value: ValueFeature;
+  readonly mark: MarkFeature;
+  readonly overlay: OverlayFeature;
+  readonly slots: SlotsFeature;
+  readonly caret: CaretFeature;
+  readonly keyboard: KeyboardFeature;
+  readonly dom: DomFeature;
+  readonly drag: DragFeature;
+  readonly clipboard: ClipboardFeature;
+  readonly parsing: ParsingFeature;
   constructor();
-  setProps(values: Partial<SignalValues<typeof this.props>>): void;
-  bumpTokens(): 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).
@@ -11120,9 +11170,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> & {
@@ -11156,47 +11206,13 @@ type DragAction = {
   index: number;
 };
 interface DragActions {
-  dragAction: {
+  action: {
     (action: DragAction): void;
   };
 }
-//#endregion
-//#region ../../core/src/features/mark/MarkHandler.d.ts
-interface RefAccessor<T> {
-  current: T | null;
-}
-declare class MarkHandler<T extends HTMLElement = HTMLElement> {
-  #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);
-  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;
-}
-//#endregion
-//#region ../../core/src/features/mark/types.d.ts
-interface MarkOptions {
-  controlled?: boolean;
+interface Feature {
+  enable(): void;
+  disable(): void;
 }
 //#endregion
 //#region src/types.d.ts