@inditextech/weave-sdk 5.7.0-SNAPSHOT.596.1 → 5.7.0-SNAPSHOT.599.1

package/dist/types.d.ts

@@ -1869,15 +1869,58 @@ declare class WeaveTextNode extends WeaveNode {
  * `text` is a derived mirror: block texts joined by `\n`.
  */
 type WeaveTextMarks = {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strike?: boolean;
+  color?: string;
+  /** Ratio of the node base `fontSize` (1 is omitted). */
+  size?: number;
+  family?: string;
+  /** Multiplier of the run font size (clamped 0.5 to 4). */
+  lineHeight?: number;
   link?: string;
   [mark: string]: unknown;
 };
+type WeaveTextMarkKey = 'bold' | 'italic' | 'underline' | 'strike' | 'color' | 'size' | 'family' | 'lineHeight' | 'link';
+type WeaveTextListKind = 'ul' | 'ol';
+type WeaveTextBlockAlign = 'left' | 'center' | 'right';
 type WeaveTextRun = {
   t: string;
   m?: WeaveTextMarks;
 };
 type WeaveTextBlock = {
   runs: WeaveTextRun[];
+  kind?: WeaveTextListKind;
+  depth?: number;
+  start?: number;
+  align?: WeaveTextBlockAlign;
+};
+type MarkState = 'all' | 'none' | 'some';
+type MarkQuery = {
+  state: MarkState;
+  value?: unknown;
+};
+type WeaveTextSelectionFormat = {
+  bold: MarkQuery;
+  italic: MarkQuery;
+  underline: MarkQuery;
+  strike: MarkQuery;
+  color: MarkQuery;
+  family: MarkQuery;
+  link: MarkQuery;
+  lineHeight: MarkQuery;
+  /** Paragraph alignment of the blocks in the range. */
+  align: {
+    state: MarkState;
+    value?: WeaveTextBlockAlign;
+  };
+  /** `value` in px (ratio * base); `none` reports the base size. */
+  size: MarkQuery;
+  list: {
+    kind: WeaveTextListKind | 'none' | 'mixed';
+    depth?: number;
+  };
 };
 //#endregion
 //#region src/nodes/text-v2/layout/engine.d.ts
@@ -1899,6 +1942,8 @@ type TextLayoutStyle = {
   letterSpacing: number;
   wrap: TextWrap;
   align: TextAlign;
+  /** List indent per depth, as a multiple of `fontSize` (default 1.5). */
+  indentStep?: number;
 };
 /** Bounds supplied by the target. `undefined` width/height means "auto". */
 type TextLayoutBounds = {
@@ -1913,6 +1958,19 @@ type LayoutSegment = {
   /** x offset relative to the line start. */
   x: number;
   width: number;
+  /** Run index inside its paragraph (hit testing / hover). */
+  run: number;
+  /** Resolved canvas font and size (px) of the run. */
+  font: string;
+  fontSize: number;
+};
+type LayoutMarker = {
+  text: string;
+  /** x relative to the content box (before padding). */
+  x: number;
+  font: string;
+  fontSize: number;
+  color?: string;
 };
 type LayoutLine = {
   paragraph: number;
@@ -1927,6 +1985,14 @@ type LayoutLine = {
   /** Alignment x offset (0 for left). */
   offsetX: number;
   y: number;
+  /** Line box height and baseline offset from the line top. */
+  height: number;
+  baseline: number;
+  /** Indent of the text (list blocks), already included in `offsetX`. */
+  indent: number;
+  marker?: LayoutMarker;
+  /** Resolved paragraph alignment. */
+  align: TextAlign;
   segments: LayoutSegment[];
   lastInParagraph: boolean;
 };
@@ -1937,10 +2003,17 @@ type TextLayout = {
   /** Font size, like `Konva.Text.getTextHeight()`. */
   textHeight: number;
   lineHeightPx: number;
+  /** Sum of line heights (without padding). */
+  contentHeight: number;
   /** Resolved node size, like `Konva.Text.width()/height()`. */
   width: number;
   height: number;
 };
+type FontMetrics = {
+  ascent: number;
+  descent: number;
+};
+type MetricsProvider = (font: string, size: number) => FontMetrics;
 declare class TextLayoutEngine {
   private readonly measure;
   private readonly cache;
@@ -1948,11 +2021,14 @@ declare class TextLayoutEngine {
   /** Entries by signature, so paragraphs that shifted index are reused. */
   private pool;
   private lastParagraphsRelaid;
-  constructor(measurer?: TextMeasurer);
+  private readonly metrics;
+  constructor(measurer?: TextMeasurer, metrics?: MetricsProvider);
   /** Number of paragraphs recomputed by the last `layout()` call. */
   getLastRelaidCount(): number;
   clearCaches(): void;
-  private paragraphSig;
+  /** Text indent of a block in px (0 for plain paragraphs). */
+  private indentFor;
+  private sigFor;
   /**
    * Pre-compute paragraph layouts for `blocks` within a time budget so a
    * following `layout()` is cheap. Call repeatedly until it returns true.
@@ -1963,6 +2039,7 @@ declare class TextLayoutEngine {
   layout(blocks: WeaveTextBlock[], style: TextLayoutStyle, bounds: TextLayoutBounds): TextLayout;
   /** Append a paragraph's lines to `lines`; stops once a fixed height is full. */
   private emitLines;
+  private stepPx;
   private rangeWidth;
   /**
    * Longest prefix of graphemes[start..n) that fits `maxWidth`, found with an
@@ -1971,6 +2048,9 @@ declare class TextLayoutEngine {
    */
   private longestFit;
   private layoutParagraph;
+  /** Per-line box height and baseline from the runs on each line. */
+  private measureLines;
+  private wrapParagraph;
   private buildSegments;
 }
 //#endregion
@@ -2004,14 +2084,41 @@ declare class WeaveTextV2Shape extends Konva.Shape {
   private blocksKey;
   private blocksCache;
   private viewport;
+  private indentStepValue;
+  private linkStyle;
+  private hoveredRun;
   constructor(config?: TextV2ShapeConfig);
   text(): string;
   text(value: string): this;
   setText(value: string | null | undefined): this;
+  /**
+   * List indent per depth, as a multiple of `fontSize`. Not a node attr: it
+   * comes from the node config and must not be serialized into the document.
+   */
+  setIndentStep(step: number | undefined): this;
+  /** Link run colours (from the node config; not serialized). */
+  setLinkStyle(style: {
+    color: string;
+    hoverColor: string;
+  }): this;
+  /** Run under the pointer (`paragraph:run`), repainted with the hover colour. */
+  setHoveredRun(key: string | null): this;
+  getHoveredRun(): string | null;
+  /**
+   * Link run at a point in node-local coordinates (the legacy node-level
+   * `link` wins: runs are then not links).
+   */
+  linkAtPoint(point: {
+    x: number;
+    y: number;
+  }): {
+    key: string;
+    url: string;
+  } | null;
   /** Resolved blocks: stored or lazily synthesized (never written back). */
   getBlocks(): WeaveTextBlock[];
   /** Replace content with blocks, keeping the `text` mirror in sync. */
-  setBlocks(blocks: WeaveTextBlock[]): this;
+  setBlocks(blocks: WeaveTextBlock[] | undefined): this;
   fontSize(): number;
   fontSize(v: number): this;
   fontFamily(): string;
@@ -2034,6 +2141,14 @@ declare class WeaveTextV2Shape extends Konva.Shape {
   wrap(v: TextWrap): this;
   textDecoration(): string;
   textDecoration(v: string): this;
+  /**
+   * Always stroke under the node transform. Weave turns `strokeScaleEnabled`
+   * off while a node is transformed; Konva then resets the canvas transform
+   * before stroking, which only works for path shapes. `strokeText` is not a
+   * path, so the outline was painted at local coordinates on the canvas
+   * origin at stage scale 1 (visible over other nodes while resizing).
+   */
+  getStrokeScaleEnabled(): boolean;
   private accessor;
   getTextWidth(): number;
   getTextHeight(): number;
@@ -2052,7 +2167,7 @@ declare class WeaveTextV2Shape extends Konva.Shape {
     height: number;
   };
   /** Rendered width of a string with this shape's font and letter spacing. */
-  measureText(text: string): number;
+  measureText(text: string, font?: string): number;
   /** Offset of the first line inside the box (padding + vertical align). */
   getContentOffset(): {
     x: number;
@@ -2065,12 +2180,20 @@ declare class WeaveTextV2Shape extends Konva.Shape {
     y1: number;
     y2: number;
   } | null): void;
+  /**
+   * Visible y-range in local coordinates, derived from the context being
+   * painted (current transform + backing canvas size) instead of the stage.
+   * The stage is not the paint target during export (off-screen canvases,
+   * tiles, server-side), so using it culled visible lines. Returns null (paint
+   * everything) when the transform cannot be read.
+   */
   private visibleRange;
   _sceneFunc: (ctx: Konva.Context, shape: Konva.Shape) => void;
   /** Vertical offset of the text block inside the box (verticalAlign). */
   private verticalOffset;
   private paintLine;
   private strokeDecoration;
+  private strokeSegment;
   private paintSegment;
   private fillText;
   _hitFunc: (ctx: Konva.Context, shape: Konva.Shape) => void;
@@ -2103,10 +2226,35 @@ type WeaveTextV2OutlineProperties = {
  * Unlike `WeaveTextNode`, `edition` has no `borderSize` (there is no DOM
  * textarea border to size): the edit box outline is `edition.outline`.
  */
+type WeaveTextV2FollowPadding = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+};
 type WeaveTextV2EditionProperties = {
   outline: WeaveTextV2OutlineProperties;
+  /**
+   * Margin, in screen pixels per side, kept between the caret and the stage
+   * edges when the stage pans to follow it while editing. Raise a side when
+   * app UI (toolbars, sidebars) covers that edge. Default 40 on every side.
+   */
+  followPadding: WeaveTextV2FollowPadding;
+};
+type WeaveTextV2RichTextProperties = {
+  /**
+   * Enables formatting commands, shortcuts and list key rules. Marks and
+   * lists already in a document always render, whatever this value.
+   */
+  enabled: boolean;
+  /**
+   * List indent per depth as a multiple of the node `fontSize` (default
+   * 1.5). Must be the same on every client, or wrapping differs.
+   */
+  indentStep: number;
 };
 type WeaveTextV2Properties = Omit<WeaveTextProperties, 'edition'> & {
+  richText: WeaveTextV2RichTextProperties;
   edition: WeaveTextV2EditionProperties;
   sizeWarning: WeaveTextV2SizeWarningProperties;
 };
@@ -2129,6 +2277,7 @@ declare class WeaveTextV2Node extends WeaveNode {
   private editingNodeId;
   private session;
   private sizeWarned;
+  private selectionTimer;
   private nodeRenderedAddedRegistered;
   private keyPressHandler;
   constructor(params?: WeaveTextV2NodeParams);
@@ -2161,67 +2310,172 @@ declare class WeaveTextV2Node extends WeaveNode {
   private setupTransform;
   onUpdate(nodeInstance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
   serialize(instance: WeaveElementInstance): WeaveStateElement;
+  private linkCtxMenuGuardRegistered;
+  private linkHoverText;
+  private linkModifier;
+  private linkHoverRefresh;
+  private linkHitAt;
+  private registerLinkContextMenuGuard;
   private setupLinkBehavior;
+  private localPointer;
+  private lastLinkOpen;
+  private openUrl;
   private openTextLink;
   getLink(nodeInstance: WeaveElementInstance): string | undefined;
   setLink(nodeInstance: WeaveElementInstance, url: string): void;
   removeLink(nodeInstance: WeaveElementInstance): void;
+  private indentStep;
+  /**
+   * Rich text is on for a node when its `richText` attribute says so;
+   * nodes without the attribute follow `config.richText.enabled`.
+   */
+  isRich(nodeInstance: WeaveElementInstance): boolean;
+  isRichTextEnabled(nodeInstance?: WeaveElementInstance): boolean;
+  private activeSession;
+  private emitFormatChange;
+  /** Selection events fire often while dragging: coalesce them. */
+  private scheduleSelectionEvent;
+  /**
+   * Format of the active selection while editing, otherwise of `range`
+   * (default: the whole text). Sizes are px.
+   */
+  getSelectionFormat(nodeInstance: WeaveElementInstance, range?: {
+    start: number;
+    end: number;
+  }): WeaveTextSelectionFormat;
+  /**
+   * Run a block transform on a non-editing node: one `updateNode`, so one
+   * Weave undo step. Returns false when rich text is disabled.
+   */
+  private commandOnNode;
+  /**
+   * Set a mark (`undefined` clears it). `size` is in px. While the node is
+   * being edited it applies to the editor selection, otherwise to `range`
+   * (default: the whole text).
+   */
+  applyMark(nodeInstance: WeaveElementInstance, key: WeaveTextMarkKey, value: unknown, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  /** Link a range (or the editor selection) to an http(s) URL. */
+  setRunLink(nodeInstance: WeaveElementInstance, url: string, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  removeRunLink(nodeInstance: WeaveElementInstance, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  toggleMark(nodeInstance: WeaveElementInstance, key: WeaveTextMarkKey, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  toggleList(nodeInstance: WeaveElementInstance, kind: WeaveTextListKind, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  /** Align every paragraph touched by the range (default: all). */
+  setAlign(nodeInstance: WeaveElementInstance, align: WeaveTextBlockAlign | undefined, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  indent(nodeInstance: WeaveElementInstance, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  outdent(nodeInstance: WeaveElementInstance, range?: {
+    start: number;
+    end: number;
+  }): boolean;
+  /**
+   * Scale the whole text: sets the node `fontSize` (px); size marks are
+   * ratios of it, so every run scales with it.
+   */
+  setBaseFontSize(nodeInstance: WeaveElementInstance, px: number): boolean;
   resetSmartLayout(textNode: WeaveTextV2Shape): void;
   static defaultState<WeaveTextProperties>(nodeId: string, params?: {
     config: WeaveTextProperties;
   }): WeaveStateElement;
   static addNodeState(defaultNodeState: WeaveStateElement, props: WeaveElementAttributes): WeaveStateElement;
   static updateNodeState(prevNodeState: WeaveStateElement, nextProps: WeaveElementAttributes): WeaveStateElement;
-  static getSchema(): import("zod").ZodObject<{
+  static getSchema(): z.ZodObject<{
     [x: string]: any;
-    type: import("zod").ZodLiteral<"text">;
-    props: import("zod").ZodObject<{
-      nodeType: import("zod").ZodLiteral<"text">;
-      width: import("zod").ZodNumber;
-      height: import("zod").ZodOptional<import("zod").ZodNumber>;
-      fontFamily: import("zod").ZodDefault<import("zod").ZodString>;
-      fontSize: import("zod").ZodDefault<import("zod").ZodNumber>;
-      fontStyle: import("zod").ZodDefault<import("zod").ZodString>;
-      fontVariant: import("zod").ZodEnum<{
+    type: z.ZodLiteral<"text">;
+    props: z.ZodObject<{
+      nodeType: z.ZodLiteral<"text">;
+      width: z.ZodNumber;
+      height: z.ZodOptional<z.ZodNumber>;
+      fontFamily: z.ZodDefault<z.ZodString>;
+      fontSize: z.ZodDefault<z.ZodNumber>;
+      fontStyle: z.ZodDefault<z.ZodString>;
+      fontVariant: z.ZodEnum<{
         normal: "normal";
         "small-caps": "small-caps";
       }>;
-      textDecoration: import("zod").ZodDefault<import("zod").ZodEnum<{
+      textDecoration: z.ZodDefault<z.ZodEnum<{
         "": "";
         "line-through": "line-through";
         underline: "underline";
       }>>;
-      letterSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
-      lineHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
-      align: import("zod").ZodDefault<import("zod").ZodEnum<{
+      letterSpacing: z.ZodDefault<z.ZodNumber>;
+      lineHeight: z.ZodDefault<z.ZodNumber>;
+      align: z.ZodDefault<z.ZodEnum<{
         left: "left";
         center: "center";
         right: "right";
         justify: "justify";
       }>>;
-      verticalAlign: import("zod").ZodDefault<import("zod").ZodEnum<{
+      verticalAlign: z.ZodDefault<z.ZodEnum<{
         top: "top";
         middle: "middle";
         bottom: "bottom";
       }>>;
-      fill: import("zod").ZodDefault<import("zod").ZodString>;
-      text: import("zod").ZodDefault<import("zod").ZodString>;
-      link: import("zod").ZodOptional<import("zod").ZodString>;
-      linkPreviousFill: import("zod").ZodOptional<import("zod").ZodString>;
-      linkPreviousTextDecoration: import("zod").ZodOptional<import("zod").ZodString>;
-      strokeEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
-      stroke: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-      strokeWidth: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
-      strokeScaleEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
-      fillAfterStrokeEnabled: import("zod").ZodDefault<import("zod").ZodBoolean>;
-      layout: import("zod").ZodDefault<import("zod").ZodEnum<{
+      fill: z.ZodDefault<z.ZodString>;
+      text: z.ZodDefault<z.ZodString>;
+      link: z.ZodOptional<z.ZodString>;
+      linkPreviousFill: z.ZodOptional<z.ZodString>;
+      linkPreviousTextDecoration: z.ZodOptional<z.ZodString>;
+      strokeEnabled: z.ZodDefault<z.ZodBoolean>;
+      stroke: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+      strokeWidth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+      strokeScaleEnabled: z.ZodDefault<z.ZodBoolean>;
+      fillAfterStrokeEnabled: z.ZodDefault<z.ZodBoolean>;
+      layout: z.ZodDefault<z.ZodEnum<{
         readonly SMART: "smart";
         readonly AUTO_ALL: "auto-all";
         readonly AUTO_HEIGHT: "auto-height";
         readonly FIXED: "fixed";
       }>>;
-    }, import("zod/v4/core").$strip>;
-  }, import("zod/v4/core").$strip>;
+      richText: z.ZodOptional<z.ZodBoolean>;
+      blocks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runs: z.ZodArray<z.ZodObject<{
+          t: z.ZodString;
+          m: z.ZodOptional<z.ZodObject<{
+            bold: z.ZodOptional<z.ZodBoolean>;
+            italic: z.ZodOptional<z.ZodBoolean>;
+            underline: z.ZodOptional<z.ZodBoolean>;
+            strike: z.ZodOptional<z.ZodBoolean>;
+            color: z.ZodOptional<z.ZodString>;
+            size: z.ZodOptional<z.ZodNumber>;
+            family: z.ZodOptional<z.ZodString>;
+            lineHeight: z.ZodOptional<z.ZodNumber>;
+            link: z.ZodOptional<z.ZodString>;
+          }, z.core.$loose>>;
+        }, z.core.$strip>>;
+        kind: z.ZodOptional<z.ZodEnum<{
+          ul: "ul";
+          ol: "ol";
+        }>>;
+        depth: z.ZodOptional<z.ZodNumber>;
+        start: z.ZodOptional<z.ZodNumber>;
+        align: z.ZodOptional<z.ZodEnum<{
+          left: "left";
+          center: "center";
+          right: "right";
+        }>>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
 }
 //#endregion
 //#region src/nodes/image/constants.d.ts
@@ -4088,10 +4342,22 @@ declare class WeaveTextToolAction extends WeaveAction {
   protected cancelAction: () => void;
   onPropsChange: undefined;
   onInit: undefined;
-  constructor();
+  private readonly toolName;
+  private readonly initialProps;
+  /**
+   * `name` and `props` let an app register several text tools, e.g. a
+   * plain one and one creating rich text nodes (`props: { richText: true }`).
+   */
+  constructor(params?: {
+    name?: string;
+    props?: WeaveElementAttributes;
+  });
   initialize(): void;
   getName(): string;
   initProps(): {
+    id?: string;
+    nodeType?: string;
+    children?: import("@inditextech/weave-types").WeaveStateElement[];
     text: string;
     layout: "smart";
     fontSize: number;