@rowsncolumns/spreadsheet 10.2.68

package/LICENSE.md

@@ -0,0 +1,100 @@
+# Rows n' Columns Commercial License Agreement
+
+This Rows n' Columns Commercial License Agreement (the "Agreement") governs
+the use of the Rows n' Columns software packages published under the
+`@rowsncolumns` npm scope, including associated JavaScript, WebAssembly
+binaries, stylesheets, type definitions and documentation (the "Software").
+
+The Software is **not** open source. Downloading or installing the Software
+from a public package registry does not grant any right to use it beyond the
+evaluation use described below.
+
+## 1. Definitions
+
+- **"Licensor"** means Rows n' Columns (rowsncolumns.app).
+- **"Licensee"** means the individual or legal entity identified in an Order.
+- **"Order"** means a purchase of a license for the Software from Licensor,
+  identified by an order ID and associated with a License Key.
+- **"License Key"** means the signed key issued by Licensor that identifies
+  the Licensee, license tier, and Update Window.
+- **"Update Window"** means the period stated in the Order during which
+  Software versions released by Licensor are covered by the License Key.
+
+## 2. License Grant
+
+Subject to payment of the applicable fees and compliance with this Agreement,
+Licensor grants Licensee a non-exclusive, non-transferable, worldwide license
+to use, and to distribute in compiled form as an embedded component of
+Licensee's own applications, any version of the Software released during the
+Update Window, in accordance with the license tier stated in the Order.
+
+This grant is perpetual for versions released during the Update Window:
+Licensee may continue to use those versions after the Update Window ends.
+Versions released after the Update Window ends require a new or renewed
+Order.
+
+## 3. Evaluation Use
+
+The Software may be used without a License Key solely for internal
+evaluation and development purposes. Evaluation use in production, or
+removal or suppression of evaluation notices, is not permitted.
+
+## 4. Restrictions
+
+Except as expressly permitted by this Agreement or by applicable law that
+cannot be contractually waived, Licensee shall not:
+
+1. redistribute, resell, sublicense, or otherwise make the Software
+   available as a standalone product, library, or development component;
+2. use the Software to build a product that competes with the Software;
+3. remove, alter, or circumvent License Key validation, evaluation notices,
+   watermarks, or copyright notices in the Software;
+4. share License Keys with any third party, or use a License Key outside
+   the scope of the tier stated in the Order;
+5. reverse engineer, decompile, or disassemble the Software except to the
+   extent permitted by applicable law.
+
+## 5. Ownership
+
+The Software is licensed, not sold. Licensor and its licensors retain all
+right, title, and interest in and to the Software, including all
+intellectual property rights.
+
+## 6. Third-Party Components
+
+The Software may include third-party open-source components. Those
+components remain governed by their own license terms, which are included
+with the applicable component and are not limited by this Agreement.
+
+## 7. Termination
+
+This Agreement terminates automatically upon material breach by Licensee
+that remains uncured 30 days after written notice. Upon termination,
+Licensee must cease use and distribution of the Software, except that
+end-user copies of Licensee applications already distributed in compliance
+with this Agreement are unaffected.
+
+## 8. Warranty Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+## 9. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL LICENSOR BE LIABLE
+FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES,
+OR ANY LOSS OF PROFITS, DATA, OR GOODWILL, ARISING OUT OF OR RELATED TO THIS
+AGREEMENT, AND LICENSOR'S AGGREGATE LIABILITY SHALL NOT EXCEED THE FEES PAID
+BY LICENSEE IN THE TWELVE MONTHS PRECEDING THE CLAIM.
+
+## 10. General
+
+This Agreement constitutes the entire agreement between the parties
+concerning the Software and supersedes any prior agreements. If any
+provision is held unenforceable, the remainder remains in effect. Failure to
+enforce a provision is not a waiver.
+
+For licensing inquiries, visit <https://www.rowsncolumns.app/pricing>.
+
+Copyright © Rows n' Columns. All rights reserved.

package/Readme.md

@@ -0,0 +1,9 @@
+# RowsnColumns Spreadsheet
+
+A declarative Spreadsheet powered by ReactJS. Uses Canvas for rendering.
+
+## Installation
+
+```javascript
+yarn add @rowsncolumns/spreadsheet
+```

package/dist/cjs/api/animate.d.ts

@@ -0,0 +1,36 @@
+type StepCallback = (percent: number, now: number, render: boolean) => boolean | void;
+type VerifyCallback = (id: number) => boolean;
+type CompletedCallback = (droppedFrames: number, animationId: number, wasFinished: boolean) => void;
+type EasingMethod = (percent: number) => number;
+/**
+ * Stops the given animation.
+ *
+ * @param id {Integer} Unique animation ID
+ * @return {Boolean} Whether the animation was stopped (aka, was running before)
+ */
+export declare const stop: (id: number) => boolean;
+/**
+ * Whether the given animation is still running.
+ *
+ * @param id {Integer} Unique animation ID
+ * @return {Boolean} Whether the animation is still running
+ */
+export declare const isRunning: (id: number) => boolean;
+/**
+ * Start the animation.
+ *
+ * @param stepCallback {Function} Pointer to function which is executed on every step.
+ *   Signature of the method should be `function(percent, now, virtual) { return continueWithAnimation; }`
+ * @param verifyCallback {Function} Executed before every animation step.
+ *   Signature of the method should be `function() { return continueWithAnimation; }`
+ * @param completedCallback {Function}
+ *   Signature of the method should be `function(droppedFrames, finishedAnimation, optional wasFinished) {}`
+ * @param duration {Integer} Milliseconds to run the animation
+ * @param easingMethod {Function} Pointer to easing function
+ *   Signature of the method should be `function(percent) { return modifiedValue; }`
+ * @param root {Element} Render root. Used for internal usage of requestAnimationFrame.
+ * @return {Integer} Identifier of animation. Can be used to stop it any time.
+ */
+export declare const start: (stepCallback: StepCallback, verifyCallback: VerifyCallback, completedCallback: CompletedCallback, duration?: number, easingMethod?: EasingMethod) => number;
+export {};
+//# sourceMappingURL=animate.d.ts.map

package/dist/cjs/api/animate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animate.d.ts","sourceRoot":"","sources":["../../../api/animate.ts"],"names":[],"mappings":"AAEA,KAAK,YAAY,GAAG,CAClB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,OAAO,KACZ,OAAO,GAAG,IAAI,CAAC;AACpB,KAAK,cAAc,GAAG,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;AAC9C,KAAK,iBAAiB,GAAG,CACvB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,OAAO,KACjB,IAAI,CAAC;AACV,KAAK,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;AAsBhD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAa,IAAI,MAAM,YAOvC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAa,IAAI,MAAM,YAE5C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAChB,cAAc,YAAY,EAC1B,gBAAgB,cAAc,EAC9B,mBAAmB,iBAAiB,EACpC,WAAW,MAAM,EACjB,eAAe,YAAY,WAmF5B,CAAC"}

package/dist/cjs/api/animate.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = exports.isRunning = exports.stop = void 0;
+var utils_1 = require("@rowsncolumns/utils");
+var time = Date.now || (function () { return +new Date(); });
+var desiredFrames = 60;
+var millisecondsPerSecond = 1000;
+var running = {};
+var counter = 1;
+/**
+ * A requestAnimationFrame wrapper / polyfill.
+ *
+ * @param callback {Function} The callback to be invoked before the next repaint.
+ * @param root {HTMLElement} The root element for the repaint
+ */
+var requestAnimationFrame = (function () {
+    // Check for request animation Frame support
+    var requestFrame = utils_1.canUseDOM ? window.requestAnimationFrame : function () { return null; };
+    return function (callback) {
+        requestFrame(callback);
+    };
+})();
+/**
+ * Stops the given animation.
+ *
+ * @param id {Integer} Unique animation ID
+ * @return {Boolean} Whether the animation was stopped (aka, was running before)
+ */
+var stop = function (id) {
+    var cleared = running[id] !== null;
+    if (cleared) {
+        running[id] = null;
+    }
+    return cleared;
+};
+exports.stop = stop;
+/**
+ * Whether the given animation is still running.
+ *
+ * @param id {Integer} Unique animation ID
+ * @return {Boolean} Whether the animation is still running
+ */
+var isRunning = function (id) {
+    return running[id] !== null;
+};
+exports.isRunning = isRunning;
+/**
+ * Start the animation.
+ *
+ * @param stepCallback {Function} Pointer to function which is executed on every step.
+ *   Signature of the method should be `function(percent, now, virtual) { return continueWithAnimation; }`
+ * @param verifyCallback {Function} Executed before every animation step.
+ *   Signature of the method should be `function() { return continueWithAnimation; }`
+ * @param completedCallback {Function}
+ *   Signature of the method should be `function(droppedFrames, finishedAnimation, optional wasFinished) {}`
+ * @param duration {Integer} Milliseconds to run the animation
+ * @param easingMethod {Function} Pointer to easing function
+ *   Signature of the method should be `function(percent) { return modifiedValue; }`
+ * @param root {Element} Render root. Used for internal usage of requestAnimationFrame.
+ * @return {Integer} Identifier of animation. Can be used to stop it any time.
+ */
+var start = function (stepCallback, verifyCallback, completedCallback, duration, easingMethod) {
+    var start = time();
+    var lastFrame = start;
+    var percent = 0;
+    var dropCounter = 0;
+    var id = counter++;
+    // Compacting running db automatically every few new animations
+    if (id % 20 === 0) {
+        var newRunning = {};
+        for (var usedId in running) {
+            newRunning[usedId] = true;
+        }
+        running = newRunning;
+    }
+    // This is the internal step method which is called every few milliseconds
+    var step = function (virtual) {
+        // Normalize virtual value
+        var render = virtual !== true;
+        // Get current time
+        var now = time();
+        // Verification is executed before next animation step
+        if (!running[id] || (verifyCallback && !verifyCallback(id))) {
+            running[id] = null;
+            completedCallback(desiredFrames - dropCounter / ((now - start) / millisecondsPerSecond), id, false);
+            return;
+        }
+        // For the current rendering to apply let's update omitted steps in memory.
+        // This is important to bring internal state variables up-to-date with progress in time.
+        if (render) {
+            var droppedFrames = Math.round((now - lastFrame) / (millisecondsPerSecond / desiredFrames)) - 1;
+            for (var j = 0; j < Math.min(droppedFrames, 4); j++) {
+                step(true);
+                dropCounter++;
+            }
+        }
+        // Compute percent value
+        if (duration) {
+            percent = (now - start) / duration;
+            if (percent > 1) {
+                percent = 1;
+            }
+        }
+        // Execute step callback, then...
+        var value = easingMethod ? easingMethod(percent) : percent;
+        if ((stepCallback(value, now, render) === false || percent === 1) &&
+            render) {
+            running[id] = null;
+            completedCallback(desiredFrames - dropCounter / ((now - start) / millisecondsPerSecond), id, percent === 1 || duration === undefined);
+        }
+        else if (render) {
+            lastFrame = now;
+            requestAnimationFrame(step);
+        }
+    };
+    // Mark as running
+    running[id] = true;
+    // Init first step
+    requestAnimationFrame(step);
+    // Return unique animation ID
+    return id;
+};
+exports.start = start;

package/dist/cjs/api/banded-ranges.d.ts

@@ -0,0 +1,16 @@
+import type { SpreadsheetTheme } from "../components/canvas-grid/typings";
+import type { BandedRange, CellFormat, Color, Maybe } from "../types";
+/**
+ * Get banded cells
+ * @param bandedRanges
+ * @param theme
+ * @returns
+ */
+export declare const getBandedCells: (bandedRanges: BandedRange[], theme: SpreadsheetTheme, sheetId: number, isHiddenRow: (rowIndex: number) => boolean, isHiddenColumn: (columnIndex: number) => boolean) => Map<string, CellFormat>;
+/**
+ * Parse tinted color. returns undefined if tint >= 1
+ * @param color
+ * @returns
+ */
+export declare const parseTintedColor: (color: Maybe<Color | string>) => Maybe<Color>;
+//# sourceMappingURL=banded-ranges.d.ts.map

package/dist/cjs/api/banded-ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banded-ranges.d.ts","sourceRoot":"","sources":["../../../api/banded-ranges.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE1E,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,cAAc,WAAW,EAAE,EAC3B,OAAO,gBAAgB,EACvB,SAAS,MAAM,EACf,aAAa,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,EAC1C,gBAAgB,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,4BA0HjD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,iBAE5D,CAAC"}

package/dist/cjs/api/banded-ranges.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTintedColor = exports.getBandedCells = void 0;
+var tslib_1 = require("tslib");
+var grid_1 = require("@rowsncolumns/grid");
+var utils_1 = require("@rowsncolumns/utils");
+var themes_1 = require("../themes");
+/**
+ * Get banded cells
+ * @param bandedRanges
+ * @param theme
+ * @returns
+ */
+var getBandedCells = function (bandedRanges, theme, sheetId, isHiddenRow, isHiddenColumn) {
+    var e_1, _a;
+    var _b, _c;
+    var bandedCells = new Map();
+    try {
+        for (var bandedRanges_1 = tslib_1.__values(bandedRanges), bandedRanges_1_1 = bandedRanges_1.next(); !bandedRanges_1_1.done; bandedRanges_1_1 = bandedRanges_1.next()) {
+            var _d = bandedRanges_1_1.value, range = _d.range, rowProperties = _d.rowProperties, columnProperties = _d.columnProperties;
+            // Only pick current sheet
+            if (range.sheetId !== sheetId) {
+                continue;
+            }
+            if (rowProperties || columnProperties) {
+                var _e = rowProperties !== null && rowProperties !== void 0 ? rowProperties : {}, headerColor = _e.headerColor, firstBandColor = _e.firstBandColor, secondBandColor = _e.secondBandColor, footerColor = _e.footerColor, headerBorder = _e.headerBorder, firstBandBorder = _e.firstBandBorder, footerBorder = _e.footerBorder;
+                var _f = columnProperties !== null && columnProperties !== void 0 ? columnProperties : {}, firstBandColorColumn = _f.firstBandColor, secondBandColorColumn = _f.secondBandColor;
+                var parsedFirstBandColor = (0, exports.parseTintedColor)(firstBandColor);
+                var parsedSecondBandColor = (0, exports.parseTintedColor)(secondBandColor);
+                var parsedFirstBandColorColumn = (0, exports.parseTintedColor)(firstBandColorColumn);
+                var parsedSecondBandColorColumn = (0, exports.parseTintedColor)(secondBandColorColumn);
+                // Pick headers using header color/border
+                var isHeader = headerColor || headerBorder;
+                // Hidden row count
+                var rowRunningIndex = 0;
+                var lastVisibleRowIndex = getLastVisibleRowIndex(range, isHiddenRow);
+                for (var rowIndex = range.startRowIndex + (isHeader ? 0 : 1); // Ignore header row
+                 rowIndex <= range.endRowIndex; rowIndex++) {
+                    if (isHiddenRow(rowIndex)) {
+                        continue;
+                    }
+                    var isOddRow = rowRunningIndex % 2 !== 0;
+                    var columnRunningIndex = 0;
+                    for (var columnIndex = range.startColumnIndex; columnIndex <= range.endColumnIndex; columnIndex++) {
+                        if (isHiddenColumn(columnIndex)) {
+                            continue;
+                        }
+                        var id = (0, grid_1.cellIdentifier)(rowIndex, columnIndex);
+                        // Header
+                        if (rowIndex === range.startRowIndex) {
+                            if (isHeader) {
+                                bandedCells.set(id, {
+                                    backgroundColor: headerColor,
+                                    borders: headerBorder,
+                                    textFormat: {
+                                        color: headerColor
+                                            ? (0, utils_1.getContrastColor)((0, themes_1.getStringifiedColor)(headerColor, theme), (0, themes_1.getStringifiedColor)({ theme: 1 }, theme), (0, themes_1.getStringifiedColor)({ theme: 0 }, theme))
+                                            : undefined,
+                                    },
+                                });
+                            }
+                        }
+                        // Body cells
+                        else {
+                            var isFooter = rowIndex === lastVisibleRowIndex;
+                            var stripeRowBackground = isOddRow
+                                ? parsedFirstBandColor
+                                : parsedSecondBandColor;
+                            var backgroundColor = isFooter
+                                ? footerColor !== null && footerColor !== void 0 ? footerColor : stripeRowBackground
+                                : stripeRowBackground;
+                            // Border
+                            var borders = isFooter
+                                ? footerBorder !== null && footerBorder !== void 0 ? footerBorder : firstBandBorder
+                                : firstBandBorder;
+                            var isEvenColumn = columnRunningIndex % 2 === 0;
+                            var finalBackgroundColor = (_b = (isEvenColumn
+                                ? parsedFirstBandColorColumn
+                                : parsedSecondBandColorColumn)) !== null && _b !== void 0 ? _b : backgroundColor;
+                            var textColor = isFooter
+                                ? footerColor !== null && footerColor !== void 0 ? footerColor : stripeRowBackground
+                                : (_c = parsedFirstBandColor !== null && parsedFirstBandColor !== void 0 ? parsedFirstBandColor : parsedSecondBandColor) !== null && _c !== void 0 ? _c : finalBackgroundColor;
+                            bandedCells.set(id, {
+                                borders: borders,
+                                backgroundColor: finalBackgroundColor,
+                                textFormat: {
+                                    color: textColor
+                                        ? (0, utils_1.getContrastColor)((0, themes_1.getStringifiedColor)(textColor, theme), (0, themes_1.getStringifiedColor)({ theme: 1 }, theme), (0, themes_1.getStringifiedColor)({ theme: 0 }, theme))
+                                        : undefined,
+                                },
+                            });
+                        }
+                        columnRunningIndex++;
+                    }
+                    rowRunningIndex++;
+                }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (bandedRanges_1_1 && !bandedRanges_1_1.done && (_a = bandedRanges_1.return)) _a.call(bandedRanges_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return bandedCells;
+};
+exports.getBandedCells = getBandedCells;
+/**
+ * Parse tinted color. returns undefined if tint >= 1
+ * @param color
+ * @returns
+ */
+var parseTintedColor = function (color) {
+    return typeof color === "object" && (color === null || color === void 0 ? void 0 : color.tint) === 1 ? undefined : color;
+};
+exports.parseTintedColor = parseTintedColor;
+/**
+ * Get last visible rowindex
+ * @param range
+ * @param isHidden
+ * @returns
+ */
+var getLastVisibleRowIndex = function (range, isHidden) {
+    var lastVisibleRowIndex = -1;
+    for (var rowIndex = range.startRowIndex; rowIndex <= range.endRowIndex; rowIndex++) {
+        if (isHidden(rowIndex)) {
+            continue;
+        }
+        lastVisibleRowIndex = rowIndex;
+    }
+    return lastVisibleRowIndex;
+};

package/dist/cjs/api/cf-engine.d.ts

@@ -0,0 +1,36 @@
+import type { ConditionalFormatRule } from "../types";
+/**
+ * Engine-evaluated aggregate conditional-format rules.
+ *
+ * The rust engine (rnc-store `derive.rs`) evaluates TOP/BOTTOM-N, DUPLICATE/
+ * UNIQUE, and above/below-average rules over each rule's FULL range and stamps
+ * `conditionalFormattingResultById[ruleId] = true` on every matching cell —
+ * the same per-cell result channel boolean/CUSTOM_FORMULA rules already use.
+ * When the host signals an engine-backed document
+ * (`engineConditionalFormatResults` on `CanvasGridProps`), the overlay reads
+ * those stamps instead of recomputing the aggregate from loaded window data —
+ * which is wrong on windowed large docs (the window only sees a slice of the
+ * range) and re-pays the O(range) scan per recompute.
+ */
+/**
+ * Mirror of the engine's `CF_DERIVE_MAX_CELLS`: rules covering more cells are
+ * NOT derived per-cell by the engine (no stamps exist), so the overlay must
+ * keep computing them itself. Keep in lockstep with
+ * `rust/crates/rnc-store/src/derive.rs`.
+ */
+export declare const ENGINE_CF_AGGREGATE_MAX_CELLS = 500000;
+/**
+ * Rules whose per-cell result depends on the range's OTHER covered values —
+ * rank (TOP/BOTTOM-N), occurrence counts (DUPLICATE/UNIQUE), and the range
+ * mean (NUMBER_ABOVE_AVERAGE / NUMBER_BELOW_AVERAGE).
+ */
+export declare const isAggregateConditionalFormatRule: (rule: ConditionalFormatRule) => boolean;
+/**
+ * Whether the engine derived per-cell stamps for `rule` — an aggregate rule
+ * within the engine's coverage cap. MUST be judged on the rule's ORIGINAL
+ * ranges (before `windowConditionalFormatRules` intersects them with the
+ * viewport), or an over-cap rule would look small enough once windowed and
+ * the overlay would read stamps the engine never wrote.
+ */
+export declare const isEngineEvaluatedAggregateRule: (rule: ConditionalFormatRule) => boolean;
+//# sourceMappingURL=cf-engine.d.ts.map

package/dist/cjs/api/cf-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cf-engine.d.ts","sourceRoot":"","sources":["../../../api/cf-engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtD;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,SAAU,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,GAC3C,MAAM,qBAAqB,KAC1B,OAQF,CAAC;AAaF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GACzC,MAAM,qBAAqB,KAC1B,OAKF,CAAC"}

package/dist/cjs/api/cf-engine.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEngineEvaluatedAggregateRule = exports.isAggregateConditionalFormatRule = exports.ENGINE_CF_AGGREGATE_MAX_CELLS = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Engine-evaluated aggregate conditional-format rules.
+ *
+ * The rust engine (rnc-store `derive.rs`) evaluates TOP/BOTTOM-N, DUPLICATE/
+ * UNIQUE, and above/below-average rules over each rule's FULL range and stamps
+ * `conditionalFormattingResultById[ruleId] = true` on every matching cell —
+ * the same per-cell result channel boolean/CUSTOM_FORMULA rules already use.
+ * When the host signals an engine-backed document
+ * (`engineConditionalFormatResults` on `CanvasGridProps`), the overlay reads
+ * those stamps instead of recomputing the aggregate from loaded window data —
+ * which is wrong on windowed large docs (the window only sees a slice of the
+ * range) and re-pays the O(range) scan per recompute.
+ */
+/**
+ * Mirror of the engine's `CF_DERIVE_MAX_CELLS`: rules covering more cells are
+ * NOT derived per-cell by the engine (no stamps exist), so the overlay must
+ * keep computing them itself. Keep in lockstep with
+ * `rust/crates/rnc-store/src/derive.rs`.
+ */
+exports.ENGINE_CF_AGGREGATE_MAX_CELLS = 500000;
+/**
+ * Rules whose per-cell result depends on the range's OTHER covered values —
+ * rank (TOP/BOTTOM-N), occurrence counts (DUPLICATE/UNIQUE), and the range
+ * mean (NUMBER_ABOVE_AVERAGE / NUMBER_BELOW_AVERAGE).
+ */
+var isAggregateConditionalFormatRule = function (rule) {
+    var _a, _b;
+    var conditionType = (_b = (_a = rule.booleanRule) === null || _a === void 0 ? void 0 : _a.condition) === null || _b === void 0 ? void 0 : _b.type;
+    return Boolean(rule.topBottomRule ||
+        rule.distinctRule ||
+        conditionType === "NUMBER_ABOVE_AVERAGE" ||
+        conditionType === "NUMBER_BELOW_AVERAGE");
+};
+exports.isAggregateConditionalFormatRule = isAggregateConditionalFormatRule;
+var ruleCoveredCells = function (rule) {
+    var e_1, _a;
+    var _b;
+    var total = 0;
+    try {
+        for (var _c = tslib_1.__values((_b = rule.ranges) !== null && _b !== void 0 ? _b : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var range = _d.value;
+            var rows = range.endRowIndex - range.startRowIndex + 1;
+            var columns = range.endColumnIndex - range.startColumnIndex + 1;
+            if (rows <= 0 || columns <= 0)
+                continue;
+            total += rows * columns;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return total;
+};
+/**
+ * Whether the engine derived per-cell stamps for `rule` — an aggregate rule
+ * within the engine's coverage cap. MUST be judged on the rule's ORIGINAL
+ * ranges (before `windowConditionalFormatRules` intersects them with the
+ * viewport), or an over-cap rule would look small enough once windowed and
+ * the overlay would read stamps the engine never wrote.
+ */
+var isEngineEvaluatedAggregateRule = function (rule) {
+    return ((0, exports.isAggregateConditionalFormatRule)(rule) &&
+        ruleCoveredCells(rule) <= exports.ENGINE_CF_AGGREGATE_MAX_CELLS);
+};
+exports.isEngineEvaluatedAggregateRule = isEngineEvaluatedAggregateRule;

package/dist/cjs/api/cf-overlays.d.ts

@@ -0,0 +1,7 @@
+import type { CfThreshold, IconSetFamily } from "../types";
+export declare const ICON_SET_GLYPHS: Record<IconSetFamily, string[]>;
+export declare const ICON_SET_COLORS: Record<IconSetFamily, string[]>;
+export declare const resolveThreshold: (threshold: CfThreshold, rangeMin: number, rangeMax: number) => number;
+export declare const pickIconBucket: (value: number, sortedThresholds: number[]) => number;
+export declare const computeDataBarFill: (value: number, min: number, max: number) => number;
+//# sourceMappingURL=cf-overlays.d.ts.map

package/dist/cjs/api/cf-overlays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cf-overlays.d.ts","sourceRoot":"","sources":["../../../api/cf-overlays.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE3D,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAqB3D,CAAC;AAIF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAkB3D,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAC3B,WAAW,WAAW,EACtB,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,MA6BF,CAAC;AAIF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,EAAE,kBAAkB,MAAM,EAAE,WAQvE,CAAC;AAKF,eAAO,MAAM,kBAAkB,GAC7B,OAAO,MAAM,EACb,KAAK,MAAM,EACX,KAAK,MAAM,KACV,MAWF,CAAC"}