@ex-grid/sheet 0.2.0-beta.3 → 0.2.0-rc.1

package/dist/index.js

@@ -646,7 +646,11 @@ function overlap(a, b) {
 }
 
 // src/sheet-find.ts
-import { findMatches, replacedEntry } from "@ex-grid/core";
+import {
+  findAllPage,
+  findMatches,
+  replacedEntry
+} from "@ex-grid/core";
 import { CellAddress as CellAddress6, Sheet as Sheet3 } from "@ex-grid/sheet-engine";
 function sheetFindStep(sheet, request) {
   if (request.text === "" || request.columns.length === 0) return { found: false };
@@ -670,6 +674,69 @@ function sheetFindStep(sheet, request) {
   }
   return found;
 }
+function sheetFindAll(sheet, request, rowSequenceVersion) {
+  const { start, count } = request;
+  if (!Number.isInteger(start) || start < 0) throw new RangeError(`A Find All page starts at an entry at or after 0, not ${String(start)}.`);
+  if (!Number.isInteger(count) || count < 1) throw new RangeError(`A Find All page asks for 1 entry or more, not ${String(count)}.`);
+  const positions = positionsOf(request.columns);
+  const columnCount2 = request.columns.length;
+  const ordinals = [];
+  if (request.text !== "") {
+    for (const address of sheet.entryAddresses) {
+      const position = positions.get(address.column);
+      if (position === void 0) continue;
+      if (request.scope !== void 0 && !inScope(request.scope, address.row, position)) continue;
+      if (sheetCellMatches(sheet, address, request)) ordinals.push(address.row * columnCount2 + position);
+    }
+  }
+  ordinals.sort((a, b) => a - b);
+  const matches = ordinals.slice(start, start + count).map((ordinal) => {
+    const row = Math.floor(ordinal / columnCount2);
+    const position = ordinal % columnCount2;
+    const column = columnName(request.columns, position);
+    const sheetColumn = CellAddress6.tryParseColumn(column);
+    if (sheetColumn === void 0) throw new Error(`Internal: '${column}' names no Sheet column.`);
+    return { row, column, text: shownTextOf(sheet, new CellAddress6(row, sheetColumn)) };
+  });
+  return findAllPage(ordinals.length, matches, rowSequenceVersion);
+}
+var SheetWorkbookMatches = class {
+  #sheets;
+  #sheetOf;
+  #ordinals;
+  constructor(sheets, pattern) {
+    const sheetOf = [];
+    const ordinals = [];
+    if (pattern.text !== "") {
+      sheets.forEach((sheet, index) => {
+        const found = [];
+        for (const address of sheet.entryAddresses) {
+          if (sheetCellMatches(sheet, address, pattern)) found.push(address.row * Sheet3.columnCount + address.column);
+        }
+        found.sort((a, b) => a - b);
+        for (const ordinal of found) {
+          sheetOf.push(index);
+          ordinals.push(ordinal);
+        }
+      });
+    }
+    this.#sheets = sheets;
+    this.#sheetOf = sheetOf;
+    this.#ordinals = ordinals;
+  }
+  /** How many cells match. */
+  get count() {
+    return this.#ordinals.length;
+  }
+  /** Match `index`: its Sheet and its cell. */
+  at(index) {
+    const sheetIndex = this.#sheetOf[index];
+    const ordinal = this.#ordinals[index];
+    const sheet = sheetIndex === void 0 ? void 0 : this.#sheets[sheetIndex];
+    if (sheet === void 0 || ordinal === void 0) throw new RangeError(`The Workbook's Find All holds ${String(this.count)} matches, not one at ${String(index)}.`);
+    return { sheet, address: new CellAddress6(Math.floor(ordinal / Sheet3.columnCount), ordinal % Sheet3.columnCount) };
+  }
+};
 function sheetFindStepWorkbook(sheets, shown, request) {
   if (request.text === "" || request.columns.length === 0) return void 0;
   const positions = positionsOf(request.columns);
@@ -814,7 +881,7 @@ function sheetFindPanelSlot(host) {
       input.checked = host.within() === within2;
       input.setAttribute("data-ex-claims", "click");
       input.addEventListener("change", () => {
-        if (input.checked) host.chooseWithin(within2);
+        if (input.checked) host.chooseWithin(within2, context);
       });
       const element = doc.createElement("label");
       element.append(input, label(id));
@@ -835,7 +902,10 @@ function sheetFindPanelSlot(host) {
     );
     const steps = doc.createElement("div");
     steps.className = "ex-popover-actions";
-    steps.append(button("ex-find-previous", findPanelLabelIds.previous, context.previous), button("ex-find-next", findPanelLabelIds.next, context.next));
+    const findAll = button("ex-find-all-button", findPanelLabelIds.findAll, () => {
+      host.findAll(context);
+    });
+    steps.append(findAll, button("ex-find-previous", findPanelLabelIds.previous, context.previous), button("ex-find-next", findPanelLabelIds.next, context.next));
     const outcome = doc.createElement("div");
     outcome.className = "ex-find-outcome";
     outcome.setAttribute("role", "status");
@@ -843,6 +913,7 @@ function sheetFindPanelSlot(host) {
     let replace;
     const paint = () => {
       view = context.view();
+      if (findAll.hidden === view.findAllShown) findAll.hidden = !view.findAllShown;
       if (matchCase.box.checked !== view.matchCase) matchCase.box.checked = view.matchCase;
       if (wholeCell.box.checked !== view.wholeCell) wholeCell.box.checked = view.wholeCell;
       if (view.replaceShown && replace === void 0) {
@@ -1029,6 +1100,16 @@ var SheetSource = class {
     if (sheet === void 0) return Promise.reject(new DOMException("The step was asked of a Sheet shown before the last one.", "AbortError"));
     return this.#step(sheet, request);
   }
+  /** A page of a Find All over the Sheet its Row Sequence Version names (ADR-0470 §7), as a step is answered: the
+   * one shown, or the one before it. Asked under an older version, the list named rows of a Sheet no longer shown:
+   * given up, never answered about cells nobody searched. Within the Workbook, the Sheet lists the matches itself. */
+  findAll(request, signal) {
+    signal.throwIfAborted();
+    const before = this.#before;
+    const sheet = request.rowSequenceVersion === this.#version ? this.#sheet : request.rowSequenceVersion === before?.version ? before.sheet : void 0;
+    if (sheet === void 0) return Promise.reject(new DOMException("The Find All was asked of a Sheet shown before the last one.", "AbortError"));
+    return Promise.resolve(sheetFindAll(sheet, request, request.rowSequenceVersion));
+  }
   /** A Selection Summary over the Sheet its Row Sequence Version names (ADR-0130), as C#'s `SheetSummary` answers
    * one: the Values of the selected cells in Excel's doubles, the figures that read numbers written in the Focus
    * cell's Number Format, or the summary declined over the first refused cell. Asked under an older version, the
@@ -4986,6 +5067,7 @@ import {
   formulaHintAt,
   formulaPointAt,
   LinkedTableColumn,
+  moveReference,
   referenceText
 } from "@ex-grid/sheet-engine";
 function sheetPointAt(text, caret2) {
@@ -5022,6 +5104,9 @@ function sheetReferenceText(range) {
 function sheetReferenceTextOn(range, shown, home) {
   return home === void 0 || home === shown ? sheetReferenceText(range) : referenceText(cellRangeOf(range), shown.name);
 }
+function sheetMoveReference(sheet, reference, range) {
+  return moveReference(reference, cellRangeOf(range), sheet.workbook.size);
+}
 function cellRangeOf(range) {
   return new CellRange5(
     new CellAddress11(range.topRow, range.leftColumn),
@@ -5931,6 +6016,7 @@ var SheetView = class _SheetView {
   // and its views go with it, under a new Row Sequence Version, which drops the Selection and refuses what was aimed
   // at the old cells (ADR-0011, ADR-0142).
   #replaceWorkbook(opened, fromFile) {
+    this.#dropWorkbookFindAll();
     this.#fileOpened = fromFile;
     this.#workbook = opened;
     this.#history.clear();
@@ -6074,6 +6160,8 @@ var SheetView = class _SheetView {
       // Formula is typed on, all of them; on another shown to point at its cells, those naming it (ADR-0331 §5).
       referencesIn: this.#referencesIn,
       onReferenceKeyColoursChanged: this.#onKeyColoursChanged,
+      // An outline dragged by its edge or a corner square rewrites its Reference in its own form (ADR-0480).
+      moveReference: this.#moveReference,
       // Point: the arrows and a press write a Reference where one can go, and F4 cycles its forms (ADR-0051).
       pointAt: sheetPointAt,
       referenceText: this.#referenceText,
@@ -6400,6 +6488,8 @@ var SheetView = class _SheetView {
   }
   // The Reference Point writes: bare on the Sheet the Formula is typed on, named with its Sheet on another (ADR-0331 §5).
   #referenceText = (range) => sheetReferenceTextOn(range, this.#source.sheet, this.#editHome);
+  // A dragged Reference rewritten to name other cells of the Sheet shown, written as it was (ADR-0480).
+  #moveReference = (reference, range) => sheetMoveReference(this.#source.sheet, reference, range);
   // The Sheet the open edit was opened on, once another Sheet has been shown while it is typed (ADR-0331 §5): its
   // Formula is committed there, and the edit's end shows it again.
   #editHome;
@@ -7095,6 +7185,8 @@ var SheetView = class _SheetView {
   // ---- Find Within (ADR-0332 §5, ADR-0331 §8) -------------------------------------------------------------------
   // Where the panel searches, as it last chose: kept across a close and a reopen, as the grid keeps the text.
   #findWithin = "sheet";
+  // The panel a Find All over the Workbook was listed in, while its list may stand (ADR-0470 §7).
+  #workbookFindAll;
   // Every answer that changes what the panel says moves this on: a step asked, the grid's Replace Request, a choice
   // of Within. The Sheet's own Replace All's outcome is said while nothing has moved it since, and the panel has not
   // been mounted again.
@@ -7119,14 +7211,23 @@ var SheetView = class _SheetView {
     within: () => this.#findWithin,
     // A choice of Within is a click taken in its place in the Input Order (ADR-0240): a step numbered before it
     // searches where the panel searched then, one numbered after it where it searches now.
-    chooseWithin: (within) => {
+    chooseWithin: (within, context) => {
       this.#findWithin = within;
       this.#findMoved();
+      context.dropFindAll();
+      this.#workbookFindAll = void 0;
+    },
+    // Over the Sheet, the grid's list; over the Workbook, the Sheet's own, which the grid draws (ADR-0470 §7).
+    findAll: (context) => {
+      if (this.#findWithin === "workbook") context.listFindAll(() => this.#listWorkbook(context));
+      else context.findAll();
     },
     // Over the Sheet, the grid's Replace Request; over the Workbook, the Sheet's own.
     replaceAll: (context) => {
-      if (this.#findWithin === "workbook") this.#replaceAllInWorkbook(context);
-      else context.replaceAll();
+      if (this.#findWithin === "workbook") {
+        this.#dropWorkbookFindAll();
+        this.#replaceAllInWorkbook(context);
+      } else context.replaceAll();
     },
     outcome: (context) => {
       const own = this.#ownFind;
@@ -7165,6 +7266,50 @@ var SheetView = class _SheetView {
       throw new DOMException("The match is on another Sheet, now shown with it selected.", "AbortError");
     });
   };
+  /**
+   * Find All over the Workbook (ADR-0470 §7), asked in the press's turn: every Sheet's matches, in tab order, each line
+   * named by its Sheet and address (`Sheet2!B12`) and showing its cell's text, for the grid to draw. The Sheet holds
+   * the cells, so it drops the list at any change to the Workbook.
+   */
+  #listWorkbook(context) {
+    const view = context.view();
+    const matches = new SheetWorkbookMatches(this.#workbook.sheets, { text: view.text, matchCase: view.matchCase, wholeCell: view.wholeCell });
+    this.#workbookFindAll = context;
+    return {
+      count: matches.count,
+      line: (index) => {
+        const { sheet, address } = matches.at(index);
+        return { where: referenceText2(new CellRange6(address), sheet.name), text: shownTextOf(sheet, address) };
+      },
+      choose: (index) => this.#chooseWorkbookMatch(matches.at(index))
+    };
+  }
+  // A line of the Workbook's list chosen (ADR-0470 §4): a match on the Sheet shown is placed as a step's answer is;
+  // one on another Sheet shows that Sheet with the cell selected, as a step over the Workbook does. While an edit is
+  // open nothing moves, and the notice says why. Answers whether the Focus moved, so the list marks the line only then.
+  #chooseWorkbookMatch({ sheet, address }) {
+    if (this.#destroyed) return false;
+    if (this.#editing) {
+      this.#tell(this.#words.editIsOpen);
+      return false;
+    }
+    const cell = { row: address.row, column: address.column };
+    if (sheet === this.#source.sheet) {
+      const grid = this.#grid;
+      if (grid === void 0) throw new Error("Internal: the Workbook's Find All list was chosen from with no grid drawn.");
+      return grid.placeMatch(cell, this.#source.snapshot().rowSequenceVersion);
+    }
+    this.#clearNotice();
+    this.#showSheet(sheet, cell);
+    this.#raiseDocument();
+    return true;
+  }
+  // The Workbook's Find All list goes: the cells it was read from changed.
+  #dropWorkbookFindAll() {
+    const context = this.#workbookFindAll;
+    this.#workbookFindAll = void 0;
+    context?.dropFindAll();
+  }
   /**
    * Replace All over the Workbook (ADR-0332 §5), from the panel's button in its place in the Input Order: every
    * cell of every Sheet whose Entry matches, all or nothing, as one step on the undo stack, which shows the Sheet it
@@ -7713,6 +7858,7 @@ var SheetView = class _SheetView {
    * the C# Sheet's does, since it changes Values and no format Format Cells read.
    */
   #changed(changes, raiseDocument = true, byUser = true) {
+    this.#dropWorkbookFindAll();
     if (byUser) {
       this.#endFormatCells();
       this.#endChoices();