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

package/types/src/slicer/ISlicer.d.ts

@@ -1,38 +1,325 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
+import { IListener } from '../listener';
 import { IModel } from '../model';
+import { IMovable, IMovableCollection } from '../movable';
+import { ITable } from '../table';
+import { IWorksheet } from '../sheet';
 /**
- * ISplicer
+ * A slicer: buttons that filter one column of a table.
  *
  * @remarks
- * Not fully implemented.
+ * A slicer holds no selection of its own. What it shows as selected is the column's filter
+ * ({@link ITable.IColumn.getFilter}), so a filter set from the column's menu shows on the slicer,
+ * and a selection made on the slicer is the column's filter, saved with the table. Two slicers on
+ * one column always agree.
  *
- * @hidden
- * @internal
+ * The column is named by a structured reference ({@link getSource}), which follows the table and
+ * the column through a rename. When the column or its table is deleted, the slicer is deleted with
+ * it, in the same step; an undo brings both back.
+ *
+ * Where a slicer sits is its movable's ({@link IMovable.getBounds}); it moves freely of the cells
+ * under it by default.
+ *
+ * @example
+ * ```ts
+ * const table = sheet.getTables().getByName('Sales');
+ * const slicer = await table.addSlicer('Region');
+ * await slicer.selectItems(['East', 'West']);
+ * ```
  */
-export interface ISlicer extends IModel {
+export interface ISlicer extends IModel, IMovable.IContent {
+    /**
+     * Returns the column the slicer filters, as a structured reference: `Sales[Region]`.
+     *
+     * @remarks
+     * Follows a rename of the table or the column.
+     */
+    getSource(): string;
+    /**
+     * Returns the table the slicer filters, or `null` if it names none.
+     */
+    getTable(): ITable | null;
+    /**
+     * Returns the column the slicer filters, or `null` if it names none.
+     */
+    getColumn(): ITable.IColumn | null;
+    /**
+     * Returns the text shown in the slicer's header.
+     *
+     * @remarks
+     * The column's name unless a caption has been set, and then it follows a rename of the column.
+     */
+    getCaption(): string;
+    /**
+     * Sets the text shown in the slicer's header.
+     *
+     * @param caption The caption, or `null` to show the column's name.
+     */
+    setCaption(caption: string | null, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns whether the header is shown.
+     */
+    isShowCaption(): boolean;
+    /**
+     * Sets whether the header is shown.
+     */
+    setShowCaption(show: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the name a formula refers to the slicer's selection by: `Slicer_Region`.
+     *
+     * @remarks
+     * Made from the column's name when the slicer is created, and kept through a rename of the
+     * column, as Excel keeps it.
+     */
+    getCacheName(): string;
+    /**
+     * Returns the name of the slicer style.
+     *
+     * @defaultValue `'SlicerStyleLight1'`
+     */
+    getStyle(): string;
+    /**
+     * Sets the slicer style by name.
+     */
+    setStyle(style: string, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the order the items are listed in.
+     */
+    getSortOrder(): ISlicer.SortOrder;
+    /**
+     * Sets the order the items are listed in.
+     */
+    setSortOrder(sortOrder: ISlicer.SortOrder, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns how items without data are shown: those whose rows the other columns' filters hide.
+     */
+    getCrossFilter(): ISlicer.CrossFilter;
+    /**
+     * Sets how items without data are shown.
+     */
+    setCrossFilter(crossFilter: ISlicer.CrossFilter, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the number of columns the items are laid out in.
+     */
+    getColumnCount(): number;
+    /**
+     * Sets the number of columns the items are laid out in, at least 1.
+     */
+    setColumnCount(count: number, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns the height of each item's button, in pixels.
+     */
+    getRowHeight(): number;
+    /**
+     * Sets the height of each item's button, in pixels.
+     */
+    setRowHeight(height: number, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns whether the slicer is marked as not to be moved or resized.
+     */
+    isLockedPosition(): boolean;
+    /**
+     * Sets whether the slicer is marked as not to be moved or resized.
+     */
+    setLockedPosition(locked: boolean, options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns `true` when the column has no filter: every item is selected.
+     */
+    isFilterCleared(): boolean;
+    /**
+     * Returns the items: the column's distinct values as it shows them, in the slicer's order.
+     *
+     * @remarks
+     * Every row of the column is read, hidden or not. An item has data when at least one row
+     * holding it passes the other columns' filters. Blanks are one item, keyed `''`, listed last.
+     */
+    getItems(): Promise<readonly ISlicer.Item[]>;
+    /**
+     * Returns the item with `key`, or `null`.
+     */
+    getItem(key: string): Promise<ISlicer.Item | null>;
+    /**
+     * Selects the items with `keys` and no others, by filtering the column.
+     *
+     * @param keys The items' keys. `null`, an empty list or every item clears the filter.
+     *
+     * @remarks
+     * The other columns' filters stay. On a date column the selection is saved as the dates
+     * themselves, not their text.
+     */
+    selectItems(keys: readonly string[] | null, options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * Clears the column's filter, selecting every item.
+     */
+    clearFilters(options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * Deletes the slicer, and with it the movable that places it.
+     */
+    delete(options?: ITransaction.OperationOptions): void;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: ISlicer.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * @returns The current state as JSON, or `null` once deleted.
+     */
     toJSON(toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
-    getDescription(): string;
+    /** For runtime type checking. */
+    readonly isISlicer: true;
 }
+/**
+ * {@inheritDoc ISlicer}
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link ISlicer}
+ */
 export declare namespace ISlicer {
+    /**
+     * The order items are listed in.
+     *
+     * - `'ascending'` / `'descending'`: by value, as the column sorts.
+     * - `'dataSource'`: in the order the values first appear in the column.
+     */
+    type SortOrder = 'ascending' | 'descending' | 'dataSource';
+    /**
+     * How items without data are shown.
+     *
+     * - `'showItemsWithDataAtTop'`: after the items with data.
+     * - `'showItemsWithNoData'`: in their place in the order.
+     * - `'none'`: not at all.
+     */
+    type CrossFilter = 'showItemsWithDataAtTop' | 'showItemsWithNoData' | 'none';
+    /**
+     * One button of a slicer.
+     */
+    interface Item {
+        /**
+         * The item's identity: the text the column shows for it, `''` for the blank item. What
+         * {@link ISlicer.selectItems} takes.
+         */
+        key: string;
+        /** The text shown on the button. */
+        name: string;
+        /** The value of the first cell showing the item; `null` for the blank item. */
+        value: Scalar;
+        /** Whether at least one row holding the item passes the other columns' filters. */
+        hasData: boolean;
+        /** Whether the column's filter selects the item. */
+        isSelected: boolean;
+    }
+    /**
+     * Options for {@link ITable.addSlicer}.
+     */
+    interface AddOptions extends IMovableCollection.AddOptions<ISlicer.JSON> {
+        /**
+         * The sheet the slicer is placed on.
+         *
+         * @defaultValue The table's sheet.
+         */
+        sheet?: IWorksheet;
+        /** {@inheritDoc ISlicer.JSON.caption} */
+        caption?: string;
+        /**
+         * The slicer style's name.
+         *
+         * @defaultValue The workbook's default slicer style, {@link ISlicerStyleCollection.getDefault}.
+         */
+        style?: string;
+        /** {@inheritDoc ISlicer.JSON.columnCount} */
+        columnCount?: number;
+    }
+    /**
+     * Events a slicer announces.
+     */
+    interface Events extends IMovable.ContentEvents {
+        /**
+         * Called when the column's filter changes, by this slicer or anything else.
+         */
+        onSelectionChange?(source: ISlicer): void;
+        /**
+         * Called when the column's values change, so the items may have.
+         */
+        onItemsChange?(source: ISlicer): void;
+    }
+    interface IListeners extends IListener.Callbacks<ISlicer, ISlicer.Events> {
+    }
     /**
      * JSON representation of a slicer.
      */
     interface JSON {
-        tableId: string;
-        columnId: string;
+        /**
+         * The column, as a structured reference: `Sales[Region]`.
+         */
+        source: string;
+        /**
+         * The header text. Absent, the column's name.
+         */
         caption?: string;
+        /**
+         * Whether the header is hidden.
+         */
+        hiddenCaption?: boolean;
+        /**
+         * @defaultValue 1
+         */
         columnCount?: number;
+        /**
+         * Each item's height in pixels.
+         *
+         * @defaultValue 27
+         */
+        rowHeight?: number;
+        /**
+         * @defaultValue `'SlicerStyleLight1'`
+         */
+        style?: string;
+        /**
+         * @defaultValue `'ascending'`
+         */
+        sortOrder?: ISlicer.SortOrder;
+        /**
+         * @defaultValue `'showItemsWithDataAtTop'`
+         */
+        crossFilter?: ISlicer.CrossFilter;
+        /**
+         * Whether the slicer is marked as not to be moved or resized.
+         */
+        lockedPosition?: boolean;
+        /**
+         * Whether a custom list is ignored when sorting the items.
+         */
+        disabledCustomListSort?: boolean;
+        /**
+         * The name formulas refer to the selection by, as the file had it. Absent, made from the
+         * column's name.
+         */
+        cacheName?: string;
+        /**
+         * The index of the first item showing: where the list was scrolled to when saved.
+         *
+         * @remarks
+         * Restored when the slicer is first drawn. Scrolling the slicer does not change it.
+         */
         startItem?: number;
-        showCaption?: boolean;
+        /**
+         * The level of a hierarchy shown, for a slicer read from a file.
+         */
         level?: number;
-        locked?: boolean;
-        displayHeader?: boolean;
-        sortDescending?: boolean;
-        useCustomLists?: boolean;
-        hideNoDataItems?: boolean;
-        indicateNoDataItems?: boolean;
-        showNoDataItemsLast?: boolean;
-        style?: string;
+        /**
+         * The id the file gave the slicer's frame.
+         */
+        sourceId?: number;
+        /**
+         * The id the file gave the slicer.
+         */
+        uid?: string;
     }
 }
 //# sourceMappingURL=ISlicer.d.ts.map

package/types/src/slicer/ISlicerStyle.d.ts

@@ -0,0 +1,109 @@
+import { IProperties } from '../type';
+import { ICellStyle } from '../style';
+/**
+ * A slicer style: how a slicer draws its frame, its caption and its items in each state.
+ *
+ * @remarks
+ * Office Scripts has the same type, `SlicerStyle`. A slicer names its style with
+ * {@link ISlicer.getStyle}; the workbook's slicer styles, built-ins included, are
+ * {@link IStyleCollection.getSlicerStyles}.
+ */
+export interface ISlicerStyle {
+    /**
+     * Returns the name of the slicer style.
+     */
+    getName(): string;
+    /**
+     * Indicates whether this is one of Excel's built-in slicer styles.
+     */
+    isBuiltIn(): boolean;
+    /**
+     * Deletes the style from the workbook. A built-in style is not deleted.
+     */
+    delete(): void;
+    /**
+     * Returns the style's elements, resolved against the workbook's styles.
+     */
+    getProperties(): Readonly<ISlicerStyle.Properties>;
+    /**
+     * Serializes the style.
+     */
+    toJSON(): ISlicerStyle.JSON;
+    /**
+     * For runtime type checking.
+     */
+    readonly isISlicerStyle: true;
+}
+/**
+ * {@inheritDoc ISlicerStyle}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ISlicerStyle}
+ */
+export declare namespace ISlicerStyle {
+    /**
+     * The parts of a slicer a style formats.
+     */
+    const ElementType: {
+        /** The frame. */
+        readonly WholeTable: "wholeTable";
+        /** The caption. */
+        readonly HeaderRow: "headerRow";
+        readonly UnselectedItemWithData: "unselectedItemWithData";
+        readonly SelectedItemWithData: "selectedItemWithData";
+        readonly UnselectedItemWithNoData: "unselectedItemWithNoData";
+        readonly SelectedItemWithNoData: "selectedItemWithNoData";
+        readonly HoveredUnselectedItemWithData: "hoveredUnselectedItemWithData";
+        readonly HoveredSelectedItemWithData: "hoveredSelectedItemWithData";
+        readonly HoveredUnselectedItemWithNoData: "hoveredUnselectedItemWithNoData";
+        readonly HoveredSelectedItemWithNoData: "hoveredSelectedItemWithNoData";
+    };
+    type ElementType = typeof ElementType[keyof typeof ElementType];
+    /**
+     * A slicer style's elements, each a differential cell format: only what it sets is applied.
+     */
+    interface Properties {
+        /**
+         * The name of the style. This is the name shown in the UI.
+         */
+        name: string;
+        /** The frame. */
+        wholeTable?: ICellStyle.Properties;
+        /** The caption. */
+        headerRow?: ICellStyle.Properties;
+        /** An item the filter leaves out, that has data. */
+        unselectedItemWithData?: ICellStyle.Properties;
+        /** An item the filter selects, that has data. */
+        selectedItemWithData?: ICellStyle.Properties;
+        /** An item the filter leaves out, that the other filters leave without data. */
+        unselectedItemWithNoData?: ICellStyle.Properties;
+        /** An item the filter selects, that the other filters leave without data. */
+        selectedItemWithNoData?: ICellStyle.Properties;
+        /** {@link unselectedItemWithData} under the pointer. */
+        hoveredUnselectedItemWithData?: ICellStyle.Properties;
+        /** {@link selectedItemWithData} under the pointer. */
+        hoveredSelectedItemWithData?: ICellStyle.Properties;
+        /** {@link unselectedItemWithNoData} under the pointer. */
+        hoveredUnselectedItemWithNoData?: ICellStyle.Properties;
+        /** {@link selectedItemWithNoData} under the pointer. */
+        hoveredSelectedItemWithNoData?: ICellStyle.Properties;
+    }
+    type ResolvableProperties = IProperties.ResolvableProperties<ISlicerStyle.Properties>;
+    interface JSON extends ISlicerStyle.Properties {
+    }
+    /**
+     * The document's slicer styles and the default.
+     */
+    interface JSONS {
+        /**
+         * The style a new slicer is given.
+         *
+         * @defaultValue `'SlicerStyleLight1'`
+         */
+        defaultSlicerStyle?: string;
+        /** The document's own slicer styles, keyed by name. */
+        styles?: Record<string, Omit<ISlicerStyle.JSON, 'name'>>;
+    }
+}
+//# sourceMappingURL=ISlicerStyle.d.ts.map

package/types/src/slicer/Slicer.d.ts

@@ -1,21 +1,141 @@
+import { ITransaction } from '../transaction';
 import { IResource } from '../resource';
-import { IModel, AbstractModel } from '../model';
+import { IListener } from '../listener';
+import { ITable } from '../table';
+import { IAnchored } from '../anchored';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ISlicer } from './ISlicer';
+interface State extends AbstractMovableContent.State {
+    data?: ISlicer.JSON;
+}
 /**
  * Implementation for {@link ISlicer}.
  */
-export declare class Slicer extends AbstractModel<State, ISlicer.JSON> implements ISlicer {
+export declare class Slicer extends AbstractMovableContent<State, ISlicer.JSON, ISlicer.Events> implements ISlicer {
+    /** The engine's formula for the source, from the last delivery; `null` until the engine holds it. */
+    private _formula;
+    /** The engine's text as first delivered: while the formula still reads so, nothing has moved. */
+    private _wired;
+    private _binding;
+    /** A lost source was seen as an operation closed; the delete waits for its commit to land. */
+    private _lossPending;
+    /**
+     * The column's name when the source last named a live column, else as the source was given.
+     * What the slicer is labeled by while its column does not resolve: the engine's own text then
+     * may be an internal spelling, never a name.
+     */
+    private _columnName;
     constructor(options: Slicer.ConstructorOptions);
     /** {@inheritDoc IModel.getType} */
     getType(): string;
-    /** {@inheritDoc Movable.Content.getDescription} */
-    getDescription(): string;
+    /** {@inheritDoc IMovable.IContent.getTypeDescription} */
+    getTypeDescription(): string;
+    /** {@inheritDoc IMovable.IContent.getDefaultAnchorType} */
+    getDefaultAnchorType(): IAnchored.Type;
+    /** {@inheritDoc ISlicer.getSource} */
+    getSource(): string;
+    /** {@inheritDoc ISlicer.getTable} */
+    getTable(): ITable | null;
+    /** {@inheritDoc ISlicer.getColumn} */
+    getColumn(): ITable.IColumn | null;
+    /** {@inheritDoc IMovable.IContent.setName} */
+    setName(name: string): this;
+    /** {@inheritDoc ISlicer.getCaption} */
+    getCaption(): string;
+    /** {@inheritDoc ISlicer.setCaption} */
+    setCaption(caption: string | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.isShowCaption} */
+    isShowCaption(): boolean;
+    /** {@inheritDoc ISlicer.setShowCaption} */
+    setShowCaption(show: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.getCacheName} */
+    getCacheName(): string;
+    /** {@inheritDoc ISlicer.getStyle} */
+    getStyle(): string;
+    /** {@inheritDoc ISlicer.setStyle} */
+    setStyle(style: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.getSortOrder} */
+    getSortOrder(): ISlicer.SortOrder;
+    /** {@inheritDoc ISlicer.setSortOrder} */
+    setSortOrder(sortOrder: ISlicer.SortOrder, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.getCrossFilter} */
+    getCrossFilter(): ISlicer.CrossFilter;
+    /** {@inheritDoc ISlicer.setCrossFilter} */
+    setCrossFilter(crossFilter: ISlicer.CrossFilter, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.getColumnCount} */
+    getColumnCount(): number;
+    /** {@inheritDoc ISlicer.setColumnCount} */
+    setColumnCount(count: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.getRowHeight} */
+    getRowHeight(): number;
+    /** {@inheritDoc ISlicer.setRowHeight} */
+    setRowHeight(height: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.isLockedPosition} */
+    isLockedPosition(): boolean;
+    /** {@inheritDoc ISlicer.setLockedPosition} */
+    setLockedPosition(locked: boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISlicer.isFilterCleared} */
+    isFilterCleared(): boolean;
+    /** {@inheritDoc ISlicer.getItems} */
+    getItems(): Promise<readonly ISlicer.Item[]>;
+    /** {@inheritDoc ISlicer.getItem} */
+    getItem(key: string): Promise<ISlicer.Item | null>;
+    /** {@inheritDoc ISlicer.selectItems} */
+    selectItems(keys: readonly string[] | null, options?: ITransaction.OperationOptions): Promise<this>;
+    /** {@inheritDoc ISlicer.clearFilters} */
+    clearFilters(options?: ITransaction.OperationOptions): Promise<this>;
+    /** {@inheritDoc ISlicer.addListeners} */
+    addListeners(listeners: ISlicer.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc Movable.Content.toJSON} */
     toJSON(_toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
-    /** {@inheritDoc Movable.Content.getTypeDescription} */
-    getTypeDescription(): string;
+    /** {@inheritDoc ISlicer.isISlicer} */
+    get isISlicer(): true;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /**
+     * Binds the slicer to its table now, rather than once the engine holds its source: what a
+     * slicer just added does, so a delete of its column right after takes it too.
+     * @internal
+     */
+    _attach(): void;
+    private _data;
+    private _getWorkbook;
+    /** The table and column the source names now, or `null` when it names no column of a live table. */
+    private _resolve;
+    /**
+     * The column's name: the live column's, else the last one the source named.
+     * @internal
+     */
+    _getColumnName(): string;
+    /**
+     * Called when the source or its table may have changed. A slicer whose column is gone - the
+     * column or its table deleted, the table made a range - is deleted as part of the operation
+     * that took it, so one undo brings both back, as Excel does.
+     *
+     * The table tells the slicer as its operation's commit closes, when the engine has rewritten
+     * the source. The commit is still landing then, so the delete waits for it to land and is
+     * folded into it; by then a table cut to another sheet has arrived there and resolves again. A
+     * delivery from the engine is acted on only inside an operation: one from a calculation pass
+     * belongs to no edit. A restore is never acted on: it brings back a state in which the slicer
+     * agrees with its tables.
+     *
+     * @param fromTable Whether the table is asking, after its operation.
+     */
+    private _checkSource;
+    /** Listens to the table the source resolves to. */
+    private _bind;
+    /** Keeps the range listener on the column's data rows; a change of them is a change of items. */
+    private _bindRange;
+    private _unbind;
+    private _notify;
+    /** Writes fields into the slicer's data as one operation; a field set to `undefined` is removed. */
+    private _set;
+    /** @internal */
+    protected _processDelete(): void;
+    /** @internal */
+    protected _processRestoreOrRevert(state: State, commit: ITransaction.ICommit): void;
+    /** @internal */
+    close(): void;
 }
 /**
  * Interfaces for creating `Slicer` items.
@@ -27,15 +147,10 @@ export declare class Slicer extends AbstractModel<State, ISlicer.JSON> implement
  */
 export declare namespace Slicer {
     /**
-     * Options for creating a chart.
+     * Options for creating a slicer.
      */
-    interface ConstructorOptions extends IModel.ConstructorOptions<ISlicer.JSON> {
-        name: string;
+    interface ConstructorOptions extends AbstractMovableContent.ConstructorOptions<ISlicer.JSON> {
     }
 }
-interface State extends AbstractModel.State {
-    data?: any;
-    name?: string;
-}
 export {};
 //# sourceMappingURL=Slicer.d.ts.map

package/types/src/slicer/SlicerStyle.d.ts

@@ -0,0 +1,25 @@
+import { IStyleCollection } from '../style';
+import { ISlicerStyle } from './ISlicerStyle';
+/**
+ * Implementation for {@link ISlicerStyle}: its elements resolved once, against the style
+ * collection that owns it.
+ */
+export declare class SlicerStyle implements ISlicerStyle {
+    protected _properties: Readonly<ISlicerStyle.Properties>;
+    protected _isBuiltIn: boolean;
+    protected _doDelete: ((name: string) => void) | undefined;
+    constructor(styles: IStyleCollection, properties: ISlicerStyle.Properties, isBuiltIn: boolean, doDelete?: (name: string) => void);
+    /** {@inheritDoc ISlicerStyle.getName} */
+    getName(): string;
+    /** {@inheritDoc ISlicerStyle.isBuiltIn} */
+    isBuiltIn(): boolean;
+    /** {@inheritDoc ISlicerStyle.delete} */
+    delete(): void;
+    /** {@inheritDoc ISlicerStyle.getProperties} */
+    getProperties(): Readonly<ISlicerStyle.Properties>;
+    /** {@inheritDoc ISlicerStyle.toJSON} */
+    toJSON(): ISlicerStyle.JSON;
+    /** {@inheritDoc ISlicerStyle.isISlicerStyle} */
+    get isISlicerStyle(): true;
+}
+//# sourceMappingURL=SlicerStyle.d.ts.map

package/types/src/slicer/_BuiltInSlicerStyles.d.ts

@@ -0,0 +1,13 @@
+import { ISlicerStyle } from './ISlicerStyle';
+/**
+ * Excel's built-in slicer styles, taken from Excel (each built-in duplicated and saved, the dxfs
+ * read back; `private-assets/design/shapes/fixtures/slicers/`). Light 1–6 and Dark 1–6 are each one
+ * design over the six accents; Other 1 and 2 stand alone.
+ */
+/** The style a slicer is given when nothing names another. */
+export declare const DefaultSlicerStyleName: string;
+/**
+ * Returns the built-in slicer styles in gallery order: Light, Other, Dark. Built on the first call.
+ */
+export declare const _BuiltInSlicerStyles: () => readonly ISlicerStyle.Properties[];
+//# sourceMappingURL=_BuiltInSlicerStyles.d.ts.map

package/types/src/slicer/_SlicerUtils.d.ts

@@ -0,0 +1,30 @@
+import { IWorkbook } from '../workbook';
+import { ITable } from '../table';
+import { ISlicer } from './ISlicer';
+/**
+ * The table and column a slicer's source names, or `null` when it is not one column of one table
+ * (`#REF!` once the column is gone, a plain range once the table is).
+ */
+export declare function parseSource(source: string | null | undefined): {
+    table: string;
+    column: string;
+} | null;
+/** `Sales[Region]`: the source text for one column of a table, as a formula spells it. */
+export declare function formatSource(tableName: string, columnName: string): string;
+/** The table named `name` on any sheet of the workbook, or `null`. */
+export declare function findTable(workbook: IWorkbook | null | undefined, name: string): ITable | null;
+/** Every slicer of the workbook, in sheet order and then in each sheet's movable order. */
+export declare function getSlicers(workbook: IWorkbook | null | undefined): ISlicer[];
+/**
+ * `base`, or the first of `base 1`, `base 2`, ... no other slicer of the workbook is named
+ * (compared without case), as Excel names a second slicer on a column.
+ */
+export declare function uniqueSlicerName(workbook: IWorkbook | null | undefined, base: string, except?: ISlicer): string;
+/** `Slicer_` and the column name, each character that is not a letter, digit or `_` made `_`. */
+export declare function deriveCacheName(columnName: string): string;
+/**
+ * The cache names of the workbook's slicers, by slicer: a carried name as it is, then a derived
+ * one in workbook order, numbered past any name already taken (`Slicer_Region1`).
+ */
+export declare function resolveCacheNames(workbook: IWorkbook | null | undefined): Map<ISlicer, string>;
+//# sourceMappingURL=_SlicerUtils.d.ts.map