@sheetxl/sdk 0.8.0-beta.7 → 0.8.0-beta.9

package/types/src/shape/_builtIn/_BuiltInDef.d.ts

@@ -0,0 +1,9 @@
+import { IGeometry } from '../IGeometry';
+/**
+ * A definition as the built-in table stores it: connection sites may be an index into its
+ * chunk's shared lists, resolved to the lists themselves when the chunk loads.
+ */
+export interface BuiltInDef extends Omit<IGeometry.Def, 'cxn'> {
+    cxn?: readonly string[] | number;
+}
+//# sourceMappingURL=_BuiltInDef.d.ts.map

package/types/src/shape/_builtIn/arrows.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=arrows.d.ts.map

package/types/src/shape/_builtIn/basic.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=basic.d.ts.map

package/types/src/shape/_builtIn/callouts.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=callouts.d.ts.map

package/types/src/shape/_builtIn/flowchart.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=flowchart.d.ts.map

package/types/src/shape/_builtIn/lines.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=lines.d.ts.map

package/types/src/shape/_builtIn/math.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=math.d.ts.map

package/types/src/shape/_builtIn/other.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=other.d.ts.map

package/types/src/shape/_builtIn/rectangles.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=rectangles.d.ts.map

package/types/src/shape/_builtIn/starsBanners.d.ts

@@ -0,0 +1,6 @@
+import { BuiltInDef } from './_BuiltInDef';
+/** Connection-site lists shared by more than one shape here; `BuiltInDef.cxn` indexes into this. */
+export declare const CXN_SHARED: readonly (readonly string[])[];
+/** This chunk's built-in definitions by their `prstGeom/@prst` name, in sorted order. */
+export declare const BUILT_IN: Readonly<Record<string, BuiltInDef>>;
+//# sourceMappingURL=starsBanners.d.ts.map

package/types/src/shape/geometry/_strokeEnds.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What a straight line needs to draw its ends without the rest of the engine: a chunk of its own,
+ * shared with the engine, so a sheet of arrows loads it and nothing else.
+ */
+export { decorateSubpaths } from './lineEnds';
+export { addSubpathsBounds, emptyBox, subpathsToSVG } from './segments';
+//# sourceMappingURL=_strokeEnds.d.ts.map

package/types/src/shape/geometry/format.d.ts

@@ -0,0 +1,3 @@
+/** Formats a coordinate: fixed decimals, trailing zeros dropped, negative zero canonicalized. */
+export declare function formatNumber(n: number, precision: number): string;
+//# sourceMappingURL=format.d.ts.map

package/types/src/shape/geometry/geometry.d.ts

@@ -0,0 +1,84 @@
+import { Point } from '@sheetxl/utils';
+import { IGeometry } from '../IGeometry';
+import { LineOptions } from './lineEnds';
+import { FillMode } from './paths';
+export interface EvaluateOptions {
+    /** Decimal places in path data. @defaultValue `2` */
+    precision?: number;
+    /**
+     * The line the shape is stroked with, when it declares a head or tail: every stroked open path
+     * is trimmed under its ends, which come back as `line`-filled paths (design §10). Absent, the
+     * paths are the definition's alone.
+     */
+    line?: LineOptions;
+}
+export interface GeometryPath {
+    /** SVG path data in output units. */
+    d: string;
+    fill: FillMode;
+    stroke: boolean;
+}
+export interface Rect {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+export interface XYHandle extends Point {
+    type: 'xy';
+    /** Adjust value the horizontal drag changes, with its allowed range. */
+    refX?: string;
+    minX?: number;
+    maxX?: number;
+    /** Adjust value the vertical drag changes, with its allowed range. */
+    refY?: string;
+    minY?: number;
+    maxY?: number;
+}
+export interface PolarHandle extends Point {
+    type: 'polar';
+    refR?: string;
+    minR?: number;
+    maxR?: number;
+    /** Angle bounds in degrees. */
+    refAng?: string;
+    minAng?: number;
+    maxAng?: number;
+}
+export type Handle = XYHandle | PolarHandle;
+export interface Connection extends Point {
+    /** Direction a connector leaves the site, in degrees clockwise from +x. */
+    ang: number;
+}
+/** What the engine evaluates a definition to; `IGeometry` is the public face of it. */
+export interface EvaluatedGeometry {
+    paths: GeometryPath[];
+    /** Text rectangle; the whole shape when the definition declares none. */
+    textRect: Rect;
+    /**
+     * The box of every path, line ends included, before the line's width: it can reach outside the
+     * shape. The whole shape when nothing is drawn.
+     */
+    pathBounds: Rect;
+    handles: Handle[];
+    connections: Connection[];
+    /** Effective adjust values after defaults and overrides. */
+    adjustments: Record<string, number>;
+}
+/**
+ * The adjust handles alone, at `width` by `height` with the given adjust values: what
+ * {@link evaluateGeometry} reports as `handles`, without compiling the paths. Cheap enough to call
+ * per step of a numeric search (see `adjustmentsFromHandle`).
+ */
+export declare function evaluateHandles(def: IGeometry.Def, width: number, height: number, adjustments?: Readonly<Record<string, number>>): Handle[];
+/**
+ * Evaluates a shape definition at `width` by `height` with optional adjust value overrides,
+ * producing SVG path data and the sites the editor needs.
+ *
+ * Every output coordinate is in the unit `width` and `height` are given in: the guide formulas
+ * are homogeneous in the extent, so a definition evaluates the same at any scale (the SDK passes
+ * pixels). Paths that declare their own coordinate space are evaluated against that space and
+ * scaled to the shape extent (design §6.1).
+ */
+export declare function evaluateGeometry(def: IGeometry.Def, width: number, height: number, adjustments?: Readonly<Record<string, number>>, options?: EvaluateOptions): EvaluatedGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/types/src/shape/geometry/guides.d.ts

@@ -0,0 +1,54 @@
+import { IGeometry } from '../IGeometry';
+/** DrawingML angles are in 60,000ths of a degree. */
+export declare const ANGLE_UNIT = 60000;
+/** A formula operand: a numeric literal or a guide name. */
+export type Operand = number | string;
+export interface CompiledGuide {
+    name: string;
+    op: string;
+    args: Operand[];
+}
+export interface CompiledGuides {
+    /** Adjust values with their default literal. */
+    av: {
+        name: string;
+        value: number;
+    }[];
+    gd: CompiledGuide[];
+}
+/** Parses one operand: an integer literal becomes a number, anything else is a guide name. */
+export declare const parseOperand: (token: string) => Operand;
+/** Tokenizes a definition's guides once; the result is cached per definition object. */
+export declare function compileGuides(def: IGeometry.Def): CompiledGuides;
+/**
+ * Guides every definition may use without declaring (ECMA-376 §20.1.9.11 plus the four the
+ * presets use but the list omits). `w`/`h` are the shape anchor extent; the anchor origin is 0,0.
+ */
+export declare function predefinedGuide(name: string, w: number, h: number): number | undefined;
+/**
+ * Evaluated guide values for one anchor extent. Lookups resolve literals, then bound guides,
+ * then the predefined set.
+ */
+export declare class GuideValues {
+    private readonly _values;
+    readonly w: number;
+    readonly h: number;
+    constructor(w: number, h: number);
+    /** The value of an operand. Throws on an unknown name; the generator guarantees presets never do. */
+    get(operand: Operand): number;
+    /** Whether a name is bound by the definition (not merely predefined). */
+    has(name: string): boolean;
+    set(name: string, value: number): void;
+}
+/**
+ * Applies one operator (design §5.2). Division by zero yields 0 rather than throwing, so a
+ * handle dragged through a degenerate size never breaks rendering.
+ */
+export declare function applyOp(op: string, x: number, y: number, z: number): number;
+/**
+ * Evaluates a definition's adjust values and guides against an anchor of `w` by `h` at 0,0.
+ * `adjustments` override adjust-value defaults by name; names the definition does not declare
+ * are ignored (a file may carry stale entries).
+ */
+export declare function evaluateGuides(def: IGeometry.Def, w: number, h: number, adjustments?: Readonly<Record<string, number>>): GuideValues;
+//# sourceMappingURL=guides.d.ts.map

package/types/src/shape/geometry/handles.d.ts

@@ -0,0 +1,14 @@
+import { IGeometry } from '../IGeometry';
+/**
+ * The adjust values a handle drag lands on: handle `index` of the shape at `width` by `height`
+ * moved to (`x`, `y`) in the shape's own frame, in the same unit as `width` and `height`.
+ *
+ * An `xy` handle solves its horizontal reference against `x` and its vertical one against `y`; a
+ * `polar` handle solves its angle reference against the direction of the point from the shape's
+ * center and its radius reference against the distance. Each value is clamped to the range the
+ * handle declares (or the spec's limit), and a reference the handle does not have is left alone.
+ *
+ * @returns `adjustments` with the solved values merged in, in the preset grammar's own units.
+ */
+export declare function adjustmentsFromHandle(def: IGeometry.Def, width: number, height: number, adjustments: Readonly<Record<string, number>> | undefined, index: number, x: number, y: number): Record<string, number>;
+//# sourceMappingURL=handles.d.ts.map

package/types/src/shape/geometry/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The geometry engine's lazily loaded entry: what the SDK's loader calls. Everything a dynamic
+ * import's module exports is kept by the bundler, so this exports only that.
+ */
+export { evaluateGeometry } from './geometry';
+export { adjustmentsFromHandle } from './handles';
+//# sourceMappingURL=index.d.ts.map

package/types/src/shape/geometry/lineEnds.d.ts

@@ -0,0 +1,53 @@
+import { Subpath } from './segments';
+/** DrawingML `ST_LineEndType`. */
+export type LineEndType = 'none' | 'triangle' | 'stealth' | 'diamond' | 'oval' | 'arrow';
+/** DrawingML `ST_LineEndWidth` / `ST_LineEndLength`. */
+export type LineEndSize = 'sm' | 'med' | 'lg';
+/** One end of a line: `headEnd` or `tailEnd`. */
+export interface LineEnd {
+    /** `'none'` and absent draw nothing. */
+    type?: LineEndType;
+    /** @defaultValue `'med'` */
+    width?: LineEndSize;
+    /** @defaultValue `'med'` */
+    length?: LineEndSize;
+}
+/** What a geometry's open paths are stroked with, as far as the line ends depend on it. */
+export interface LineOptions {
+    /** The stroke width, in output units. */
+    width: number;
+    /** @defaultValue `'butt'` */
+    cap?: 'butt' | 'round' | 'square';
+    /** The end at a path's start. */
+    head?: LineEnd;
+    /** The end at a path's end. */
+    tail?: LineEnd;
+}
+/**
+ * A line end's shape, from rythan's `getLineDecoratorDrawInfo`: the outline with its tip at the
+ * origin and its body along +x, how much line it hides, and how far back along the line it is
+ * aimed. Sizes are in units of `lw' = max(lineWidth, 2)` scaled by the declared size.
+ */
+interface EndOutline {
+    outline: Subpath[];
+    /** Arc length of line to trim under the end; none when not positive. */
+    clip: number;
+    /** Arc length back along the line to the point the end is aimed at; `0` aims it along the end's tangent. */
+    sample: number;
+}
+/** The outline of a line end at a line width, or `null` when it draws nothing. */
+export declare function lineEndOutline(end: LineEnd | undefined, lineWidth: number): EndOutline | null;
+/**
+ * A path's subpaths with the line's ends applied: every open subpath gets the head at its start
+ * and the tail at its end, each trimmed back under its end. Closed subpaths are left alone, as
+ * are all of them when the line declares no end.
+ *
+ * @returns The subpaths to stroke, and the ends to fill with the stroke's paint; `null` when
+ * nothing was decorated.
+ */
+export declare function decorateSubpaths(subpaths: readonly Subpath[], line: LineOptions): {
+    stroke: Subpath[];
+    ends: Subpath[];
+} | null;
+export {};
+//# sourceMappingURL=lineEnds.d.ts.map

package/types/src/shape/geometry/paths.d.ts

@@ -0,0 +1,35 @@
+import { IGeometry } from '../IGeometry';
+import { GuideValues, Operand } from './guides';
+import { Subpath } from './segments';
+export { formatNumber } from './segments';
+/**
+ * How a path is painted. The definitions declare `norm`, `none` and the four shaded modes; `line`
+ * is the geometry's own: a line end, filled with the stroke's paint (design §10).
+ */
+export type FillMode = 'norm' | 'none' | 'darken' | 'darkenLess' | 'lighten' | 'lightenLess' | 'line';
+export interface CompiledCommand {
+    c: 'M' | 'L' | 'Q' | 'C' | 'A' | 'Z';
+    args: Operand[];
+}
+export interface CompiledPath {
+    fill: FillMode;
+    stroke: boolean;
+    /** Path coordinate space, when the path declares one. */
+    w?: number;
+    h?: number;
+    cmds: CompiledCommand[];
+}
+export declare function compilePath(p: IGeometry.DefPath): CompiledPath;
+/** Tokenizes a definition's paths once; cached per definition object. */
+export declare function compilePaths(def: IGeometry.Def): CompiledPath[];
+/**
+ * Evaluates one path's commands into subpaths of segments in output space: guide-space points
+ * are scaled by `sx`,`sy`. `arcTo` follows design §6.3: DrawingML angles are visual, so the start
+ * angle is mapped to the ellipse's parametric angle to find the center, and the end point comes
+ * from the parametric end angle. A command right after `Z` continues from the closed subpath's
+ * start, as SVG does, in a subpath written without an `M`.
+ */
+export declare function evaluatePath(path: CompiledPath, values: GuideValues, sx: number, sy: number): Subpath[];
+/** Converts one path to SVG path data: {@link evaluatePath} written out. */
+export declare function pathToSVG(path: CompiledPath, values: GuideValues, sx: number, sy: number, precision: number): string;
+//# sourceMappingURL=paths.d.ts.map

package/types/src/shape/geometry/segments.d.ts

@@ -0,0 +1,114 @@
+import { Point } from '@sheetxl/utils';
+import { formatNumber } from './format';
+export interface LineSegment {
+    k: 'L';
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export interface QuadSegment {
+    k: 'Q';
+    x0: number;
+    y0: number;
+    cx: number;
+    cy: number;
+    x1: number;
+    y1: number;
+}
+export interface CubicSegment {
+    k: 'C';
+    x0: number;
+    y0: number;
+    c1x: number;
+    c1y: number;
+    c2x: number;
+    c2y: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * An elliptical arc by center parameterization: `c + R(phi)·(rx·cos t, ry·sin t)` for `t` from
+ * `t0` over `dt` (radians; positive is clockwise on screen). A full turn is `|dt| = 2π`.
+ */
+export interface ArcSegment {
+    k: 'A';
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    phi: number;
+    t0: number;
+    dt: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export type Segment = LineSegment | QuadSegment | CubicSegment | ArcSegment;
+export interface Subpath {
+    /** The subpath's start: its `M`. */
+    x: number;
+    y: number;
+    segments: Segment[];
+    /** Ends with `Z`. */
+    closed: boolean;
+    /**
+     * Begun by a drawing command right after a `Z`, with no `M` of its own: SVG continues from the
+     * closed subpath's start, so no `M` is written for it.
+     */
+    implicit?: boolean;
+}
+export { formatNumber };
+export declare function arcPoint(a: ArcSegment, t: number): Point;
+/** The point at parameter `u` in `[0, 1]` along the segment. */
+export declare function pointAt(seg: Segment, u: number): Point;
+/** The direction of travel at parameter `u`: the derivative, not normalized. */
+export declare function tangentAt(seg: Segment, u: number): Point;
+export declare function segmentLength(seg: Segment): number;
+/** The parameter at arc length `s` from the segment's start, clamped to `[0, 1]`. */
+export declare function parameterAtLength(seg: Segment, s: number): number;
+/** The segment split at parameter `u`: the part before it and the part after. */
+export declare function splitSegment(seg: Segment, u: number): [Segment, Segment];
+export declare function subpathLength(sp: Subpath): number;
+/** The point at arc length `s` from the subpath's start, and the direction of travel there. Clamped to the ends. */
+export declare function pointAtLength(sp: Subpath, s: number): {
+    point: Point;
+    tangent: Point;
+};
+/** Whether the subpath is open: not closed by `Z`, and not ending where it began. */
+export declare function isOpen(sp: Subpath): boolean;
+/**
+ * The subpath shortened by `amount` of arc length from its start (`fromStart`) or its end, the
+ * way rythan's `adjustPathForDecorator` walks it: whole segments shorter than what is left to
+ * remove are dropped, the one the cut lands in is split there, and less than 0.26 left to remove
+ * is not removed at all.
+ */
+export declare function trimSubpath(sp: Subpath, amount: number, fromStart: boolean): Subpath;
+/**
+ * The subpath moved by a similarity transform: rotated by `angle` radians (clockwise on screen),
+ * after a reflection in y when `flipY`, then translated to (`x`, `y`).
+ */
+export declare function placeSubpath(sp: Subpath, x: number, y: number, angle: number, flipY?: boolean): Subpath;
+/** Edges of a box; empty while `l > r`. */
+export interface Box {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+/** A box that holds nothing yet. */
+export declare const emptyBox: () => Box;
+/**
+ * Grows `box` to hold the segment exactly: its ends and every point where it turns back along x
+ * or y (a curve's derivative roots, an arc's crossings of its ellipse's extremes).
+ */
+export declare function addSegmentBounds(box: Box, seg: Segment): void;
+/** Grows `box` to hold every subpath, starts included. */
+export declare function addSubpathsBounds(box: Box, subpaths: readonly Subpath[]): Box;
+/**
+ * SVG path data for subpaths. An arc of a full turn or more is written as two halves, because
+ * SVG draws nothing when an arc's end point equals its start.
+ */
+export declare function subpathsToSVG(subpaths: readonly Subpath[], precision: number): string;
+//# sourceMappingURL=segments.d.ts.map

package/types/src/shape/index.d.ts

@@ -1,2 +1,4 @@
 export * from './IShape';
+export * as ShapeStyleUtils from './ShapeStyleUtils';
+export * from './IGeometry';
 //# sourceMappingURL=index.d.ts.map

package/types/src/sheet/ISheet.d.ts

@@ -30,6 +30,7 @@ import { ICalculation } from '../calculation';
 import { ISheetView } from '../sheetView';
 import { ISheetHeader } from '../sheetHeader';
 import { ISheetProtection } from '../sheetProtection';
+import { IOutline } from '../outline';
 import { ICellContainerOptions } from './ICellContainerOptions';
 /**
  * An `ISheet` represents a collection of elements (such as {@link ICellRange | ranges},
@@ -264,12 +265,9 @@ export interface ISheet extends ITransaction.ITransactional, IListener.ISource<I
      */
     getCodeName(): string | null;
     /**
-     * How row and column groups are laid out on this sheet.
-     *
-     * @remarks
-     * Always fully populated: a sheet that declares nothing reports the defaults.
+     * The row and column groups on this sheet, and how they are laid out.
      */
-    getOutlineSettings(): Readonly<ISheet.OutlineSettings>;
+    getOutline(): IOutline;
     /**
      * Whether conditional formats on this sheet are recalculated as the sheet changes.
      *
@@ -973,12 +971,13 @@ export declare namespace ISheet {
          */
         container?: ISheet.ContainerOptions;
         /**
-         * A unique identifier used for identifying this sheet during operations (i.e. copy/paste).
-         * This must be unique for all in-memory instances of a sheet.
+         * The sheet's id ({@link ISheet.getId}): what formulas and operations (copy/paste) identify it
+         * by. Must be unique among all in-memory sheets.
          *
-         * @returns A unique identifier for in memory operations. If not provided a default one will be used.
+         * @returns The id. If not provided a new one is made.
          * @remarks
-         * This is not saved as part of the {@link ISheet.JSON} persisted model.
+         * Not saved as part of the {@link ISheet.JSON} persisted model. A container that names its
+         * sheets before it builds them (a workbook loading its sheets) supplies it.
          */
         uid?: () => string;
         /**
@@ -1074,38 +1073,6 @@ export declare namespace ISheet {
             type: string;
         };
     }
-    /**
-     * How row and column groups are laid out.
-     *
-     * @see {@link ISheet.getOutlineSettings}
-     */
-    interface OutlineSettings {
-        /**
-         * Whether a group's summary row sits below its detail rows. When `false` it sits above them.
-         *
-         * @defaultValue true
-         */
-        summaryBelow: boolean;
-        /**
-         * Whether a group's summary column sits to the right of its detail columns. When `false` it
-         * sits to the left.
-         *
-         * @defaultValue true
-         */
-        summaryRight: boolean;
-        /**
-         * Whether the expand and collapse buttons for groups are shown.
-         *
-         * @defaultValue true
-         */
-        showOutlineSymbols: boolean;
-        /**
-         * Whether the automatic outline styles are applied to summary rows and columns.
-         *
-         * @defaultValue false
-         */
-        applyStyles: boolean;
-    }
     /**
      * A drawing whose shapes are described in the origin format's own legacy vector markup rather
      * than through {@link IMovable | movables}.
@@ -1153,7 +1120,6 @@ export declare namespace ISheet {
          */
         cols?: IRange.JSONReference<ICellHeader.JSON>[];
         defaultColSize?: number;
-        outlineLevelCol?: number;
         /**
          * Row headers, each addressed as an entire-row run (`'5:5'`, `'5:12'`).
          *
@@ -1162,7 +1128,6 @@ export declare namespace ISheet {
          */
         rows?: IRange.JSONReference<ICellHeader.JSON>[];
         defaultRowSize?: number;
-        outlineLevelRow?: number;
         styles?: IStyleCollection.JSON;
         resources?: IResource.JSON[];
         strings?: string[];
@@ -1215,9 +1180,9 @@ export declare namespace ISheet {
         /**
          * The outline settings that differ from their defaults.
          *
-         * @see {@link ISheet.getOutlineSettings}
+         * @see {@link ISheet.getOutline}
          */
-        outline?: Partial<OutlineSettings>;
+        outline?: IOutline.JSON;
         /**
          * Present, as `false`, only when conditional format calculation is turned off.
          *

package/types/src/sheet/Sheet.d.ts

@@ -25,7 +25,6 @@ import { IMovable, IMovableCollection } from '../movable';
 import { Movable } from '../movable/Movable';
 import { IChartCollection } from '../chart';
 import { IPicture } from '../picture';
-import { Chart } from '../chart/Chart';
 import { IPivotTable, IPivotTableCollection } from '../pivot';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegions, ICellRanges } from '../cellRange';
@@ -44,6 +43,7 @@ import { Comment } from '../comment/Comment';
 import { NoteMovable } from '../comment/NoteMovable';
 import { NoteLayout } from '../comment/_NoteBox';
 import { ISheetProtection } from '../sheetProtection';
+import { IOutline } from '../outline';
 import { ISheetHeader } from '../sheetHeader';
 import { ISheetView } from '../sheetView';
 import { ISheet } from './ISheet';
@@ -60,6 +60,7 @@ import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_Sh
 import { AutoFillProjection, AutoFillPreviewCache } from './_SheetAutoFillUtils';
 import { ProtectionCheck } from './_SheetCoords';
 import { SheetProtection } from '../sheetProtection/SheetProtection';
+import { Outline } from '../outline/Outline';
 import { SheetCellOptions } from './SheetCell';
 import { ICalculation } from '../calculation';
 import { ICalcGrid } from '../calculation/grid';
@@ -227,7 +228,7 @@ export declare class Sheet implements ISheet {
     protected _tabColor: IColor | null;
     /** VBA binding identity; carried from the file, never minted. See {@link ISheet.getCodeName}. */
     protected _codeName: string | null;
-    protected _outlineSettings: Readonly<ISheet.OutlineSettings>;
+    protected _outline: Outline;
     protected _conditionalFormatCalculation: boolean;
     /**
      * Modules this sheet owns — see {@link getModules}.
@@ -929,7 +930,7 @@ export declare class Sheet implements ISheet {
      * chart formulas are absolute in every file Excel saves.
      * @internal
      */
-    protected _holdFormulas(getExpressions: () => readonly string[]): Chart.HeldFormulas;
+    protected _holdFormulas(getExpressions: () => readonly string[]): IMovable.HeldFormulas;
     /**
      * Carry every reference a cut encloses from its source to its destination.
      *
@@ -1379,8 +1380,8 @@ export declare class Sheet implements ISheet {
     setTabColor(color: IColor | string | null): this;
     /** {@inheritDoc ISheet.getCodeName} */
     getCodeName(): string | null;
-    /** {@inheritDoc ISheet.getOutlineSettings} */
-    getOutlineSettings(): Readonly<ISheet.OutlineSettings>;
+    /** {@inheritDoc ISheet.getOutline} */
+    getOutline(): IOutline;
     /** {@inheritDoc ISheet.isConditionalFormatCalculationEnabled} */
     isConditionalFormatCalculationEnabled(): boolean;
     /**
@@ -1428,6 +1429,19 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _noteLayout(): NoteLayout;
+    /** The farthest any movable of the index paints past its anchor, for each `drawn` version. */
+    private _movableOverhangs;
+    /**
+     * Called when a movable's content has a newer answer for what it paints: the next search reads
+     * it, and listeners are told once per batch of answers.
+     */
+    private _drawnNotifyQueued;
+    private _onMovableDrawnReady;
+    /**
+     * The farthest any of `models` paints past its anchor, in pixels.
+     * @internal
+     */
+    protected _maxMovableOverhang(models: Map<IMovable, unknown>): number;
     /**
      * The movables of one index that match the filter, in z-order.
      * @internal