@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.12

package/types/src/selection/IChartElementSelection.d.ts

@@ -0,0 +1,103 @@
+import { IListener } from '../listener';
+import { IChart } from '../chart/IChart';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+/**
+ * The elements of a chart that are selected: its title, an axis, a series, a point of one, a
+ * legend entry… (see {@link IChart.IElement}), as Excel selects them with a click inside a chart.
+ *
+ * @remarks
+ * A sheet's view holds one beside its {@link IMovableSelection | movable selection}
+ * ({@link IWorksheetView.getChartElementSelection}). Its elements are always of the one chart whose
+ * movable is the active selected movable: selecting an element of another chart selects that
+ * chart's movable first, alone, and the selection empties when the movable selection moves on.
+ * A chart outside a workbook (`createChart`) takes a selection of its own, made with its chart.
+ *
+ * Every selected element has the same {@link IItemSelection.getContainer | container}; the chart
+ * area is the root and is never selected here: with nothing selected, the chart itself is what
+ * the movable selection holds.
+ *
+ * Which element a press selects is the editor's: Excel selects a series on the first press and
+ * its point on the next ({@link IChart.getElementAt} answers the point).
+ */
+export interface IChartElementSelection extends IItemSelection<IChart.IElement> {
+    /**
+     * Returns the chart the selected elements are of, or `null` when the selection is empty.
+     */
+    getChart(): IChart | null;
+    /**
+     * Selects `elements`, replacing the selection.
+     *
+     * @param elements The elements to select, the last one the active one. All of one chart.
+     * @param options With `add`, extends the selection instead.
+     *
+     * @throws If an element is of a chart this selection cannot reach (another sheet's, or not the
+     * selection's own chart), or the chart no longer has it.
+     */
+    select(elements: readonly IChart.IElement[], options?: IChartElementSelection.SelectOptions): this;
+    /**
+     * Selects the next element the chart shows, alone, among {@link IChart.getElements}: what
+     * pressing an arrow key does with a chart selected.
+     *
+     * @param reverse Selects the previous one instead.
+     *
+     * @remarks
+     * With nothing selected, starts from the chart's first element after the chart area. Does nothing
+     * without a chart to walk: one selected, or the selection's own.
+     */
+    traverse(reverse?: boolean): this;
+    /**
+     * Adds listeners to the selection.
+     *
+     * @param listeners The listeners to add.
+     * @param options Options for the listeners.
+     * @returns A function to remove the listeners.
+     */
+    addListeners(listeners: IChartElementSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isIChartElementSelection: true;
+}
+/**
+ * {@inheritDoc IChartElementSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IChartElementSelection}
+ */
+export declare namespace IChartElementSelection {
+    /**
+     * Options for {@link IChartElementSelection.select}.
+     */
+    interface SelectOptions extends IItemSelection.SelectOptions {
+    }
+    /**
+     * Events for {@link IChartElementSelection}.
+     */
+    interface Events {
+        /**
+         * Called when the selected elements, or the active one, change.
+         */
+        onChange?(source: IChartElementSelection): void;
+    }
+    /**
+     * Listeners for {@link IChartElementSelection} events.
+     */
+    interface IListeners extends IListener.Callbacks<IChartElementSelection, Events> {
+    }
+    /**
+     * Options for constructing an {@link IChartElementSelection}: one of the two.
+     */
+    interface ConstructorOptions {
+        /**
+         * The sheet whose charts the selection is of: selecting an element selects its chart's movable
+         * on the sheet's view first, and the selection follows the movable selection.
+         */
+        sheet?: IWorksheet;
+        /**
+         * The one chart the selection is of: for a chart outside a workbook, or a chart drawn outside
+         * its sheet's view.
+         */
+        chart?: IChart;
+    }
+}
+//# sourceMappingURL=IChartElementSelection.d.ts.map

package/types/src/selection/IItemSelection.d.ts

@@ -0,0 +1,131 @@
+import { IListener } from '../listener';
+/**
+ * A selection of items that stand in a tree: drawings on a sheet and the members of groups, or
+ * the elements of a chart. What a selection of either kind does is here; what each kind adds is
+ * on its own interface ({@link IMovableSelection}, {@link IChartElementSelection}).
+ *
+ * @remarks
+ * Every selected item has the same parent, its {@link getContainer | container}. Selecting an item
+ * from another container replaces the selection, as Excel's does: a shape and a member of a group
+ * cannot be selected together, nor a chart's title and a point of one of its series.
+ *
+ * The latest item picked is the {@link getActive | active} one, the one a Format pane shows.
+ *
+ * @typeParam T The kind of item selected.
+ */
+export interface IItemSelection<T extends IItemSelection.Item> {
+    /**
+     * Returns what every selected item shares as its parent: `null` for the root (the sheet, the
+     * chart), else the group or element they are in.
+     *
+     * @remarks
+     * `null` when the selection is empty.
+     */
+    getContainer(): T | null;
+    /**
+     * Returns the selected items, in the order the selection keeps them.
+     */
+    getItems(): readonly T[];
+    /**
+     * Returns the item selected most recently, or `null` when the selection is empty.
+     */
+    getActive(): T | null;
+    /**
+     * Returns `true` if `item` is selected.
+     */
+    isSelected(item: T): boolean;
+    /**
+     * Returns `true` if nothing is selected.
+     */
+    isEmpty(): boolean;
+    /**
+     * Selects `items`, replacing the selection.
+     *
+     * @param items The items to select, the last one the active one.
+     * @param options With `add`, extends the selection instead.
+     *
+     * @remarks
+     * Items are taken in order, as picks: one in another container than those selected before it
+     * replaces them.
+     *
+     * @throws If an item cannot be selected here: it is not where this selection looks, or has
+     * been removed.
+     */
+    select(items: readonly T[], options?: IItemSelection.SelectOptions): this;
+    /**
+     * Removes `items` from the selection. Items not selected are ignored.
+     */
+    unselect(items: readonly T[]): this;
+    /**
+     * Empties the selection.
+     */
+    clear(): this;
+    /**
+     * Selects the next item, alone: what pressing Tab does.
+     *
+     * @param reverse Selects the previous one instead.
+     *
+     * @remarks
+     * Wraps at the ends. With nothing selected, starts from the first (or, in reverse, the last).
+     */
+    traverse(reverse?: boolean): this;
+    /**
+     * Returns `true` if `other` selects the same items, with the same one active.
+     */
+    isEquals(other: IItemSelection<T>): boolean;
+    /**
+     * Adds listeners to the selection.
+     *
+     * @param listeners The listeners to add.
+     * @param options Options for the listeners.
+     * @returns A function to remove the listeners.
+     */
+    addListeners(listeners: IItemSelection.IListeners<T>, options?: IListener.Options): IListener.Remove;
+}
+/**
+ * {@inheritDoc IItemSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IItemSelection}
+ */
+export declare namespace IItemSelection {
+    /**
+     * What an item of a selection is: something that knows what it is part of.
+     */
+    interface Item {
+        /**
+         * Returns the item this one is part of, or `null` at the root.
+         */
+        getParent(): Item | null;
+    }
+    /**
+     * Options for {@link IItemSelection.select}.
+     */
+    interface SelectOptions {
+        /**
+         * Extend the selection rather than replace it.
+         *
+         * @remarks
+         * The equivalent of Ctrl+click in the UI.
+         *
+         * @defaultValue false
+         */
+        add?: boolean;
+    }
+    /**
+     * Events for {@link IItemSelection}.
+     */
+    interface Events<T extends Item> {
+        /**
+         * Called when the selected items, or the active one, change.
+         */
+        onChange?(source: IItemSelection<T>): void;
+    }
+    /**
+     * Listeners for {@link IItemSelection} events.
+     */
+    interface IListeners<T extends Item> extends IListener.Callbacks<IItemSelection<T>, Events<T>> {
+    }
+}
+//# sourceMappingURL=IItemSelection.d.ts.map

package/types/src/selection/IMovableSelection.d.ts

@@ -1,6 +1,7 @@
 import { IListener } from '../listener';
 import { IMovable } from '../movable';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
 /**
  * The drawings selected on a sheet's view: shapes, pictures, charts, controls, groups and the
  * members of groups.
@@ -15,11 +16,11 @@ import { ISheet } from '../sheet';
  * Every selected movable has the same parent, its {@link getContainer | container}: the sheet,
  * or one group. Selecting a movable from another container replaces the selection.
  */
-export interface IMovableSelection {
+export interface IMovableSelection extends IItemSelection<IMovable> {
     /**
      * Returns the sheet the selection is on.
      */
-    getSheet(): ISheet;
+    getWorksheet(): IWorksheet;
     /**
      * Returns what every selected movable shares as its parent: `null` for the sheet, else the
      * group's movable.
@@ -42,14 +43,6 @@ export interface IMovableSelection {
      * The one a Format pane shows.
      */
     getActive(): IMovable | null;
-    /**
-     * Returns `true` if `movable` is selected.
-     */
-    isSelected(movable: IMovable): boolean;
-    /**
-     * Returns `true` if no movable is selected.
-     */
-    isEmpty(): boolean;
     /**
      * Selects `movables`, replacing the selection.
      *
@@ -63,14 +56,6 @@ export interface IMovableSelection {
      * @throws If a movable is not on this sheet, or has been deleted.
      */
     select(movables: readonly IMovable[], options?: IMovableSelection.SelectOptions): this;
-    /**
-     * Removes `movables` from the selection. Movables not selected are ignored.
-     */
-    unselect(movables: readonly IMovable[]): this;
-    /**
-     * Empties the selection.
-     */
-    clear(): this;
     /**
      * Selects the next drawing on the sheet, alone.
      *
@@ -84,10 +69,6 @@ export interface IMovableSelection {
      * Useful for pressing Tab from the UI.
      */
     traverse(reverse?: boolean): this;
-    /**
-     * Returns `true` if `other` selects the same movables, with the same one active.
-     */
-    isEquals(other: IMovableSelection): boolean;
     /**
      * Adds listeners to the selection.
      *
@@ -110,16 +91,7 @@ export declare namespace IMovableSelection {
     /**
      * Options for {@link IMovableSelection.select}.
      */
-    interface SelectOptions {
-        /**
-         * Extend the selection rather than replace it.
-         *
-         * @remarks
-         * The equivalent of Ctrl+click in the UI.
-         *
-         * @defaultValue false
-         */
-        add?: boolean;
+    interface SelectOptions extends IItemSelection.SelectOptions {
     }
     /**
      * Events for {@link IMovableSelection}.
@@ -142,7 +114,7 @@ export declare namespace IMovableSelection {
         /**
          * The sheet the selection is on.
          */
-        sheet: ISheet;
+        sheet: IWorksheet;
     }
 }
 //# sourceMappingURL=IMovableSelection.d.ts.map

package/types/src/selection/IRangeSelection.d.ts

@@ -3,7 +3,7 @@ import { SelectionCoords as WellKnownSelectionCoords, RunCoordValue } from '@she
 import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 /**
  * Interface representing a range selection within a sheet.
  */
@@ -75,9 +75,9 @@ export interface IRangeSelection {
      * A selection's *ranges* may span multiple sheets (each range/cell carries its own optional `scope`
      * sheet name — e.g. a formula's cross-sheet references), but the selection itself is always anchored to
      * one sheet: the one it was constructed with (or, for a {@link create} picker, the sheet it was
-     * derived from). This is that sheet — the analog of {@link ICellRange.getSheet} for a selection.
+     * derived from). This is that sheet — the analog of {@link ICellRange.getWorksheet} for a selection.
      */
-    getSheet(): ISheet;
+    getWorksheet(): IWorksheet;
     /**
      * Returns the selected cell.
      */
@@ -273,7 +273,7 @@ export declare namespace IRangeSelection {
         /**
          * The sheet to which the selection belongs.
          */
-        sheet: ISheet;
+        sheet: IWorksheet;
         /**
          * Initial selection coordinates.
          */

package/types/src/selection/ItemSelection.d.ts

@@ -0,0 +1,49 @@
+import { IListener } from '../listener';
+import { IItemSelection } from './IItemSelection';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+/**
+ * The mechanics of an {@link IItemSelection}: the picks, their container, the active item,
+ * replacing and extending, and the listeners. What a kind of selection admits and how it walks
+ * its items for {@link traverse} is the subclass's.
+ */
+export declare abstract class ItemSelection<T extends IItemSelection.Item> implements IItemSelection<T> {
+    protected _emitter: ListenerEmitter<IItemSelection<T>, IItemSelection.IListeners<T>>;
+    /** The selected items in the order they were picked; the last is the active one. */
+    protected _picks: readonly T[];
+    protected _container: T | null;
+    constructor();
+    /** {@inheritDoc IItemSelection.getContainer} */
+    getContainer(): T | null;
+    /** {@inheritDoc IItemSelection.getItems} */
+    getItems(): readonly T[];
+    /** {@inheritDoc IItemSelection.getActive} */
+    getActive(): T | null;
+    /** {@inheritDoc IItemSelection.isSelected} */
+    isSelected(item: T): boolean;
+    /** {@inheritDoc IItemSelection.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc IItemSelection.select} */
+    select(items: readonly T[], options?: IItemSelection.SelectOptions): this;
+    /** {@inheritDoc IItemSelection.unselect} */
+    unselect(items: readonly T[]): this;
+    /** {@inheritDoc IItemSelection.clear} */
+    clear(): this;
+    /** {@inheritDoc IItemSelection.traverse} */
+    traverse(reverse?: boolean): this;
+    /** {@inheritDoc IItemSelection.isEquals} */
+    isEquals(other: IItemSelection<T>): boolean;
+    /** {@inheritDoc IItemSelection.addListeners} */
+    addListeners(listeners: IItemSelection.IListeners<T>, options?: IListener.Options): IListener.Remove;
+    /** Throws where `item` cannot be selected here. */
+    protected abstract _check(item: T): void;
+    /** Every item that {@link traverse} visits, in order. */
+    protected abstract _traversal(): readonly T[];
+    /** Whether `other` selects among the same items as this one (the same sheet, the same chart). */
+    protected _comparable(_other: IItemSelection<T>): boolean;
+    /** Called with the picks about to be selected, before the selection changes: for what must come first (selecting the movable a chart is in). */
+    protected _beforeSelect(_picks: readonly T[]): void;
+    /** Called once the selection has changed. */
+    protected _afterChange(): void;
+    protected _update(picks: readonly T[], container: T | null): this;
+}
+//# sourceMappingURL=ItemSelection.d.ts.map

package/types/src/selection/MovableSelection.d.ts

@@ -1,46 +1,27 @@
 import { IListener } from '../listener';
 import { IMovable } from '../movable';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
 import { IMovableSelection } from './IMovableSelection';
-import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { ItemSelection } from './ItemSelection';
 /**
  * The movable selection of a sheet's view.
  */
-export declare class MovableSelection implements IMovableSelection {
-    protected _sheet: ISheet;
-    protected _emitter: ListenerEmitter<MovableSelection, IMovableSelection.IListeners>;
-    /** The selected movables in the order they were picked; the last is the active one. */
-    protected _picks: readonly IMovable[];
-    protected _container: IMovable | null;
+export declare class MovableSelection extends ItemSelection<IMovable> implements IMovableSelection {
+    protected _sheet: IWorksheet;
     /** {@link _picks} back to front, handed out again while the z-order holds. */
     protected _items: readonly IMovable[];
     constructor(options: IMovableSelection.ConstructorOptions);
-    /** {@inheritDoc IMovableSelection.getSheet} */
-    getSheet(): ISheet;
-    /** {@inheritDoc IMovableSelection.getContainer} */
-    getContainer(): IMovable | null;
+    /** {@inheritDoc IMovableSelection.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc IMovableSelection.getItems} */
     getItems(): readonly IMovable[];
-    /** {@inheritDoc IMovableSelection.getActive} */
-    getActive(): IMovable | null;
-    /** {@inheritDoc IMovableSelection.isSelected} */
-    isSelected(movable: IMovable): boolean;
-    /** {@inheritDoc IMovableSelection.isEmpty} */
-    isEmpty(): boolean;
-    /** {@inheritDoc IMovableSelection.select} */
-    select(movables: readonly IMovable[], options?: IMovableSelection.SelectOptions): this;
-    /** {@inheritDoc IMovableSelection.unselect} */
-    unselect(movables: readonly IMovable[]): this;
-    /** {@inheritDoc IMovableSelection.clear} */
-    clear(): this;
-    /** {@inheritDoc IMovableSelection.traverse} */
-    traverse(reverse?: boolean): this;
-    /** {@inheritDoc IMovableSelection.isEquals} */
-    isEquals(other: IMovableSelection): boolean;
     /** {@inheritDoc IMovableSelection.addListeners} */
     addListeners(listeners: IMovableSelection.IListeners, options?: IListener.Options): IListener.Remove;
-    protected _checkOnSheet(movable: IMovable): void;
-    protected _update(picks: readonly IMovable[], container: IMovable | null): this;
+    protected _traversal(): readonly IMovable[];
+    protected _comparable(other: IItemSelection<IMovable>): boolean;
+    protected _check(movable: IMovable): void;
+    protected _afterChange(): void;
     get [Symbol.toStringTag](): string;
     /** {@inheritDoc IMovableSelection.isIMovableSelection} */
     get isIMovableSelection(): true;

package/types/src/selection/RangeSelection.d.ts

@@ -3,14 +3,14 @@ import { RunCoordValue } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { IRangeSelection } from './IRangeSelection';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 /**
  * Used for managing selection of a range.
  */
 export declare class RangeSelection {
-    protected _sheet: ISheet;
+    protected _sheet: IWorksheet;
     protected _coords: Required<IRangeSelection.Coords>;
     protected _navigationPolicy: IRangeSelection.NavigationPolicy;
     protected _shapePolicy: IRangeSelection.ShapePolicy;
@@ -26,8 +26,8 @@ export declare class RangeSelection {
     getCoords(): IRangeSelection.Coords;
     /** {@inheritDoc IRangeSelection.hasTopOrLeft} */
     hasTopOrLeft(): boolean;
-    /** {@inheritDoc IRangeSelection.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc IRangeSelection.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc IRangeSelection.getCell} */
     getCell(): ICell;
     /** {@inheritDoc IRangeSelection.getRange} */

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

@@ -1,3 +1,6 @@
 export * from './IRangeSelection';
+export * from './IItemSelection';
 export * from './IMovableSelection';
+export * from './IChartElementSelection';
+export { ChartElementSelection } from './ChartElementSelection';
 //# sourceMappingURL=index.d.ts.map

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

@@ -290,7 +290,8 @@ export declare namespace IShape {
          * The theme style the shape draws with wherever it states no fill, stroke or text color of its
          * own: the file's `style` element, which refers into the theme's format scheme by position.
          * A reference not stated is Excel's for a new shape (a connector's differ: the first line, no
-         * fill); `null`, the shape has no style and draws only what it states itself.
+         * fill; a text box's take nothing from the format scheme); `null`, the shape has no style and
+         * draws only what it states itself.
          */
         style?: ITheme.StyleRefsJSON | null;
         /**

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

@@ -1,5 +1,5 @@
 import { ITransaction } from '../transaction';
-import { IFill, IStroke } from '../fill';
+import { IFill, IFillable, IStroke } from '../fill';
 /**
  * What a shape draws with: its fill and its line.
  *
@@ -12,6 +12,9 @@ import { IFill, IStroke } from '../fill';
  * Writes state values on the shape: `setFill('red')` makes the fill the shape's own, and
  * `setFill(null)` hands it back to the theme style. {@link toJSON} answers only what the shape
  * states, never the resolved values; {@link isThemed} says whether it states anything at all.
+ * A partial fill update merges into the resolved fill, so a color on a themed shape gives a solid
+ * fill of that color; `setFillNone()` states that the shape has no fill, which is not the same as
+ * leaving it to the theme style.
  *
  * Every write is one undoable step, transactional like the rest of the shape.
  *
@@ -24,36 +27,7 @@ import { IFill, IStroke } from '../fill';
  * style.clear();                               // back to the theme style
  * ```
  */
-export interface IShapeStyle {
-    /**
-     * The fill, resolved. A shape that states none draws its theme style's.
-     */
-    getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.IImage | IFill.INone;
-    /**
-     * Sets the fill: a color, a fill, or fill properties; `null` for the theme style's.
-     *
-     * @remarks
-     * A partial update merges into the resolved fill, so a color on a themed shape gives a solid
-     * fill of that color.
-     */
-    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): IShapeStyle;
-    /**
-     * Makes the fill solid, keeping the color the fill resolves to, and returns it.
-     */
-    setFillSolid(options?: ITransaction.OperationOptions): IFill.ISolid;
-    /**
-     * Makes the fill a gradient and returns it.
-     */
-    setFillGradient(options?: ITransaction.OperationOptions): IFill.IGradient;
-    /**
-     * Makes the fill a pattern and returns it.
-     */
-    setFillPattern(options?: ITransaction.OperationOptions): IFill.IPattern;
-    /**
-     * Removes the fill: the shape states that it has none, which is not the same as leaving it to
-     * the theme style.
-     */
-    setFillNone(options?: ITransaction.OperationOptions): IFill.INone;
+export interface IShapeStyle extends IFillable<IShapeStyle> {
     /**
      * The line, resolved. A shape that states none draws its theme style's; a line the shape
      * states without a color takes the theme style's color, as in Excel.

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

@@ -0,0 +1,85 @@
+import { ITransaction } from '../transaction';
+import { IFill, IStroke } from '../fill';
+import { IFontStyle } from '../font';
+import { IShapeStyle } from './IShapeStyle';
+/**
+ * What a text box draws with: its fill, its line and the font of its text.
+ *
+ * @remarks
+ * A chart's title, legend, axes, data labels and data table are text boxes: one
+ * `getStyle()` answers how each looks, as `range.getStyle()` does for a cell. A part with no text,
+ * such as a series or the plot area, answers an {@link IShapeStyle}; `isITextBoxStyle` tells them
+ * apart.
+ *
+ * The font reads what is drawn, stated or not; what the box does not state it takes from the text
+ * around it. {@link toJSON} answers only what the box states.
+ *
+ * @example
+ * ```ts
+ * const style = chart.getTitle().getStyle();
+ * style.getFont().setBold(true);
+ * style.update({ fill: 'white', font: { size: 18, color: 'accent1' } });
+ * style.clear();                       // fill, line and font back to the chart's
+ * ```
+ */
+export interface ITextBoxStyle extends IShapeStyle {
+    /**
+     * Returns the font of the box's text.
+     */
+    getFont(): IFontStyle;
+    /** {@inheritDoc IFillable.setFill} */
+    setFill(fill: IFill.Update, options?: ITransaction.OperationOptions): ITextBoxStyle;
+    /** {@inheritDoc IShapeStyle.setStroke} */
+    setStroke(stroke: IStroke.Update, options?: ITransaction.OperationOptions): ITextBoxStyle;
+    /**
+     * Sets fill, line and font at once, as one undoable step.
+     */
+    update(update: ITextBoxStyle.Update, options?: ITransaction.OperationOptions): ITextBoxStyle;
+    /**
+     * Removes everything the box states, its font too.
+     */
+    clear(options?: ITransaction.OperationOptions): ITextBoxStyle;
+    /**
+     * What the box states itself, never the resolved values; `null` when it states nothing.
+     */
+    toJSON(): ITextBoxStyle.JSON | null;
+    /**
+     * For type checking.
+     */
+    readonly isITextBoxStyle: true;
+}
+/**
+ * {@inheritDoc ITextBoxStyle}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITextBoxStyle}
+ */
+export declare namespace ITextBoxStyle {
+    /**
+     * The properties a text box states.
+     */
+    interface Properties extends IShapeStyle.Properties {
+        /** The font of the text. */
+        font?: IFontStyle.Properties;
+    }
+    /**
+     * A partial list of properties: {@link IShapeStyle.Modifiers} and the font. `null` for the font
+     * hands it back to the text around the box.
+     */
+    interface Modifiers extends IShapeStyle.Modifiers {
+        /** {@inheritDoc ITextBoxStyle.getFont} */
+        font?: IFontStyle.Update | null;
+    }
+    /**
+     * Options for updating a text box style: a style (what it states), modifiers, or `null` to clear.
+     */
+    type Update = ITextBoxStyle | IShapeStyle | Modifiers | null;
+    /**
+     * A JSON representation useful for persistence: what the box states.
+     */
+    interface JSON extends IShapeStyle.JSON {
+        font?: IFontStyle.JSON;
+    }
+}
+//# sourceMappingURL=ITextBoxStyle.d.ts.map

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

@@ -3,8 +3,20 @@ import { ITheme } from '../theme';
 import { IMovable } from '../movable/IMovable';
 import { IText, ITextFrame } from '../text';
 import { IShape } from './IShape';
-/** The style references a shape takes for each one it does not state; a connector's differ. */
+/** The style references a shape takes for each one it does not state; a connector's and a text box's differ. */
 export declare function defaultStyleRefs(json: IShape.JSON | null | undefined): Readonly<ITheme.StyleRefsJSON>;
+/**
+ * A new object's JSON over what its theme gives a new object of its kind
+ * ({@link ITheme.getObjectDefaults}): a line or connector takes the line default, a text box the
+ * text box default, anything else the shape default. What the JSON states wins; a line and a text
+ * body are merged a level down, so an arrowhead the JSON states keeps the default's width and color.
+ *
+ * @remarks
+ * Call this when inserting, not when copying or loading: the object keeps what it took, and a later
+ * change to the theme's defaults does not reach it. A text box whose theme states no default takes
+ * Excel's built-in one.
+ */
+export declare function withThemeDefaults(json: IShape.JSON, theme: ITheme): IShape.JSON;
 /**
  * `style` with every reference equal to its default left out: `undefined` when none is left,
  * `null` (no style at all) kept.