@sheetxl/formulas-extended 0.8.0-beta.14 → 0.8.0-beta.16

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@sheetxl/formulas-extended",
   "description": "Formulas Enterprise - TypeScript formulas compatible with Excel built-ins.",
-  "version": "0.8.0-beta.14",
-  "license": "SEE LICENSE IN <LICENSE>",
+  "version": "0.8.0-beta.16",
+  "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
     ".": {
@@ -42,7 +42,7 @@
     "formulas"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.8.0-beta.14",
-    "@sheetxl/scripting": "^0.8.0-beta.14"
+    "@sheetxl/primitives": "^0.8.0-beta.16",
+    "@sheetxl/scripting": "^0.8.0-beta.16"
   }
 }

package/types/src/_utils/Pivot.d.ts

@@ -109,61 +109,59 @@ export declare const isLoneBlankCell: (values: IRange) => boolean;
  * `#VALUE!` for the whole call (f06, f08), as is a shape mismatch (f03, f09, f11).
  */
 export declare const isValidFilter: (filter: IRange, recordCount: number) => boolean;
+/** A group of one axis of the pivot. */
+export type Group = IFormulaContext.PivotGroup;
 /**
- * A group at one key level of an axis.
- */
-export interface AxisNode {
-    /** The key level, 0 for the outermost field. */
-    readonly level: number;
-    /** The group within that level's grouping. */
-    readonly group: number;
-    /** The keys down to this level, as spelled by the group's first record. */
-    readonly keys: readonly Scalar[];
-    /** The group one level up, `null` at the outermost level. */
-    readonly parent: AxisNode | null;
-    readonly children: AxisNode[];
-}
-/**
- * One output line of an axis: a group at the innermost level, a subtotal, or the grand total.
+ * One output line of an axis: a group at the innermost level, a subtotal, or the grand total
+ * (the axis's root).
  */
 export interface AxisLine {
     readonly kind: 'group' | 'subtotal' | 'total';
-    /** `null` for the grand total. */
-    readonly node: AxisNode | null;
+    readonly node: Group;
 }
+/** Each group's children in their sorted order. */
+export type AxisOrder = ReadonlyMap<Group, readonly Group[]>;
+/**
+ * `measure` over the records in both a row group and a column group: the pivot's own aggregate
+ * when it computes the function ({@link IFormulaContext.Pivot.getAggregate}), the function over
+ * the members otherwise, and `""` when no record is in both.
+ */
+export declare const aggregateAt: (pivot: IFormulaContext.Pivot, measure: Measure, values: IRange, row: Group | undefined, column: Group | undefined, y: () => IRange) => Scalar;
 /**
- * One axis of groups — `GROUPBY`'s rows, or either side of `PIVOTBY`.
+ * The layout of one axis of a pivot — `GROUPBY`'s rows, or either side of `PIVOTBY` — over the
+ * pivot's tree of groups ({@link IFormulaContext.createPivot}): sorting, subtotal and total
+ * placement, and key cells.
  *
  * @remarks
- * Each key level has its own grouping, over the key columns down to it, so a subtotal's members are
- * one group of that grouping rather than a union of its children's. A level's parent is read
- * through its first record (`getFirstRecord`/`getGroup`).
+ * The pivot groups every key level, so a subtotal's members are one group rather than a union of
+ * its children's, and each level keeps its own group's spelling: `East`, then `east` under a later
+ * product, is still `East` in that row (c13).
  */
-export declare class PivotAxis {
+export declare class AxisLayout {
+    readonly root: Group;
     readonly fieldCount: number;
-    /** Per key level, the grouping over the key columns down to it. */
-    readonly groupings: IFormulaContext.Grouping[];
-    /** Per key level, the key columns down to it. */
-    readonly prefixes: IRange[];
-    readonly roots: AxisNode[];
-    constructor(keys: IRange, filter: IRange | undefined);
-    /** The number of records kept. */
-    getRecordCount(): number;
-    /** A node's members of one value column. */
-    getMembers(values: IRange, node: AxisNode | null): IRange;
+    /**
+     * @param axis One axis of the pivot.
+     * @param fieldCount The key columns the axis is grouped by.
+     */
+    constructor(axis: IFormulaContext.PivotAxis, fieldCount: number);
     /**
      * Orders the groups at every level.
      *
-     * @param valueOf A node's aggregate, for a sort by value.
-     * @param table Field relationship 1: one flat order over the innermost groups (d18).
+     * @param valueOf A group's aggregate, for a sort by value.
      *
      * @remarks
-     * Keys sort by the comparison operators' order — numbers, text, `FALSE`, `TRUE`, errors — with
+     * Keys sort by the comparison operators' order — numbers, text, `FALSE`, `TRUE`, errors — with
      * a blank key last in either direction (e01, e02). A sort by value orders each level by its own
      * aggregate, parents by their subtotal (d05); ties keep key order (e06), and an error aggregate
      * sorts last.
      */
-    sort(spec: SortSpec, valueOf: (node: AxisNode) => Scalar, table: boolean): AxisNode[];
+    sortTree(spec: SortSpec, valueOf: (node: Group) => Scalar): AxisOrder;
+    /**
+     * The innermost groups in one flat order, for field relationship 1 (d18): by every key level in
+     * turn, then by value when the sort asks for it.
+     */
+    sortLeaves(spec: SortSpec, valueOf: (node: Group) => Scalar): Group[];
     /**
      * The output lines in order, with subtotals and the grand total placed per `depth`.
      *
@@ -171,7 +169,7 @@ export declare class PivotAxis {
      * `|depth|` 1 is the grand total alone; each step deeper adds subtotals for one more level from
      * the top (c03, c13, c14). A negative depth puts every total before what it totals (c06, c15).
      */
-    lines(roots: AxisNode[], depth: number): AxisLine[];
+    lines(order: AxisOrder, depth: number): AxisLine[];
     /**
      * The key cells of a line: its keys, `""` past its level, and the total's label.
      *