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

package/types/src/table/ITable.d.ts

@@ -5,7 +5,7 @@ import { IProperties } from '../type';
 import { IListener } from '../listener';
 import { IHistory } from '../history';
 import { ICellRange } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { INamed } from '../named';
 import { ICondition } from '../condition';
 import { ISort } from '../sort';
@@ -280,13 +280,7 @@ export declare namespace ITable {
          */
         columns?: (string | ITable.ColumnProperties)[];
         /**
-         * A string representing the name of the table. This is the name that shall be used in formula references,
-         * and displayed in the UI to the spreadsheet user.
-         * This name shall not have any spaces in it, and it must be unique amongst all other displayNames and
-         * definedNames in the names. The character lengths and restrictions are the same as for definedNames.
-         *
-         * @see
-         * See SpreadsheetML Reference - Workbook definedNames section for details.
+         * Free text describing the table, such as what it holds. Not used in formulas.
          */
         description?: string;
         /**
@@ -370,7 +364,7 @@ export declare namespace ITable {
          * place, so its name and the references to it stay as they are; anywhere else it is removed
          * and added again under its name.
          */
-        copyTo(destination: ITable.SnapshotDestination, options?: ReferenceableClipboard.CopyOptions): Promise<IRange.Coords>;
+        copyTo(destination: ITable.SnapshotDestination, options?: ReferenceableClipboard.CopyOptions): IRange.Coords;
     }
     /**
      * A JSON representation useful for persistence.
@@ -388,6 +382,10 @@ export declare namespace ITable {
          * The button may be hidden for other reasons like there is no filter.
          */
         hiddenButtons?: boolean | number[];
+        /**
+         * If the grid's controls around the table are hidden. See {@link ITable.setHiddenDecorations}.
+         */
+        hiddenDecorations?: boolean;
         /**
          * **OOXML** - Not sure what it is used for.
          */
@@ -463,8 +461,8 @@ export interface ITable extends IAnchored {
     /**
      * Add a single row to the table.
      *
-     * @param index The body row the new row goes in before, `0` being the first. Omitted, the row
-     * is added at the end.
+     * @param index The body row the new row goes in before, `0` being the first. Omitted or `-1`,
+     * the row is added at the end.
      *
      * @remarks
      * This is a convenience method for {@link addRows(index, 1)}
@@ -473,8 +471,8 @@ export interface ITable extends IAnchored {
     /**
      * Add a number of rows to a table.
      *
-     * @param index The body row the new rows go in before, `0` being the first. An index at or past
-     * the number of body rows adds them at the end, above the totals row if there is one.
+     * @param index The body row the new rows go in before, `0` being the first. `-1`, or an index at
+     * or past the number of body rows, adds them at the end, above the totals row if there is one.
      * @param count The number of rows to add. Defaults to `1`.
      *
      * @remarks
@@ -489,13 +487,14 @@ export interface ITable extends IAnchored {
      */
     addRows(index: number, count?: number, options?: ITransaction.OperationOptions): ITable;
     /**
-     * Delete the rows from the table.
+     * Delete rows from the table's body.
      *
-     * @remarks
-     * Not implemented
+     * @param index The first body row to delete, `0` being the first.
+     * @param count The number of rows to delete. Defaults to `1`.
      *
-     * @param index The index to clear from
-     * @param count
+     * @remarks
+     * The rows are deleted across the table's columns only: cells below the table move up, and cells
+     * beside it stay where they are.
      */
     deleteRowsAt(index: number, count?: number, options?: ITransaction.OperationOptions): ITable;
     /**
@@ -909,6 +908,20 @@ export interface ITable extends IAnchored {
      * This will only return `true` if all buttons are hidden.
      */
     isHiddenButtons(): boolean;
+    /**
+     * If `hidden` is `true`, the grid shows none of its controls around the table: the handle at its
+     * bottom-right corner that resizes it by dragging, and the toolbar that floats beside it on hover.
+     *
+     * @remarks
+     * For a table an app manages itself. Only the controls are hidden: the table still grows as
+     * content is typed next to it (see {@link setAutoExpand}), and its filter buttons are
+     * {@link setHiddenButtons}. Not saved to xlsx, which has no such setting.
+     */
+    setHiddenDecorations(hidden: boolean): this;
+    /**
+     * Whether the grid's controls around the table are hidden. See {@link setHiddenDecorations}.
+     */
+    isHiddenDecorations(): boolean;
     /**
      * Add Listeners.
      *
@@ -923,7 +936,7 @@ export interface ITable extends IAnchored {
     /**
      * Returns the sheet the table is associated with.
      */
-    getSheet(): ISheet | null;
+    getWorksheet(): IWorksheet | null;
     /**
      * The table's entry in the workbook's names, or `null` if it is not named.
      *

package/types/src/table/_NamedTable.d.ts

@@ -1,14 +1,14 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { INamed } from '../named';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { ITransaction } from '../transaction';
 import { ITable } from './ITable';
 import { AbstractNamed } from '../named/AbstractNamed';
 export declare class NamedTable extends AbstractNamed<ITable, any> {
-    protected _sheet: ISheet;
+    protected _sheet: IWorksheet;
     protected _table: ITable;
-    constructor(sheet: ISheet, table: ITable, options: INamed.ConstructorOptions<ITable>);
+    constructor(sheet: IWorksheet, table: ITable, options: INamed.ConstructorOptions<ITable>);
     select(options?: ICellRange.SelectOptions): Promise<this>;
     getRanges(): ICellRanges | null;
     /**

package/types/src/table/_NamedTableSource.d.ts

@@ -1,7 +1,7 @@
 import { IListener } from '../listener';
 import { INamed } from '../named';
 import { NamedCollection } from '../named/NamedCollection';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 /**
  * Presents the tables of one or more sheets as named items.
  *
@@ -47,7 +47,7 @@ export declare class NamedTableSource implements NamedCollection.Source {
 export declare namespace NamedTableSource {
     interface ConstructorOptions {
         /** The sheets whose tables are contributed. Re-read on every query. */
-        getSheets: () => readonly ISheet[];
+        getSheets: () => readonly IWorksheet[];
         /**
          * Subscribes to the sheet list changing, so tables on a sheet added later are picked up.
          * Omitted for a single, fixed sheet.

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

@@ -35,24 +35,6 @@ export declare namespace IText {
         readonly All: "all";
     };
     type SmallCaps = typeof SmallCaps[keyof typeof SmallCaps];
-    /**
-     * Indicate how and if a line will be drawing horizontally through the middle of the text.
-     */
-    const StrikeStyle: {
-        /**
-         * No strike-through
-         */
-        readonly None: "none";
-        /**
-         * A single line.
-         */
-        readonly Single: "single";
-        /**
-         * A double line.
-         */
-        readonly Double: "double";
-    };
-    type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
     /**
      * How a paragraph's text is aligned between its margins.
      */
@@ -81,35 +63,6 @@ export declare namespace IText {
         readonly Bottom: "bottom";
     };
     type FontAlignment = typeof FontAlignment[keyof typeof FontAlignment];
-    /**
-     * How a run of drawing text is underlined.
-     *
-     * @remarks
-     * Drawing text has more underlines than a cell's font ({@link IFont.UnderlineStyle}); the two
-     * agree on `none`, `single` and `double`.
-     */
-    const UnderlineStyle: {
-        readonly None: "none";
-        /** Each word underlined, the spaces between them not. */
-        readonly Words: "words";
-        readonly Single: "single";
-        readonly Double: "double";
-        readonly Heavy: "heavy";
-        readonly Dotted: "dotted";
-        readonly DottedHeavy: "dottedHeavy";
-        readonly Dash: "dash";
-        readonly DashHeavy: "dashHeavy";
-        readonly DashLong: "dashLong";
-        readonly DashLongHeavy: "dashLongHeavy";
-        readonly DotDash: "dotDash";
-        readonly DotDashHeavy: "dotDashHeavy";
-        readonly DotDotDash: "dotDotDash";
-        readonly DotDotDashHeavy: "dotDotDashHeavy";
-        readonly Wavy: "wavy";
-        readonly WavyHeavy: "wavyHeavy";
-        readonly WavyDouble: "wavyDouble";
-    };
-    type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
     /**
      * A font named by a run: a family, or one of the theme's two fonts.
      */
@@ -129,8 +82,8 @@ export declare namespace IText {
      * raises the run as a superscript), colors are fills or serialized colors.
      *
      * @remarks
-     * Where a cell's font has the same property ({@link IStyledFont.Properties}) the name and
-     * values are the same: `weight`, `style`, `letterSpacing`, `family`.
+     * Where a text style has the same property ({@link IFontStyle.Properties}) the name and values
+     * are the same: `weight`, `style`, `underline`, `strike`, `letterSpacing`, `baseline`.
      */
     interface RunPropertiesJSON {
         /** Font size in points. */
@@ -138,8 +91,8 @@ export declare namespace IText {
         /** `700` for bold, `400` for regular. */
         weight?: number;
         style?: IFont.Style;
-        underline?: UnderlineStyle;
-        strike?: StrikeStyle;
+        underline?: IFont.UnderlineStyle;
+        strike?: IFont.StrikeStyle;
         /** The text color: a fill (solid, gradient, pattern) or a serialized color. */
         color?: IFill.JSON | string;
         /** The Latin font. */

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

@@ -0,0 +1,34 @@
+import { SdkWasmExports } from '../wasm';
+import { TextWrapperFallback } from './_TextWrapperFallback';
+/** The lazily loaded TypeScript wrapper and its `linebreak` package. */
+export type TextFallbackModule = {
+    TextWrapperFallback: typeof TextWrapperFallback;
+};
+/**
+ * What wraps text: the Rust wrapper in the sdk's wasm, or, only where that cannot load (a
+ * Content Security Policy without `'wasm-unsafe-eval'`, Lockdown Mode), the TypeScript wrapper
+ * with its `linebreak` package as a chunk of its own. One or the other is loaded before any text
+ * is wrapped, never both; a wrap before either is an error naming `whenReady()`. The font
+ * collection starts the load when it starts and counts it among the loads its `whenReady()`
+ * waits for, so a workbook's `whenReady()` covers it.
+ *
+ * @remarks
+ * Internal to the sdk. In Node the wasm is instantiated as the sdk loads, so there is no window
+ * in which nothing is loaded.
+ */
+export declare const TextEngine: {
+    /**
+     * Loads the engine: the wasm, and the TypeScript fallback only if that fails. Rejects only
+     * when neither loads.
+     */
+    load: () => Promise<void>;
+    /** Loads the TypeScript wrapper whether or not the wasm is there: for comparing the two. */
+    loadFallback: () => Promise<TextFallbackModule>;
+    /** Whether a wrap can run now. */
+    isLoaded: () => boolean;
+    /** The wasm, if it has loaded. */
+    peekWasm: () => SdkWasmExports | undefined;
+    /** The TypeScript wrapper, if it has loaded. */
+    peekFallback: () => TextFallbackModule | undefined;
+};
+//# sourceMappingURL=TextEngine.d.ts.map

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

@@ -1,10 +1,10 @@
 import { Size, Bounds, Rectangle } from '@sheetxl/utils';
+import { IFontStyle } from '../font';
 import { TextVisitor } from './TextVisitor';
 import { ITextLine } from './TextLine';
 import { ITextParagraph } from './TextParagraph';
 import { ITextFrame } from './ITextFrame';
 import { ITextBoxAlignment } from './TextBoxAlignment';
-import { IStyledFont } from './richtext';
 export declare class TextFrame {
     private _private;
     private _bounds;
@@ -12,9 +12,11 @@ export declare class TextFrame {
     private _lines;
     private _lastLayoutSize;
     private _lastLayout;
+    /** The fonts the last layout measured with: a font that arrived since makes it stale. */
+    private _lastLayoutFonts;
     private _defaultFont;
     private _alignment;
-    constructor(overrides: Partial<ITextFrame>, defaultFont: IStyledFont, alignment: ITextBoxAlignment, lines?: ITextLine[] | null, bounds?: Bounds | null, textBounds?: Bounds | null);
+    constructor(overrides: Partial<ITextFrame>, defaultFont: IFontStyle, alignment: ITextBoxAlignment, lines?: ITextLine[] | null, bounds?: Bounds | null, textBounds?: Bounds | null);
     visitParas(visitor: TextVisitor): void;
     visitLines(visitor: TextVisitor): void;
     layout(size?: Partial<Size> | null): ITextFrame;

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

@@ -1,4 +1,5 @@
 import { Bounds } from '@sheetxl/utils';
+import { IFont } from '../font';
 import { IText } from './IText';
 import { TextVisitor } from './TextVisitor';
 /**
@@ -51,7 +52,7 @@ export interface ITextRun {
     /**
      * Specifies the strikethrough style applied to the text.
      */
-    readonly strikeStyle: IText.StrikeStyle;
+    readonly strikeStyle: IFont.StrikeStyle;
     /**
        * Specifies the baseline for both the superscript and subscript fonts.
        * The size is specified using a percentage where 1000 is equal to 1 percent
@@ -87,7 +88,7 @@ export declare class DefaultTextRun implements ITextRun, PlacedTextRun, Cloneabl
     get kerningMin(): number;
     get smallCaps(): IText.SmallCaps;
     get offset(): number;
-    get strikeStyle(): IText.StrikeStyle;
+    get strikeStyle(): IFont.StrikeStyle;
     /** {@inheritDoc ITextRun.isITextRun} */
     get isITextRun(): true;
 }

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