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

package/types/src/font/IFont.d.ts

@@ -92,51 +92,56 @@ export declare namespace IFont {
      */
     type Charset = number;
     /**
-     * Specifies the style of underline applied to text.
+     * Indicate how and if a line will be drawing horizontally through the middle of the text.
      */
-    const UnderlineStyle: {
+    const StrikeStyle: {
         /**
-         * No underline.
+         * No strike-through
          */
         readonly None: "none";
         /**
-         * A double underline.
-         */
-        readonly Double: "double";
-        /**
-         * A double underline used in accounting contexts (typically thicker and below the descenders).
-         */
-        readonly DoubleAccounting: "doubleAccounting";
-        /**
-         * A single underline.
+         * A single line.
          */
         readonly Single: "single";
         /**
-         * A single underline used in accounting contexts (typically below the descenders).
+         * A double line.
          */
-        readonly SingleAccounting: "singleAccounting";
+        readonly Double: "double";
     };
-    type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
+    type StrikeStyle = typeof StrikeStyle[keyof typeof StrikeStyle];
     /**
-     * Vertical alignment of text within a line.
-     * @see
-     * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/vertical-align}
+     * How text is underlined.
+     *
+     * @remarks
+     * A cell draws `none`, `single`, `double` and the two accounting underlines; drawing text (charts,
+     * shapes) draws all but the accounting ones.
      */
-    const VerticalAlignment: {
-        /**
-         * Aligns the baseline of the cell with the baseline of all other cells in the row that are baseline-aligned.
-         */
-        readonly Baseline: "baseline";
-        /**
-         * Aligns the baseline of the element with the subscript-baseline of its parent.
-         */
-        readonly Sub: "sub";
-        /**
-         * Aligns the baseline of the element with the superscript-baseline of its parent.
-         */
-        readonly Super: "super";
+    const UnderlineStyle: {
+        readonly None: "none";
+        /** Each word underlined, the spaces between them not. */
+        readonly Words: "words";
+        readonly Single: "single";
+        readonly Double: "double";
+        /** A single line below the descenders, the width of the cell. */
+        readonly SingleAccounting: "singleAccounting";
+        /** A double line below the descenders, the width of the cell. */
+        readonly DoubleAccounting: "doubleAccounting";
+        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 VerticalAlignment = typeof VerticalAlignment[keyof typeof VerticalAlignment];
+    type UnderlineStyle = typeof UnderlineStyle[keyof typeof UnderlineStyle];
     /**
      * Advanced text metrics.
      */
@@ -145,6 +150,13 @@ export declare namespace IFont {
          * This is the lineHeight and includes the lineGap
          */
         readonly lineHeight: number;
+        /**
+         * The CSS `letter-spacing`, in the same px as `width`, that makes the platform paint the
+         * measured text exactly `width` wide: the difference between the measure (Excel's hinted
+         * widths) and what the platform paints with (a browser's fractional advances), spread between
+         * the characters. `0` where paint and measure agree, or where nothing paints (Node).
+         */
+        readonly renderLetterSpacing?: number;
     }
     interface Metrics {
         readonly underlinePosition?: number;
@@ -173,47 +185,165 @@ export declare namespace IFont {
         /** The font's descent below the baseline in whole px — GDI's `tmDescent` (OS/2 `winDescent`). */
         readonly descent: number;
     }
+    /**
+     * One face's measures, serving every size: what {@link IFontCollection.getByName} answers with.
+     *
+     * @remarks
+     * Advances are per em and vertical metrics follow GDI, so a table measures as Excel does: a
+     * shipped face measures GDI's hinted whole pixels and sizes rows as Excel autofits them. Tables
+     * are built by the collection from the shipped files or the platform; they are read here, never
+     * made or changed.
+     */
+    interface AdvanceTable {
+        /** The family the table measures, as a style names it. */
+        readonly family: string;
+        /** The CSS weight, 400 regular and 700 bold. */
+        readonly weight: number;
+        readonly italic: boolean;
+        /** Whether widths are GDI's hinted whole pixels. */
+        readonly isHinted: boolean;
+        /** Whether row heights are Excel's own captured ones. */
+        readonly hasRows: boolean;
+        /** The number of characters with an advance. */
+        readonly size: number;
+        /** The advance of `codepoint` per em, or `undefined` when the table has none. */
+        advance(codepoint: number): number | undefined;
+        /** The characters of `text` with no advance, each once, in first-seen order. */
+        missing(text: string): string[];
+        /**
+         * The advance width of `text` in px at `px` pixels per em: the advances summed, then the
+         * super/subscript scale, then `letterSpacing` between characters.
+         */
+        width(text: string, px: number, options?: AdvanceTable.WidthOptions): number;
+        /** The face's whole-px vertical metrics at `px` pixels per em. */
+        metrics(px: number): Metrics;
+        /**
+         * The underline at `px`: its center's offset above the baseline (negative below) and its
+         * thickness, in px; `null` when the source did not record one.
+         */
+        underline(px: number): AdvanceTable.LineRule | null;
+        /** The strikeout at `px`, as {@link underline}. */
+        strikeout(px: number): AdvanceTable.LineRule | null;
+        /**
+         * {@link width} and {@link metrics} together, with the underline and strikeout thickness in
+         * whole px as they are drawn (at least 1).
+         */
+        measure(text: string, px: number, options?: AdvanceTable.MeasureOptions): ExtendedMetrics;
+    }
+    namespace AdvanceTable {
+        /** Which face a table measures. */
+        interface Face {
+            family: string;
+            weight: number;
+            italic: boolean;
+        }
+        interface WidthOptions {
+            /** Px added between characters. */
+            letterSpacing?: number;
+            /** Measure as superscript or subscript text. */
+            superSub?: boolean;
+        }
+        interface MeasureOptions extends WidthOptions {
+            /**
+             * The table of what the platform paints this face with, when that is not this table (a
+             * browser's fractional advances against Excel's hinted widths): {@link AdvanceTable.measure}
+             * then reports the `renderLetterSpacing` that paints the text at the measured width.
+             */
+            paint?: AdvanceTable | null;
+        }
+        /** A horizontal rule (underline, strikeout): offset above the baseline and thickness. */
+        interface LineRule {
+            readonly position: number;
+            readonly thickness: number;
+        }
+    }
     interface MetricOptions {
         isBold?: boolean;
         isItalic?: boolean;
         letterSpacing?: number;
     }
-    interface Measurer {
-        (text: string, size: number, family: string, options?: IFont.MetricOptions): IFont.ExtendedMetrics;
-    }
     /**
-     * The contract a per-environment measurer module must satisfy. The active default is resolved
-     * via the `@sheetxl/sdk/font/FontMeasurer` conditional export:
-     * `browser` -> canvas, `node` -> fontkit, `default` -> simple (the zero-dependency char counter,
-     * the only universally-safe fallback - never pull a native/node-only measurer through `default`).
-     *
-     * Override the active measurer at runtime with {@link setSharedMeasurer} (e.g. force the simple
-     * measurer in unit tests), or at build time by aliasing the `@sheetxl/sdk/font/FontMeasurer`
-     * import in the bundler config.
+     * Returns scaling to use for the current device.
      */
-    interface MeasurerProvider {
-        /** The best measurer for the current environment (may itself fall back to the simple measurer). */
-        getInstance(): IFont.Measurer;
-        /** The device scale for the current environment. */
-        getDeviceScale(): number;
+    function getDeviceScale(): number;
+    /** A face's names and style, read from its own tables. */
+    interface FaceIdentity {
+        /** The family as Excel names it, which a style's font name is matched against ("Segoe UI Semibold"). */
+        readonly family: string;
+        /** The family as its designer groups it ("Segoe UI"); the same as {@link family} for most fonts. */
+        readonly typographicFamily: string;
+        /** The style within {@link family} ("Regular", "Bold Italic"). */
+        readonly subfamily: string;
+        /** The face's full name ("Segoe UI Semibold Italic"). */
+        readonly fullName: string;
+        /** The face's PostScript name ("SegoeUI-SemiboldItalic"). */
+        readonly postscriptName: string;
+        /** The weight class, 100 to 900. */
+        readonly weight: number;
+        /** Whether this is the bold member of {@link family}. A heavy weight alone is not bold. */
+        readonly bold: boolean;
+        readonly italic: boolean;
+        /** The font's version string. */
+        readonly version: string;
+    }
+    /** A face in a font file, as {@link CaptureOptions.filter} is asked about it. */
+    interface FaceToCapture extends FaceIdentity {
+        /**
+         * The name the face's tables are found by, without a suffix (`tahoma-bold`): its
+         * `.metrics.json` and `.hinted.json` go in a `fonts` resource root under this name.
+         */
+        readonly fileStem: string;
+    }
+    /** A face's measures tables, as captured by {@link captureTables}. */
+    interface CapturedFace extends FaceToCapture {
+        /** The `.metrics.json` text, to write as `<fileStem>.metrics.json`. */
+        readonly metrics: string;
+        /** The `.hinted.json` text, to write as `<fileStem>.hinted.json`; absent when hinting was not captured. */
+        readonly hinted?: string;
+    }
+    /** Options for {@link captureTables}. */
+    interface CaptureOptions {
+        /**
+         * The pixel sizes to capture hinted widths at, which are what make widths match Excel's, or
+         * `false` for none.
+         *
+         * @defaultValue `{ first: 6, last: 120 }`
+         */
+        hinting?: false | {
+            first: number;
+            last: number;
+        };
+        /** The font file's name, recorded in the tables so a copy kept beside them can be found again. */
+        sourceFile?: string;
+        /** Decides per face, before the costly part, whether to capture it. */
+        filter?(face: FaceToCapture): boolean;
+        /** Called as each face is captured: for progress, since a face takes about a second. */
+        onCaptured?(face: CapturedFace, index: number, count: number): void;
     }
     /**
-     * Override the default mechanism for measuring text.
+     * Reads a font file and captures the measures tables of each face in it: what SheetXL measures
+     * text with when the font itself is not at hand.
      *
-     * @param measurer {@link IFont.Measurer}
-     */
-    function setSharedMeasurer(measurer: IFont.Measurer): void;
-    /**
-     * Returns the {@link IFont.Measurer} used for measuring text.
+     * @remarks
+     * The tables are facts about the font's design (its advances and metrics), never its outlines,
+     * so they can go where the font itself cannot. Placed in a `fonts` resource root, they are found
+     * the next time a style names the family. This is what `sheetxl fonts add` does.
      *
-     * @see
-     * {@link setSharedMeasurer}
-     */
-    function getSharedMeasurer(): IFont.Measurer;
-    /**
-     * Returns scaling to use for the current device.
+     * Accepts `.ttf`, `.otf`, and the collections `.ttc` and `.otc`.
+     *
+     * @param bytes The font file.
+     * @returns One entry per face, in file order, less those {@link CaptureOptions.filter} declined.
+     * @throws when the bytes are not a font.
+     *
+     * @example
+     * ```ts
+     * for (const face of await IFont.captureTables(bytes)) {
+     *   await writeFile(`${face.fileStem}.metrics.json`, face.metrics);
+     *   if (face.hinted) await writeFile(`${face.fileStem}.hinted.json`, face.hinted);
+     * }
+     * ```
      */
-    function getDeviceScale(): number;
+    function captureTables(bytes: Uint8Array, options?: CaptureOptions): Promise<CapturedFace[]>;
     /**
      * Provides a font-family fallback based on the PANOSE hex string.
      *

package/types/src/font/IFontCollection.d.ts

@@ -1,7 +1,5 @@
 import { IListener } from '../listener';
 import { IFont } from './IFont';
-import { AdvanceBuilder } from './AdvanceBuilder';
-import { AdvanceTable } from './AdvanceTable';
 /**
  * The fonts text is measured with: one table per family, weight and style, shared by every
  * workbook, the way a browser's `document.fonts` is shared by a page.
@@ -16,7 +14,8 @@ export interface IFontCollection extends IListener.ISource<IFontCollection, IFon
     /**
      * The table to measure a face with, now.
      *
-     * @param family The family as a style names it, or a CSS generic name (`sans-serif`).
+     * @param family The family as a style names it, a CSS generic name (`sans-serif`), or a CSS
+     * `font-family` list (`"Aptos Narrow", Calibri, sans-serif`).
      * @param options {@link IFontCollection.GetByNameOptions}
      *
      * @remarks
@@ -35,15 +34,6 @@ export interface IFontCollection extends IListener.ISource<IFontCollection, IFon
     whenReady(): Promise<void>;
     /** Whether a face is loading. */
     isLoading(): boolean;
-    /**
-     * Replaces where tables come from, tried in order, and forgets every table built before; the
-     * built-in Calibri and Arial stay.
-     *
-     * @remarks
-     * For hosts that capture or ship their own tables, and for tests that pin measurement to the
-     * shipped tables.
-     */
-    setAdvanceBuilders(builders: readonly AdvanceBuilder[]): void;
     /** The families offered for choosing, as a font picker lists them. */
     getFontList(): readonly IFontCollection.FontHandle[];
     /** Replaces the families offered for choosing; `null` restores the default list. */
@@ -87,17 +77,29 @@ export declare namespace IFontCollection {
     /** The table a face is measured with, and how good an answer it is. */
     interface Resolution {
         /** Measures and wraps text in the face. */
-        readonly table: AdvanceTable;
+        readonly table: IFont.AdvanceTable;
         readonly kind: ResolutionKind;
         readonly status: FontStatus;
         /** The face that was asked for. */
-        readonly requested: AdvanceTable.Face;
+        readonly requested: IFont.AdvanceTable.Face;
+        /**
+         * What the platform paints the face with when that is not `table` (a browser's own advances
+         * for the family and its fallbacks, substitutes included), for
+         * `IFont.ExtendedMetrics.renderLetterSpacing`. Absent where paint is the measure, where nothing
+         * paints (Node), and while it loads (`status` is then `'loading'`).
+         */
+        readonly paint?: IFont.AdvanceTable;
     }
     interface GetByNameOptions {
         /** Defaults to `false`. */
         bold?: boolean;
         /** Defaults to `false`. */
         italic?: boolean;
+        /**
+         * Families to measure with, in order, when the family has no table of its own, as a style's
+         * font fallbacks list them. A CSS `font-family` list in `family` reads the same way.
+         */
+        fallbacks?: readonly string[];
     }
     /** A face to {@link IFontCollection.load | load}. */
     interface FaceRequest extends GetByNameOptions {
@@ -106,6 +108,10 @@ export declare namespace IFontCollection {
     interface FontHandle {
         /** `null` is used as a cached 'no match' sentinel (see {@link IFontCollection.findBestMatch}). */
         fontRef: IFont.IFontFace | null;
+        /**
+         * Whether the platform has the family installed, so paints it as itself; a font menu can show
+         * a missing one differently. `true` where the platform cannot tell (Node, which paints nothing).
+         */
         loaded: boolean;
     }
     interface FindBestMatchOptions {

package/types/src/font/IFontStyle.d.ts

@@ -0,0 +1,207 @@
+import { Properties as CSSProperties } from 'csstype';
+import { IColor } from '../color';
+import { ITransaction } from '../transaction';
+import { IFont } from './IFont';
+/**
+ * How text is drawn: its typeface, size, weight, slant, lines, color, spacing and baseline.
+ *
+ * @remarks
+ * A cell's font (`range.getStyle().getFont()`) and the text of a chart part
+ * (`title.getStyle().getFont()` on a title, legend, axis or data labels) are both text styles, so
+ * the same code formats either.
+ *
+ * What a style does not state it takes from the text around it: a cell's from the Normal style, a
+ * chart title's from the chart, the chart's from the theme. Reads answer what is drawn, stated or
+ * not.
+ *
+ * Setters return the text style to keep chaining on. A cell's font is a snapshot of the cell, so
+ * its setters return the updated font rather than the one they were called on.
+ *
+ * @example
+ * ```ts
+ * range.getStyle().getFont().setBold(true).setColor('accent2');
+ * chart.getTitle().getStyle().getFont().update({ size: 18, family: IFontStyle.ThemeFamily.Heading });
+ * ```
+ */
+export interface IFontStyle {
+    /**
+     * Returns the typeface drawn: the one stated, or the theme's font when the style names
+     * {@link IFontStyle.ThemeFamily | a theme font} or none.
+     */
+    getFamily(): string;
+    /**
+     * Sets the typeface: a family name, or a {@link IFontStyle.ThemeFamily} to follow the theme's
+     * heading or body font. `null` clears it.
+     */
+    setFamily(family: string | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /**
+     * Exists to have api parity with Office Scripts.
+     *
+     * @deprecated Use {@link getFamily}.
+     * @hidden
+     */
+    getName(): string;
+    /**
+     * Exists to have api parity with Office Scripts.
+     *
+     * @deprecated Use {@link setFamily}.
+     * @hidden
+     */
+    setName(name: string | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /**
+     * Returns the theme font the style follows, or `null` when it names its own family.
+     */
+    getThemeFamily(): IFontStyle.ThemeFamily | null;
+    /**
+     * Returns the families drawn when {@link IFontStyle.getFamily} cannot draw a character, in order.
+     */
+    getFallbacks(): string[];
+    /** @see {@link IFontStyle.getFallbacks} */
+    setFallbacks(fallbacks: string[] | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns the size in points. */
+    getSize(): number;
+    /** Sets the size in points. */
+    setSize(size: number | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns the weight, `400` being regular and `700` bold. */
+    getWeight(): number;
+    /** @see {@link IFontStyle.getWeight} */
+    setWeight(weight: number | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns whether the text is bold: a weight above `400`. */
+    getBold(): boolean;
+    /** Sets the weight to bold (`700`) or regular (`400`). */
+    setBold(bold: boolean | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns whether the text is italic. */
+    getItalic(): boolean;
+    /** @see {@link IFontStyle.getItalic} */
+    setItalic(italic: boolean | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns how the text is underlined; `'none'` when it is not. */
+    getUnderline(): IFont.UnderlineStyle;
+    /** Sets how the text is underlined; `'none'` removes the underline. */
+    setUnderline(underline: IFont.UnderlineStyle | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns how the text is struck through; `'none'` when it is not. */
+    getStrike(): IFont.StrikeStyle;
+    /** Sets how the text is struck through; `'none'` removes the line. */
+    setStrike(strike: IFont.StrikeStyle | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns the text color. */
+    getColor(): IColor;
+    /** Sets the color: an {@link IColor}, `#FF0000`, `rgb(…)`, or a theme color such as `accent1`. */
+    setColor(color: IColor | string | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Returns the space added between characters, in points; `0` for none, negative to condense. */
+    getLetterSpacing(): number;
+    /** @see {@link IFontStyle.getLetterSpacing} */
+    setLetterSpacing(spacing: number | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /**
+     * Returns how far the text is raised, as a percentage of its size: positive for superscript,
+     * negative for subscript, `0` on the baseline.
+     */
+    getBaseline(): number;
+    /** Raises or lowers the text by a percentage of its size; `0` puts it back on the baseline. */
+    setBaseline(baseline: number | null, options?: ITransaction.OperationOptions): IFontStyle;
+    /** Sets several properties at once, as one step to undo. */
+    update(update: IFontStyle.Update, options?: ITransaction.OperationOptions): IFontStyle;
+    /**
+     * Returns `true` when `other` measures text the same, so a measured width can be reused.
+     */
+    isEqualMeasure(other: IFontStyle): boolean;
+    /**
+     * Returns the style as CSS properties.
+     *
+     * @param mode How colors are written.
+     * @param zoom Scales the font size.
+     * @param ignoreNormal Leaves out what equals the Normal style's font, where there is one.
+     */
+    toCSS(mode?: IColor.CSSMode, zoom?: number, ignoreNormal?: boolean): CSSProperties;
+    /** Serializes to a JSON object. */
+    toJSON(): IFontStyle.JSON;
+    /** For runtime type checking. */
+    readonly isIFontStyle: true;
+}
+/**
+ * {@inheritDoc IFontStyle}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IFontStyle}
+ */
+export declare namespace IFontStyle {
+    /**
+     * A family that follows the theme: its heading font or its body font.
+     */
+    const ThemeFamily: {
+        readonly Heading: "theme:heading";
+        readonly Body: "theme:body";
+    };
+    type ThemeFamily = typeof ThemeFamily[keyof typeof ThemeFamily];
+    /**
+     * The {@link IFontStyle.getBaseline | baselines} superscript and subscript text take by default.
+     */
+    const Baseline: {
+        readonly Superscript: 30;
+        readonly Subscript: -25;
+    };
+    /**
+     * The stored shape of a text style.
+     *
+     * @remarks
+     * One spelling per concept: bold is a {@link Properties.weight | weight}, italic a
+     * {@link Properties.style | style}, a theme font a {@link ThemeFamily} in `family`. Updates
+     * accept the more forgiving {@link Update}, which is normalized to this before it is stored.
+     */
+    interface Properties<C = IColor.Serializable> {
+        /** A family name, or a {@link ThemeFamily}. */
+        family?: string;
+        /** {@inheritDoc IFontStyle.getFallbacks} */
+        fallbacks?: string[];
+        /** {@inheritDoc IFontStyle.getSize} */
+        size?: number;
+        /** {@inheritDoc IFontStyle.getWeight} */
+        weight?: number;
+        /** `italic` or `normal`. */
+        style?: IFont.Style;
+        /** {@inheritDoc IFontStyle.getColor} */
+        color?: C;
+        /** {@inheritDoc IFontStyle.getLetterSpacing} */
+        letterSpacing?: number;
+        /** {@inheritDoc IFontStyle.getUnderline} */
+        underline?: IFont.UnderlineStyle;
+        /** {@inheritDoc IFontStyle.getStrike} */
+        strike?: IFont.StrikeStyle;
+        /** {@inheritDoc IFontStyle.getBaseline} */
+        baseline?: number;
+        /**
+         * The character set the font was authored against, a font-substitution hint.
+         *
+         * @remarks
+         * An **opaque passthrough**. The model carries the value so it survives a round trip and never
+         * interprets it.
+         */
+        charset?: number;
+        /**
+         * @remarks
+         * An **opaque passthrough**, not drawn. The model carries the value so it survives a round
+         * trip.
+         */
+        shadow?: boolean;
+        /** {@inheritDoc IFontStyle.Properties.shadow} */
+        outline?: boolean;
+    }
+    /**
+     * What {@link IFontStyle.update} and a cell style's `font` accept: {@link Properties} with
+     * shorthands. `null` clears a property.
+     */
+    type Update<C = IColor.Serializable | IColor> = {
+        [K in keyof Omit<Properties<C>, 'weight' | 'underline'>]?: Properties<C>[K] | null;
+    } & {
+        /** A number (`400`, `700`) or a CSS keyword (`'bold'`). */
+        weight?: number | string | null;
+        /** `true` for `'single'`, `false` for `'none'`. */
+        underline?: IFont.UnderlineStyle | boolean | null;
+        /** Sets the weight to `700` or `400`. Ignored when `weight` is also given. */
+        bold?: boolean | null;
+        /** Sets the style to `italic` or `normal`. Ignored when `style` is also given. */
+        italic?: boolean | null;
+    };
+    interface JSON extends Properties<string> {
+    }
+}
+//# sourceMappingURL=IFontStyle.d.ts.map

package/types/src/font/TableFileAdvanceBuilder.d.ts

@@ -22,6 +22,15 @@ export declare class TableFileAdvanceBuilder implements AdvanceBuilder {
      */
     constructor(base?: string | null);
     build(face: AdvanceTable.Face): Promise<AdvanceTable | null>;
+    /**
+     * Gives `table` the hinted widths of its `.hinted.json` companion and Excel's row heights from
+     * its `.rows.json`, those it has.
+     *
+     * @returns Whether the table is hinted now.
+     */
+    hint(table: AdvanceTable): Promise<boolean>;
+    /** A companion file of a face, or `null` when there is none. */
+    private _companion;
     private _load;
 }
 //# sourceMappingURL=TableFileAdvanceBuilder.d.ts.map

package/types/src/font/_FontUtils.d.ts

@@ -1,9 +1,16 @@
-import { IFont } from './IFont';
 export declare const DefaultMinFontSize: number;
 export declare const DefaultMaxFontSize: number;
 export declare const DefaultMaxFontPrecision: number;
 export declare const DefaultLineHeightMultiplier: number;
-export declare function defaultHorizontalPadding(fontSize: number): number;
+/**
+ * Excel's horizontal padding a side for a cell whose font's widest digit is `digitWidth` px: a
+ * quarter of that digit, rounded up (2 px at Calibri 11, 17 at Calibri 100, 56 at Arial 300).
+ * Exact against Excel's own autofit over 130 cells, Calibri and Arial, 8 to 48 pt
+ * (`private-assets/design/rust/tools/sweep-excel-autofit.ps1`), and against the column at which
+ * Excel stops showing a number as `#` from 20 to 300 pt (`tools/oracle-excel-overflow.ps1`:
+ * content + 2 x this + 1 every time).
+ */
+export declare function defaultHorizontalPadding(digitWidth: number): number;
 export declare function defaultVerticalPadding(_fontSize: number): number;
 /**
  * The size to scale a font for super/sub text.
@@ -11,12 +18,12 @@ export declare function defaultVerticalPadding(_fontSize: number): number;
  * **NOT IMPLEMENTED** This should read from the font but is currently hardcoded to `0.6`.
  * * This will be moved to 'Measurer'
  */
-export declare function superSubScale(_fontFamily: string, _fontSize?: number, _verticalAlign?: IFont.VerticalAlignment): number;
+export declare function superSubScale(_fontFamily: string, _fontSize?: number, _baseline?: number): number;
 /**
  * The distance in pixels to shift a font for super/sub text.
  * @remarks
  * **NOT IMPLEMENTED** This should read from the font but is currently hardcoded to `+1/5 -1/5`.
  * * This will be moved to 'Measurer'
  */
-export declare function superSubShift(fontFamily: string, fontSize?: number, verticalAlign?: IFont.VerticalAlignment): number;
+export declare function superSubShift(fontFamily: string, fontSize?: number, baseline?: number): number;
 //# sourceMappingURL=_FontUtils.d.ts.map

package/types/src/font/_FontsVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A number that changes whenever the shared {@link IFontCollection} does (a table or its hinted
+ * widths arrived): part of the key of any cache of measurements, so a cached measure taken before a
+ * font loaded is not served after. Listens from its first call on.
+ */
+export declare function fontsVersion(): number;
+//# sourceMappingURL=_FontsVersion.d.ts.map

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

@@ -1,8 +1,6 @@
 export * from './IFontCollection';
 export * from './IFont';
+export * from './IFontStyle';
 export * from './Font';
-export * from './AdvanceTable';
-export { type AdvanceBuilder } from './AdvanceBuilder';
-export { TableFileAdvanceBuilder } from './TableFileAdvanceBuilder';
 export * as FontUtils from './FontUtils';
 //# sourceMappingURL=index.d.ts.map

package/types/src/font/platform.browser.d.ts

@@ -0,0 +1,15 @@
+import { AdvanceBuilder } from './AdvanceBuilder';
+/**
+ * The browser's builders: a canvas, for installed families we have no captured table for. Known
+ * families never reach it; the shipped tables and the built-ins answer first.
+ */
+export declare function getAdvanceBuilders(): AdvanceBuilder[];
+/**
+ * Returns scaling to use for the current device.
+ *
+ * @remarks
+ * **TODO** This is hardcoded to Non-HD DPI. Revisit: `window.devicePixelRatio`, with a listener
+ * for the `(resolution: ...dppx)` media query so a window moving between screens is noticed.
+ */
+export declare function getDeviceScale(): number;
+//# sourceMappingURL=platform.browser.d.ts.map