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

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

@@ -1,5 +1,5 @@
 import { IMovable } from '../movable/IMovable';
-import { ISheet } from '../sheet/ISheet';
+import { IWorksheet } from '../sheet/IWorksheet';
 import { IShape } from './IShape';
 import { Direction, Route } from './_ConnectorRoute';
 export { connectorEndPoints, placeConnector, placePoint, unplacePoint } from './_ConnectorFrame';
@@ -44,12 +44,12 @@ export declare const connectorEndsOf: (movable: IMovable) => IShape.ConnectorEnd
  */
 export declare const mayHoldConnector: (movable: IMovable) => boolean;
 /** The movable a connector's end names, or `null` when none on the sheet has that id. */
-export declare const findBySourceId: (sheet: ISheet, id: number) => IMovable | null;
+export declare const findBySourceId: (sheet: IWorksheet, id: number) => IMovable | null;
 /**
  * An id no movable on the sheet has: what a target takes when a connector first glues to it, so
  * the file writes the target with it and the connector's end names it. A file's ids start at 2.
  */
-export declare const nextSourceId: (sheet: ISheet) => number;
+export declare const nextSourceId: (sheet: IWorksheet) => number;
 /** Where a movable is and, while a gesture moves its handles, the adjust values its shape takes. */
 export type PlacementPreview = IMovable.PlacementPreview;
 /** Where each movable is, for the glue: the model's placement unless the caller says otherwise. */
@@ -75,21 +75,21 @@ export interface GluedRoute {
  * free end where it is: a bent or curved connector is routed to it, the free end facing back
  * toward the glued one.
  */
-export declare const gluedRoute: (sheet: ISheet, connector: IMovable, placements: PlacementResolver, onReady: () => void, resolve?: (id: number) => IMovable | null, translated?: boolean) => GluedRoute | null;
+export declare const gluedRoute: (sheet: IWorksheet, connector: IMovable, placements: PlacementResolver, onReady: () => void, resolve?: (id: number) => IMovable | null, translated?: boolean) => GluedRoute | null;
 /** The placement a connector takes with each glued end on its target's site; see {@link gluedRoute}. */
-export declare const gluedPlacement: (sheet: ISheet, connector: IMovable, placements: PlacementResolver, onReady: () => void, resolve?: (id: number) => IMovable | null) => IMovable.Placement | null;
+export declare const gluedPlacement: (sheet: IWorksheet, connector: IMovable, placements: PlacementResolver, onReady: () => void, resolve?: (id: number) => IMovable | null) => IMovable.Placement | null;
 /**
  * Every connector on the sheet with a glued end off its site, and the placement that puts it back;
  * read only, so a caller writes nothing when nothing moved.
  */
-export declare const strayConnectors: (sheet: ISheet, onReady: () => void) => [IMovable, GluedRoute][];
+export declare const strayConnectors: (sheet: IWorksheet, onReady: () => void) => [IMovable, GluedRoute][];
 /**
  * Writes where a connector goes onto it, touching only what differs: the turn first, which keeps
  * the frame where it is, then the frame, the flips, and the route's preset and adjust values.
  */
 export declare const applyPlacement: (connector: IMovable, next: GluedRoute) => void;
 /** The connectors on the sheet with an end glued to any of `targets`. */
-export declare const gluedConnectors: (sheet: ISheet, targets: ReadonlyMap<number, IMovable>) => IMovable[];
+export declare const gluedConnectors: (sheet: IWorksheet, targets: ReadonlyMap<number, IMovable>) => IMovable[];
 /** `movables` and every movable inside them, by the id a connector names each by. */
 export declare const targetsById: (movables: readonly IMovable[]) => Map<number, IMovable>;
 /**
@@ -99,10 +99,10 @@ export declare const targetsById: (movables: readonly IMovable[]) => Map<number,
  * @param onReady Called when a target's sites were not evaluated yet and are now: the caller runs
  * the glue again, folded into the commit it belongs to.
  */
-export declare const glueConnectorsTo: (sheet: ISheet, changed: IMovable, onReady: () => void, translated?: boolean) => void;
+export declare const glueConnectorsTo: (sheet: IWorksheet, changed: IMovable, onReady: () => void, translated?: boolean) => void;
 /**
  * Places one connector on its targets' sites, as part of the open operation: what gluing an end
  * does once the end is recorded.
  */
-export declare const glueConnector: (sheet: ISheet, connector: IMovable, onReady: () => void) => void;
+export declare const glueConnector: (sheet: IWorksheet, connector: IMovable, onReady: () => void) => void;
 //# sourceMappingURL=_Connectors.d.ts.map

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

@@ -7,6 +7,7 @@ import { IMovable } from '../movable/IMovable';
 import { AnyFill } from '../fill/_Fills';
 import { IShape } from './IShape';
 import { IShapeStyle } from './IShapeStyle';
+import * as ShapeStyleUtils from './ShapeStyleUtils';
 /**
  * What a shape's style reads and writes through: the shape's own JSON, the workbook it resolves
  * colors and theme styles against, and the write that states a fill or line on the shape.
@@ -22,6 +23,13 @@ export interface ShapeStyleHost {
      * a key left out is untouched.
      */
     write(patch: Partial<Pick<IShape.JSON, 'fill' | 'stroke'>>, options: ITransaction.OperationOptions): void;
+    /**
+     * What the style resolves to over `data`, where it is not a shape's: a chart element's own
+     * default fill and line take the place of a theme style's. A shape's resolves through its theme.
+     */
+    resolve?(data: IShape.JSON | null): Pick<ShapeStyleUtils.ResolvedShapeStyle, 'fill' | 'stroke'>;
+    /** The undo message of a write, where it is not a shape's. */
+    describe?(key: 'fill' | 'stroke' | 'style' | 'clear'): string;
 }
 /**
  * {@link IShapeStyle} for a shape: every read resolves from the shape's current JSON, and every
@@ -32,6 +40,7 @@ export declare class ShapeStyle implements IShapeStyle {
     constructor(_h: ShapeStyleHost);
     private _parseColor;
     private _resolve;
+    private _describe;
     /** The shape's JSON with one of its stated values left out: what the theme style alone gives. */
     private _without;
     private _fillHost;

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

@@ -1,5 +1,6 @@
 export * from './IShape';
 export * from './IShapeStyle';
+export * from './ITextBoxStyle';
 export * as ShapeStyleUtils from './ShapeStyleUtils';
 export * from './IGeometry';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,7 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegion, ICellRegions } from '../cellRange';
-import { ISheetInternal } from './Sheet';
+import { IWorksheetInternal } from './Worksheet';
 /**
  * Normalizes the requested features, ONCE, at the call.
  *
@@ -38,7 +38,9 @@ export declare class CellRegion implements ICellRegion {
     private _range;
     /** Memoized clip verdict: the probes are sheet reads, and a listing may ask twice. */
     private _clipped;
-    constructor(coords: Readonly<IRange.Coords>, internal: ISheetInternal, features: readonly ICellRange.Feature[], bounds: Readonly<IRange.Coords>);
+    /** Whether the address names its sheet: a listing across sheets. */
+    private readonly _qualified;
+    constructor(coords: Readonly<IRange.Coords>, internal: IWorksheetInternal, features: readonly ICellRange.Feature[], bounds: Readonly<IRange.Coords>, qualified?: boolean);
     /** {@inheritDoc ICellRegion.getFeatures} */
     getFeatures(): readonly ICellRange.Feature[];
     /** {@inheritDoc ICellRegion.getCoords} */
@@ -91,7 +93,7 @@ export declare class CellRegions implements ICellRegions {
     private _regions;
     /** The extent as a range, built on demand — a listing that never asks never pays. */
     private _range;
-    constructor(bounds: Readonly<IRange.Coords>, internal: ISheetInternal, features: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions);
+    constructor(bounds: Readonly<IRange.Coords>, internal: IWorksheetInternal, features: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions);
     /** {@inheritDoc ICellRegions.getFeatures} */
     getFeatures(): readonly ICellRange.Feature[];
     /** {@inheritDoc ICellRegions.getRange} */
@@ -109,4 +111,36 @@ export declare class CellRegions implements ICellRegions {
     /** {@inheritDoc ICellRegions.isICellRegions} */
     get isICellRegions(): true;
 }
+/** One sheet's part of an anomalies listing. @internal */
+export interface AnomalyExtent {
+    readonly bounds: Readonly<IRange.Coords>;
+    readonly internal: IWorksheetInternal;
+    /** Whether the addresses name the sheet: a listing across sheets. */
+    readonly qualified: boolean;
+}
+/** Validated eagerly, so a misspelled check throws at the call rather than at first iteration. */
+export declare const resolveAnomalyOptions: (options?: ICellRange.GetAnomaliesOptions) => Readonly<ICellRange.GetAnomaliesOptions>;
+/**
+ * The regions of the `anomalies` feature in reading order, windowed — what `getAnomalies`
+ * returns. The same regions and ranks as `getRegions('anomalies')`; lazily built and memoized.
+ */
+export declare class AnomalyRegions implements ICellRegions {
+    private readonly _extents;
+    private readonly _range;
+    private readonly _options;
+    private _listed;
+    constructor(extents: readonly AnomalyExtent[], range: () => ICellRange, options: Readonly<ICellRange.GetAnomaliesOptions>);
+    /** {@inheritDoc ICellRegions.getFeatures} */
+    getFeatures(): readonly ICellRange.Feature[];
+    /** {@inheritDoc ICellRegions.getRange} */
+    getRange(): ICellRange;
+    /** {@inheritDoc ICellRegions.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ICellRegions.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<ICellRegion>;
+    private _materialize;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc ICellRegions.isICellRegions} */
+    get isICellRegions(): true;
+}
 //# sourceMappingURL=CellRegion.d.ts.map

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

@@ -0,0 +1,46 @@
+import { IEmbeddedPart } from '../io/IEmbeddedPart';
+import { ISheet } from './ISheet';
+/**
+ * A sheet whose content is carried but not modeled: a chart sheet, an Excel 4.0 macro sheet or an
+ * Excel 5 dialog sheet.
+ *
+ * @remarks
+ * It is a tab like any other: it can be renamed, moved, hidden, colored, selected and deleted, and it
+ * counts in `SHEETS()`, `SHEET()` and 3-D references. What it holds is kept as it was read and written
+ * back unchanged. It has no cells, so a reference to one (`Chart1!A1`) is `#REF!`; for a macro sheet
+ * that differs from Excel, which reads its cells.
+ *
+ * Renames and moves are not followed inside it: a chart's series formulas and a macro sheet's
+ * formulas keep the names they were written with.
+ */
+export interface IOpaqueSheet extends ISheet {
+    /** {@inheritDoc ISheet.getKind} */
+    getKind(): IOpaqueSheet.Kind;
+    /**
+     * For runtime type checking.
+     */
+    readonly isIOpaqueSheet: true;
+}
+/**
+ * {@inheritDoc IOpaqueSheet}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IOpaqueSheet}
+ */
+export declare namespace IOpaqueSheet {
+    /**
+     * The kinds of sheet that are carried rather than modeled.
+     */
+    type Kind = Exclude<ISheet.Kind, 'worksheet'>;
+    /**
+     * JSON representation of an {@link IOpaqueSheet}.
+     */
+    interface JSON extends ISheet.JSON {
+        /**
+         * The sheet's part, with every part its markup references.
+         */
+        part: IEmbeddedPart.JSON;
+    }
+}
+//# sourceMappingURL=IOpaqueSheet.d.ts.map