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

package/types/src/text/TextWrapper.d.ts

@@ -1,4 +1,4 @@
-import { IFont } from '../font';
+import { IFontCollection } from '../font';
 /**
  * Simple Text Line Wrapper. Is not useful for Rich Text (yet). see TextLayout.
  */
@@ -43,36 +43,42 @@ export interface Line {
 export interface onLine {
     (line: Line): boolean | void;
 }
+export interface TextWrapperConfig {
+    /**
+     * Wrap in the Rust wrapper when the wasm is there (the default). `false` keeps every wrap on
+     * the TypeScript one, for comparing the two; that one must have been loaded
+     * (`TextEngine.loadFallback()`).
+     */
+    native?: boolean;
+}
 export declare function linesToText(lines: Line[], trimTrailingSpace?: boolean): string;
 /**
- * A simple text wrapper that uses a line breaker to break lines.
+ * Wraps text into lines against a width, measuring from the font collection.
  *
- * *PERFORMANCE OPTIMIZATIONS*
- * - Binary search for wordBreak
- * - Reuse all of the objects. (this should support a reuse flag and it lines are not needed then they can also be internally reused)
- * - Have text measure for collapsed text just calc the difference between the two (just trailing whitespace, is there kerning?)
+ * @remarks
+ * Two wrappers behind one call, one of them loaded before any text is wrapped
+ * ({@link TextEngine}): the Rust one in the sdk's wasm (`sheetxl-text`), or, only where the wasm
+ * cannot load, the TypeScript one with its `linebreak` package. Both measure from the same
+ * {@link IFont.AdvanceTable}, the Rust one through the table's wasm twin, and break the same way,
+ * so which one answers changes no size (`wrap.differential.node.test.ts`: zero
+ * disagreements over the corpus). A wrap before either has loaded is an error: wait for
+ * `IWorkbook.whenReady()` first.
  */
 export declare class TextWrapper {
-    private _textMeasurer;
-    private _breaker;
-    private _lastBreak;
-    private _charactersRead;
-    private _linesRead;
-    private _maxXRead;
-    private _maxXWhitespaceRead;
-    private _maxYRead;
-    private _fontName;
-    private _fontSize;
-    private _metricOptions;
-    private _indent;
-    private _isSuperSub;
-    private _ellipsis;
-    private _maxWidth;
-    private _maxHeight;
-    constructor(textMeasurer: IFont.Measurer);
-    private _measureText;
-    private _breakWord;
-    private _breakWhiteSpace;
+    private readonly _fonts;
+    private readonly _useNative;
+    /**
+     * @param fonts Where the font named by each wrap's options is measured from.
+     */
+    constructor(fonts?: IFontCollection, config?: TextWrapperConfig);
+    /** Whether the next wrap runs in the Rust wrapper. */
+    get isNative(): boolean;
     wrap(text: string, options?: TextWrapperOptions | null): TextWrapperResults;
+    /**
+     * The wrap through the Rust wrapper: the text crosses the boundary once and the lines come
+     * back as one flat array, {@link NATIVE_LINE_STRIDE} numbers each (DESIGN-FONTS §6.2:
+     * one call per wrap). Its offsets are UTF-8 bytes, turned into UTF-16 positions here.
+     */
+    private _wrapNative;
 }
 //# sourceMappingURL=TextWrapper.d.ts.map

package/types/src/text/_TextUtils.d.ts

@@ -1,17 +1,17 @@
 import { Size } from '@sheetxl/utils';
-import { IFont } from '../font';
+import { IFontCollection } from '../font';
 import { ITextFrame } from './ITextFrame';
 import { ITextBoxAlignment } from './TextBoxAlignment';
-import { IStyledFont } from './richtext/IStyledFont';
+import { IFontStyle } from '../font/IFontStyle';
 /**
  * This 'places' text which means that using all of the formatting rules it assign's locations and bounds to
  * all of the characters. It does not however actually render them. See @renderTextFrame for rendering.
  *
  * @param textFrame
  * @param dimensions
- * @param textMeasurer This defaults to a canvas context
+ * @param fonts Where fonts are measured from; the shared collection by default.
  */
-export declare function layoutTextFrame(textFrame: ITextFrame, defaultFont: IStyledFont, alignment: ITextBoxAlignment, dimensions?: Partial<Size> | null, textMeasurer?: IFont.Measurer): ITextFrame;
+export declare function layoutTextFrame(textFrame: ITextFrame, defaultFont: IFontStyle, alignment: ITextBoxAlignment, dimensions?: Partial<Size> | null, fonts?: IFontCollection): ITextFrame;
 /**
  * Checks whether a string is entirely uppercase, lowercase, or mixed case.
  *
@@ -86,5 +86,5 @@ export declare function convertCase(str: string, caseArray: readonly number[]):
  * TODO - abstract CellStyle
  * @internal
  */
-export declare function createTextFrameFromText(text: string, defaultFont: IStyledFont, alignment: ITextBoxAlignment, allowWrap: boolean, disableCustomFormatting?: boolean): ITextFrame;
+export declare function createTextFrameFromText(text: string, defaultFont: IFontStyle, alignment: ITextBoxAlignment, allowWrap: boolean, disableCustomFormatting?: boolean): ITextFrame;
 //# sourceMappingURL=_TextUtils.d.ts.map

package/types/src/text/_TextWrapperFallback.d.ts

@@ -0,0 +1,49 @@
+import { IFontCollection } from '../font';
+import { TextWrapperOptions, TextWrapperResults } from './TextWrapper';
+/**
+ * A simple text wrapper that uses a line breaker to break lines.
+ *
+ * @remarks
+ * Widths are advance sums with no kerning, so a line is measured as it grows, a character at a
+ * time ({@link Tally}): no character is measured twice, however long the line.
+ */
+export declare class TextWrapperFallback {
+    private _fonts;
+    private _table;
+    private _letterSpacing;
+    private _breaker;
+    private _lastBreak;
+    private _charactersRead;
+    private _linesRead;
+    private _maxXRead;
+    private _maxXWhitespaceRead;
+    private _maxYRead;
+    private _fontSize;
+    private _indent;
+    private _isSuperSub;
+    private _maxWidth;
+    private _maxHeight;
+    /** One character's advance in px, by character, for the current wrap. */
+    private _advances;
+    private _metrics;
+    /** The current line from its start to {@link _charactersRead}. */
+    private _lineTally;
+    /**
+     * @param fonts Where the font named by each wrap's options is measured from.
+     */
+    constructor(fonts: IFontCollection);
+    private _finish;
+    /** `[trailing white space trimmed, as is]`. */
+    private _widths;
+    private _advance;
+    /** Grows `tally` by `text`, the characters that follow the phrase it measures. */
+    private _extend;
+    /**
+     * Breaks a word that does not fit into full lines of characters, at least one per line; the
+     * remainder becomes `currentLine`, its tally the line's.
+     */
+    private _breakWord;
+    private _breakWhiteSpace;
+    wrap(text: string, options?: TextWrapperOptions | null): TextWrapperResults;
+}
+//# sourceMappingURL=_TextWrapperFallback.d.ts.map

package/types/src/text/impl/TabStrategy.d.ts

@@ -1,8 +1,10 @@
 import { ITextFrame } from '../ITextFrame';
 import { Phrase } from './Phrase';
 import { IFont } from '../../font';
+/** Measures a phrase's text in the frame's font. */
+export type TabTextMeasurer = (text: string) => IFont.ExtendedMetrics;
 export interface TabStrategy {
-    width(x: number, xOffset: number, maxX: number, tabStop: ITextFrame.TabStop, phrase: Phrase, textMeasurer: IFont.Measurer): number;
+    width(x: number, xOffset: number, maxX: number, tabStop: ITextFrame.TabStop, phrase: Phrase, textMeasurer: TabTextMeasurer): number;
     yanks(): boolean;
     shrinksToZero(): boolean;
 }

package/types/src/text/richtext/IRichText.d.ts

@@ -1,4 +1,4 @@
-import { IStyledFont } from './IStyledFont';
+import { IFontStyle } from '../../font';
 /**
  * Text with formatting: a list of {@link IRichText.Run | runs}, each a span of text with the font
  * properties it sets.
@@ -24,7 +24,15 @@ export declare namespace IRichText {
          * `{ style: 'italic' }`. The color is any string a font's color takes; one read from a file keeps
          * its theme or indexed color that way.
          */
-        font?: IStyledFont.JSON;
+        font?: IFontStyle.JSON;
+    }
+    /**
+     * A run as given to a setter: the font may use the update spellings (`bold`, `italic`,
+     * `underline: true`), which are folded onto the properties a stored {@link Run} carries.
+     */
+    interface RunUpdate {
+        text: string;
+        font?: IFontStyle.Update<string> | null;
     }
     /**
      * The serialized form: the runs, in order.
@@ -32,5 +40,11 @@ export declare namespace IRichText {
     interface JSON {
         runs: Run[];
     }
+    /**
+     * What a setter takes: runs, a {@link JSON}, or plain text for one run.
+     */
+    type Update = JSON | {
+        runs: readonly RunUpdate[];
+    } | readonly RunUpdate[] | string;
 }
 //# sourceMappingURL=IRichText.d.ts.map

package/types/src/text/richtext/index.d.ts

@@ -1,3 +1,2 @@
-export * from './IStyledFont';
 export * from './IRichText';
 //# sourceMappingURL=index.d.ts.map

package/types/src/theme/ITheme.d.ts

@@ -1,6 +1,7 @@
 import { IColor } from '../color';
 import { IFont } from '../font';
 import { IFill, IStroke, IEffect } from '../fill';
+import { IShape } from '../shape';
 import { buildPalette as _buildPalette } from './_ThemeUtils';
 /**
  * Defines and manages themes associated to a specific document or spreadsheet.
@@ -34,6 +35,14 @@ export interface ITheme {
      * Office's.
      */
     getFormatScheme(): ITheme.FormatScheme;
+    /**
+     * What a new shape, line or text box starts from in this theme.
+     *
+     * @remarks
+     * Read once, when the object is inserted (`ShapeStyleUtils.withThemeDefaults`); the object
+     * keeps what it took. A theme that states none has the base theme's.
+     */
+    getObjectDefaults(): Readonly<ITheme.ObjectDefaultsJSON>;
     /**
      * This is available for functions that want to resolve themed colors
      *
@@ -207,15 +216,60 @@ export declare namespace ITheme {
          * @returns An array of fallback fonts for the minor font.
          */
         getMinorFallbacks(): readonly string[];
+        /**
+         * The heading fonts, as the scheme states them or as the theme it builds on does.
+         */
+        getMajor(): Readonly<ITheme.FontCollectionJSON>;
+        /**
+         * The body fonts, as the scheme states them or as the theme it builds on does.
+         */
+        getMinor(): Readonly<ITheme.FontCollectionJSON>;
     }
-    interface FontSchemeProperties {
-        majorFont: string;
-        majorFallbacks: string[];
-        minorFont: string;
-        minorFallbacks: string[];
-        name: string;
+    /**
+     * The fonts of one role in a font scheme, heading (major) or body (minor), by the kind of text
+     * they are for.
+     */
+    interface FontCollectionJSON {
+        /**
+         * The font for Latin text: what a cell whose font names the scheme draws with.
+         */
+        latin?: string;
+        /**
+         * The PANOSE classification of {@link latin}, 20 hexadecimal digits. It chooses the generic
+         * family drawn with when the font is not installed.
+         */
+        panose?: string;
+        /**
+         * The font for East Asian text. Usually empty, with the font given by script in {@link scripts}.
+         */
+        eastAsian?: string;
+        /**
+         * The font for complex-script text (Arabic, Hebrew, Thai, ...). Usually empty, with the font
+         * given by script in {@link scripts}.
+         */
+        complexScript?: string;
+        /**
+         * Fonts by the script of the text, keyed by ISO 15924 code (`Jpan`, `Hang`, `Arab`, ...), in the
+         * order they are listed.
+         */
+        scripts?: Record<string, string>;
     }
-    interface FontSchemeJSON extends Partial<FontSchemeProperties> {
+    /**
+     * A theme's fonts: one collection for headings and one for body text.
+     *
+     * @remarks
+     * A collection is taken whole: one that is stated replaces the base theme's, script fonts included.
+     */
+    interface FontSchemeJSON {
+        name?: string;
+        /**
+         * The heading fonts. Office calls these the **Headings** font.
+         */
+        major?: FontCollectionJSON;
+        /**
+         * The body fonts. Office calls these the **Body** font.
+         */
+        minor?: FontCollectionJSON;
     }
     /**
      * One reference into a theme style list (`fillRef`, `lnRef`, `effectRef`): the one-based position
@@ -288,6 +342,53 @@ export declare namespace ITheme {
          * represented are still populated, so the theme draws with them.
          */
         formatSchemeXml?: string;
+        /**
+         * What a new shape, line or text box starts from. Stated, it replaces the base theme's whole,
+         * so `{}` means none.
+         */
+        objectDefaults?: ITheme.ObjectDefaultsJSON;
+        /**
+         * Colors the theme offers beside its scheme, in order: Office lists them as **Custom Colors**
+         * in its color pickers. Not inherited from the base theme.
+         */
+        customColors?: ITheme.CustomColorJSON[];
+        /**
+         * Which theme this is, across the files and versions it appears in. Not inherited from the
+         * base theme.
+         */
+        family?: ITheme.FamilyJSON;
+    }
+    /**
+     * A color a theme offers beside its scheme (DrawingML's `custClr`).
+     */
+    interface CustomColorJSON {
+        /** The name shown for the color. */
+        name?: string;
+        color: string;
+    }
+    /**
+     * A theme's identity (the 2012 theme extension's `themeFamily`). Office matches themes by
+     * {@link id}, and the versions of one theme by {@link vid}.
+     */
+    interface FamilyJSON {
+        /** The family's name, such as `Office Theme`. */
+        name: string;
+        /** A GUID in braces, the same for every version of the theme. */
+        id: string;
+        /** A GUID in braces naming this version. */
+        vid?: string;
+    }
+    /**
+     * What a new object starts from, by kind: its fill, line, effects, text body and style
+     * references, as a shape states them. DrawingML's `objectDefaults`.
+     */
+    interface ObjectDefaultsJSON {
+        /** A new shape (`spDef`). */
+        shape?: IShape.JSON;
+        /** A new line or connector (`lnDef`). */
+        line?: IShape.JSON;
+        /** A new text box (`txDef`). */
+        text?: IShape.JSON;
     }
 }
 //# sourceMappingURL=ITheme.d.ts.map

package/types/src/theme/ThemeCollection.d.ts

@@ -16,6 +16,9 @@ export declare class Theme implements ITheme {
     private _effectStyleLst;
     private _bgFillStyleLst;
     private _formatScheme;
+    private _objectDefaults;
+    private _customColors;
+    private _family;
     private _cacheColors;
     /** System epoch at which `_cacheColors` was populated (for host-theme invalidation). */
     private _cacheEpoch;
@@ -31,6 +34,8 @@ export declare class Theme implements ITheme {
     getFontScheme(): ITheme.IFontScheme;
     /** {@inheritDoc ITheme.getFormatScheme} */
     getFormatScheme(): ITheme.FormatScheme;
+    /** {@inheritDoc ITheme.getObjectDefaults} */
+    getObjectDefaults(): Readonly<ITheme.ObjectDefaultsJSON>;
     /** {@inheritDoc ITheme.schemeLookup} */
     schemeLookup(): IColor.SchemeLookup;
     /** {@inheritDoc ITheme.parseColor} */

package/types/src/theme/_OfficeFontScheme.d.ts

@@ -0,0 +1,8 @@
+import { ITheme } from './ITheme';
+/**
+ * The fonts of the Office theme's font scheme (Excel 2013-2022), as Excel writes them into a new
+ * workbook, script fonts included.
+ */
+export declare const OFFICE_MAJOR_FONTS: Readonly<ITheme.FontCollectionJSON>;
+export declare const OFFICE_MINOR_FONTS: Readonly<ITheme.FontCollectionJSON>;
+//# sourceMappingURL=_OfficeFontScheme.d.ts.map

package/types/src/transaction/ITransaction.d.ts

@@ -657,8 +657,11 @@ export declare namespace ITransaction {
         onBeforeCommitEnd?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called after the transaction. This is generally used for cleanup or ui notification.
+         *
+         * @param previous The commit the store moved from: for a commit its parent, for a revert or
+         * restore the commit that was current before it. `null` when there is none.
          */
-        onAfterStateChange?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
+        onAfterStateChange?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>, previous: ITransaction.ICommit | null): void;
         /**
          * Called if the restore or revert is called. This is called asynchronously As should only have passive actions.
          */
@@ -776,6 +779,22 @@ export declare namespace ITransaction {
          * Called when this transaction, or any transaction it is nested in, rolls back.
          */
         onRollback?(): void;
+        /**
+         * Called each time a transaction begun directly inside this one commits, while this one is
+         * still open.
+         *
+         * @param child The transaction that committed. It has closed: what this hook writes begins
+         * inside this transaction, and is itself reported here when it commits.
+         * @param intents What `child`, and everything nested in it, recorded with
+         * {@link ITransaction.setIntent}, on its own. The operation's intents
+         * ({@link ITransaction.getIntent}) hold the union.
+         *
+         * @remarks
+         * For a caller that reacts to each step of an operation as it happens, rather than once when
+         * it lands ({@link onCommit}). Deeper transactions are part of the step that holds them and are
+         * not reported on their own. A child that rolls back is not reported.
+         */
+        onChildCommit?(child: ITransaction, intents: Readonly<Record<string, any>>): void;
     }
     /**
      * Options for operations with the store.

package/types/src/transaction/Transaction.d.ts

@@ -161,7 +161,7 @@ export declare class TransactionStore implements ITransaction.IStore {
      * the states were computed against the current snapshot and belong to it.
      */
     protected _commitRecord(container: CommitContainer, states: Map<any, any>, amendOf: string | null): void;
-    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean, source?: CommitContainer): void;
+    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean, source?: CommitContainer, previous?: ITransaction.ICommit | null): void;
     protected _notifyClose(commit: ITransaction.ICommit, isRollback: boolean, isElided?: boolean, isAmend?: boolean): void;
     _notify(event: Exclude<keyof ITransaction.IListeners, 'onCommitClose'>, commit: ITransaction.ICommit, async?: boolean): void | Promise<any>;
 }
@@ -181,6 +181,7 @@ declare abstract class AbstractTransaction implements ITransaction {
     protected _hooks: ITransaction.Hooks | null;
     protected _flushing: boolean;
     protected _outcomes: ITransaction.Hooks[] | null;
+    protected _intentMark: number;
     constructor(store: TransactionStore, container: CommitContainer, options: ITransaction.StoreOperationOptions | string | undefined);
     /** @internal Whether a read of some record flushes this transaction. */
     _isFlushedOnRead(): boolean;
@@ -199,6 +200,12 @@ declare abstract class AbstractTransaction implements ITransaction {
     protected _settle(options?: ITransaction.StoreOperationOptions): void;
     /** @internal A committed child's outcome hooks, now waiting on this transaction's outcome. */
     _adoptOutcomes(child: AbstractTransaction): void;
+    /**
+     * Tells this transaction's `onChildCommit` that `child`, begun directly inside it, has
+     * committed.
+     * @internal
+     */
+    _childCommitted(child: AbstractTransaction): void;
     /** @internal Tells the outcome hooks waiting on this transaction how the operation ended. */
     protected _notifyOutcome(commit: ITransaction.ICommit | null): void;
     /**

package/types/src/transaction/_BatchHandle.d.ts

@@ -0,0 +1,118 @@
+import { ITransaction } from './ITransaction';
+/**
+ * The handle a batch hands its callback: the same SDK objects, reached through it, bound to the
+ * batch.
+ *
+ * @remarks
+ * A batch that awaits stays open while other code runs on the event loop: a React render, a hook
+ * subscribing. The store cannot tell the batch's next line from that code, so "is a transaction
+ * open" does not say whether a caller is part of the batch. Holding the batch does. Whatever is
+ * reached through the handle is wrapped by the same rule, so a script that only ever sees the
+ * handle never touches a plain object, and code that never sees it (the UI) is outside the batch
+ * however long it stays open.
+ *
+ * A call made through the handle runs with the handle current ({@link getCurrentBatchHandle}) for
+ * its synchronous extent. That is the only scope there is: nothing is inferred across an `await`,
+ * which is what makes it safe in the browser.
+ *
+ * Objects go back into the SDK unwrapped, so the SDK only ever sees its own objects. A wrapped
+ * object is a different identity from the plain one, but the same object is always wrapped the
+ * same way, so identities compare consistently on either side.
+ *
+ * @internal
+ */
+export declare class BatchHandle {
+    protected _store: ITransaction.IStore;
+    protected _closed: boolean;
+    protected _commitId: string | null;
+    protected _stepListeners: Set<BatchHandle.StepListener> | null;
+    protected _toWrapped: WeakMap<object, any>;
+    /** @param store The store the batch is open on. */
+    constructor(store: ITransaction.IStore);
+    /** The store the batch is open on. */
+    getStore(): ITransaction.IStore;
+    /**
+     * The id of the root commit the batch writes into, or `null` before its callback has started.
+     * A batch nested in another operation shares that operation's commit.
+     */
+    getCommitId(): string | null;
+    /** Whether the batch this handle is bound to has closed. */
+    isClosed(): boolean;
+    /**
+     * The batch has closed. What was reached through the handle keeps working, as the plain object
+     * does: it is no longer part of a batch.
+     */
+    close(): void;
+    /**
+     * Hear each step of the batch as it is made: a transaction begun directly inside the batch has
+     * committed. Dropped when the batch closes.
+     */
+    addStepListener(listener: BatchHandle.StepListener): () => void;
+    protected _onStep(commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>): void;
+    /** `value` as seen through this handle. */
+    wrap<T>(value: T): T;
+    /** `value` as the SDK sees it: what this handle wrapped, unwrapped. */
+    unwrap<T>(value: T): T;
+    protected _wrapModel<T extends object>(raw: T): T;
+    protected _wrapMethod(target: object, method: (...args: any[]) => any): (...args: any[]) => any;
+    protected _methods: WeakMap<object, Map<(...args: any[]) => any, (...args: any[]) => any>>;
+    protected _unwrapArg(arg: any): any;
+    protected _unwrapCallbacks(plain: Record<string, any>): Record<string, any>;
+    protected _callbacks: WeakMap<object, Record<string, any>>;
+    /**
+     * `outward`: a function handed out by the SDK (its arguments go in unwrapped, its result comes
+     * out wrapped). Otherwise one handed in (the SDK calls it: arguments wrapped, result unwrapped).
+     */
+    protected _wrapFunction(fn: (...args: any[]) => any, outward: boolean): (...args: any[]) => any;
+    protected _outward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _inward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _wrapArray(array: any[]): any[];
+    protected _wrapIterator(iterator: Iterator<any>): Iterator<any>;
+    protected _inScope<R>(callback: () => R): R;
+    /**
+     * A batch's callback, handed `self` bound to a new handle on `store`.
+     *
+     * @remarks
+     * What the callback answers is handed back plain: the handle is over once the batch is. `close`
+     * belongs in the batch's close callback, and `onChildCommit` in the options it is begun with.
+     */
+    static bind<T extends object, R>(store: ITransaction.IStore, self: T, callback: (commit: ITransaction.ICommit, bound: T) => R | Promise<R>): {
+        callback: (commit: ITransaction.ICommit) => R | Promise<R>;
+        close: () => void;
+        onChildCommit: NonNullable<ITransaction.Hooks['onChildCommit']>;
+    };
+    /**
+     * Whether a batch open on `store` is told of each of its steps. While one is, a write is to be
+     * made as it comes, never held for later: a step made later is heard later.
+     */
+    static isStepping(store: ITransaction.IStore): boolean;
+    /** The handle `value` was reached through, or `null` for a plain object. */
+    static of(value: unknown): BatchHandle | null;
+}
+/**
+ * The open batch handle the running code was called through, or `null`.
+ *
+ * @remarks
+ * Set only for the synchronous extent of a call made through a handle that is still open. Code
+ * reached any other way - the UI, a timer, a hook - sees `null` whatever batch is open.
+ *
+ * @internal
+ */
+export declare const getCurrentBatchHandle: () => BatchHandle | null;
+/**
+ * Whether a listener registered now, on `store`, with no `transactional` of its own, takes part in
+ * the operation: it is registered through an open batch's handle, on that batch's store.
+ *
+ * @internal
+ */
+export declare const isRegisteringInBatch: (store: ITransaction.IStore) => boolean;
+export declare namespace BatchHandle {
+    /**
+     * Told as a step of the batch is made.
+     *
+     * @param commit The root commit the batch writes into.
+     * @param intents What the step recorded ({@link ITransaction.Hooks.onChildCommit}).
+     */
+    type StepListener = (commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>) => void;
+}
+//# sourceMappingURL=_BatchHandle.d.ts.map

package/types/src/type/AbstractCollection.d.ts

@@ -2,20 +2,9 @@ import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 import { ICollection } from './ICollection';
-/**
- * Base for every {@link ICollection}.
- *
- * @remarks
- * A subclass supplies {@link _getItems} — how its items are stored is its own business, keyed or
- * ordered, held here or fronted from elsewhere — and gets iteration, the count and every read
- * helper from that one call. A subclass with a cheaper count overrides {@link getCount}.
- *
- * Listeners are uniform: {@link addListeners} on the base, and {@link _notifyCollectionChange} /
- * {@link _notifyInvalidated} for the subclass to announce with. A subclass that fronts another
- * collection and forwards its events overrides `addListeners` instead of keeping a second
- * emitter.
- */
 export declare abstract class AbstractCollection<T, O extends ICollection.GetItemsOptions = ICollection.GetItemsOptions> implements ICollection<T> {
+    /** Answered by the proxy the constructor returns; see {@link ICollection}. */
+    readonly [index: number]: T;
     /**
      * The store transactional listeners are versioned in; `undefined` gives the emitter a transient
      * store of its own.
@@ -25,6 +14,8 @@ export declare abstract class AbstractCollection<T, O extends ICollection.GetIte
     private _collectionEmitter;
     private _closed;
     constructor(transactions?: ITransaction.IStore);
+    /** {@inheritDoc ICollection.length} */
+    get length(): number;
     /** {@inheritDoc ICollection.isClosed} */
     isClosed(): boolean;
     /**

package/types/src/type/ICollection.d.ts

@@ -4,9 +4,10 @@ import { IListener } from '../listener';
  * Interface used for all ICollections.
  *
  * @remarks
- * A collection is the read side of a `ReadonlyArray` without the index operator: it iterates,
- * counts, and offers the familiar helpers (`at`, `find`, `filter`, `map`, ...), but it is not an
- * array and has no `[i]` or `length`. Call {@link toArray} when an array is really wanted.
+ * A collection reads like a `ReadonlyArray`: it indexes (`[i]`), counts (`length`), iterates, and
+ * offers the familiar helpers (`at`, `find`, `filter`, `map`, ...). It is not an array —
+ * `Array.isArray` is `false` and it cannot be written through `[i]` — so call {@link toArray} when
+ * an array is really wanted.
  *
  * Iteration order is the collection's own order — insertion order for the ordered collections
  * (sheets, tables, movables) and unspecified for the keyed ones (resources, functions). Every
@@ -14,11 +15,23 @@ import { IListener } from '../listener';
  * they run.
  */
 export interface ICollection<T> {
+    /**
+     * The item at the given index, or `undefined` if there is none — `wb.getWorksheets()[0]`.
+     *
+     * @remarks
+     * Read-only and live: each read is against the collection as it is now. Assigning through an
+     * index throws.
+     */
+    readonly [index: number]: T;
+    /**
+     * The number of items — the same as {@link getCount}.
+     */
+    readonly length: number;
     /**
      * Iterates the collection's items.
      *
      * @remarks
-     * The unfiltered walk — `for (const sheet of wb.getSheets())`. Every other iterable surface in
+     * The unfiltered walk — `for (const sheet of wb.getWorksheets())`. Every other iterable surface in
      * the SDK (`ICellRange`, `ICellRegions`, `ICellRanges`) reads this way, so a collection that did
      * not was a trap: `for…of` over one is the obvious line to write and it threw at runtime with
      * nothing in the types to warn first.

package/types/src/type/IProperties.d.ts

@@ -11,7 +11,7 @@ export declare namespace IProperties {
      * @typeParam P - The type representing the properties associated with the range.
      * @typeParam U - The type accepted by updates. This need not be `P` widened - a property bag may
      * accept convenience keys that are folded onto canonical ones and never appear in `P` (see
-     * `IStyledFont.Modifiers`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
+     * `IFontStyle.Update`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
      * @typeParam J - The type representing the JSON-serializable representation of the range.
      */
     interface ICellRanged<P, U = IProperties.ResolvableProperties<P>> {

package/types/src/utils/_CSSUtils.d.ts

@@ -18,7 +18,7 @@ export declare function toHex(color: IColor, darkMode?: boolean): string;
 /** Baked modes keep the historical hex output; `'adaptive'` defers to `IColor.toCSS` (`light-dark()`). */
 export declare function toCSSColor(color: IColor, mode?: IColor.CSSMode): string;
 export declare function toCSSFontSize(size: number | null | undefined): string | null;
-export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strike: boolean): CSSTextDecoration;
+export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strikeStyle: IFont.StrikeStyle | boolean): CSSTextDecoration;
 export declare function toCSSTextUnderlineStyle(underline: IFont.UnderlineStyle): string;
 export declare const noDecoration: Readonly<{
     underline: "none";