@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/hooks/use-can-edit-cellrange.d.ts

@@ -0,0 +1,31 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import { type SheetProtectionAction } from "@rowsncolumns/spreadsheet";
+/** Error-state title shown when worksheet protection blocks an interaction. */
+export declare const SHEET_PROTECTION_ERROR_TITLE = "This sheet is protected";
+export declare const useCanEditSheet: () => (sheetId: number) => boolean;
+/**
+ * Workbook-level structural protection gate. Mirrors Excel's
+ * `workbookProtection lockStructure="1"`: when set, sheet-structural
+ * operations (add / delete / rename / move / duplicate / hide / show /
+ * tab color) are refused regardless of per-sheet protection.
+ *
+ * Cell-level edits are independently gated by `useCanEditCellRange` /
+ * `useCanEditSheet` — workbook protection only governs structure.
+ */
+export declare const useCanEditWorkbook: () => () => boolean;
+/**
+ * Granular worksheet-protection gate (`<sheetProtection>` action flags).
+ * Returns `(sheetId, action) => boolean` — `false` when the sheet's
+ * protection is active and prohibits the structural action (a flag set
+ * `true` prohibits, `false` allows, absent falls back to the OOXML default
+ * of prohibited; `mergeCells` is always prohibited while protected).
+ * Always `true` when the host supplies no protection lookup or the sheet is
+ * unprotected — so unprotected sheets behave exactly as before.
+ *
+ * Single-purpose: consult this ALONGSIDE `useCanEditSheet` /
+ * `useCanEditCellRange` (which cover whole-sheet protection and locked
+ * cells), not instead of them.
+ */
+export declare const useCanPerformSheetAction: () => (sheetId: number, action: SheetProtectionAction) => boolean;
+export declare const useCanEditCellRange: () => (sheetId: number, rangeOrCell: GridRange | CellInterface) => boolean;
+//# sourceMappingURL=use-can-edit-cellrange.d.ts.map

package/dist/cjs/hooks/use-can-edit-cellrange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-can-edit-cellrange.d.ts","sourceRoot":"","sources":["../../../hooks/use-can-edit-cellrange.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAEL,KAAK,qBAAqB,EAK3B,MAAM,2BAA2B,CAAC;AAMnC,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE,eAAO,MAAM,eAAe,kBAGd,MAAM,YASnB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,qBAS9B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,kBAGvB,MAAM,UAAU,qBAAqB,YAIlD,CAAC;AAEF,eAAO,MAAM,mBAAmB,kBAIlB,MAAM,eAAe,SAAS,GAAG,aAAa,YAkB3D,CAAC"}

package/dist/cjs/hooks/use-can-edit-cellrange.js

@@ -0,0 +1,86 @@
+import { __read, __values } from "tslib";
+import { isActionBlockedBySheetProtection, useCanEditCell, useGetSheetProtection, useIsSheetProtected, useIsWorkbookProtected, } from "@rowsncolumns/spreadsheet";
+import { convertCellToRange, iterateCellsInRange } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { isSelectionRange } from "../api/range";
+/** Error-state title shown when worksheet protection blocks an interaction. */
+export var SHEET_PROTECTION_ERROR_TITLE = "This sheet is protected";
+export var useCanEditSheet = function () {
+    var isSheetProtected = useIsSheetProtected();
+    return useCallback(function (sheetId) {
+        var isProtected = isSheetProtected === null || isSheetProtected === void 0 ? void 0 : isSheetProtected(sheetId);
+        if (isProtected) {
+            return false;
+        }
+        return true;
+    }, [isSheetProtected]);
+};
+/**
+ * Workbook-level structural protection gate. Mirrors Excel's
+ * `workbookProtection lockStructure="1"`: when set, sheet-structural
+ * operations (add / delete / rename / move / duplicate / hide / show /
+ * tab color) are refused regardless of per-sheet protection.
+ *
+ * Cell-level edits are independently gated by `useCanEditCellRange` /
+ * `useCanEditSheet` — workbook protection only governs structure.
+ */
+export var useCanEditWorkbook = function () {
+    var isWorkbookProtected = useIsWorkbookProtected();
+    return useCallback(function () {
+        var isProtected = isWorkbookProtected === null || isWorkbookProtected === void 0 ? void 0 : isWorkbookProtected();
+        if (isProtected) {
+            return false;
+        }
+        return true;
+    }, [isWorkbookProtected]);
+};
+/**
+ * Granular worksheet-protection gate (`<sheetProtection>` action flags).
+ * Returns `(sheetId, action) => boolean` — `false` when the sheet's
+ * protection is active and prohibits the structural action (a flag set
+ * `true` prohibits, `false` allows, absent falls back to the OOXML default
+ * of prohibited; `mergeCells` is always prohibited while protected).
+ * Always `true` when the host supplies no protection lookup or the sheet is
+ * unprotected — so unprotected sheets behave exactly as before.
+ *
+ * Single-purpose: consult this ALONGSIDE `useCanEditSheet` /
+ * `useCanEditCellRange` (which cover whole-sheet protection and locked
+ * cells), not instead of them.
+ */
+export var useCanPerformSheetAction = function () {
+    var getSheetProtection = useGetSheetProtection();
+    return useCallback(function (sheetId, action) {
+        return !isActionBlockedBySheetProtection(getSheetProtection === null || getSheetProtection === void 0 ? void 0 : getSheetProtection(sheetId), action);
+    }, [getSheetProtection]);
+};
+export var useCanEditCellRange = function () {
+    var canEditCell = useCanEditCell();
+    var canEditSheet = useCanEditSheet();
+    return useCallback(function (sheetId, rangeOrCell) {
+        var e_1, _a;
+        // If user cannot edit the sheet, early return
+        if (canEditSheet && !canEditSheet(sheetId)) {
+            return false;
+        }
+        // Check if to range is protected
+        var range = isSelectionRange(rangeOrCell)
+            ? rangeOrCell
+            : convertCellToRange(rangeOrCell);
+        try {
+            for (var _b = __values(iterateCellsInRange(range)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), rowIndex = _d[0], columnIndex = _d[1];
+                if (canEditCell && !(canEditCell === null || canEditCell === void 0 ? void 0 : canEditCell(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }))) {
+                    return false;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return true;
+    }, [canEditCell, canEditSheet]);
+};

package/dist/cjs/hooks/use-cellxfs-registry.d.ts

@@ -0,0 +1,6 @@
+import { type Dispatch, type SetStateAction } from "react";
+import { CellXfsRegistry } from "../cellxfs-registry";
+import type { CellXfs } from "../types";
+export { CellXfsRegistry } from "../cellxfs-registry";
+export declare const useCellXfsRegistry: (cellXfs: CellXfs | undefined | null, onChangeCellXfs?: Dispatch<SetStateAction<CellXfs | undefined | null>>) => CellXfsRegistry;
+//# sourceMappingURL=use-cellxfs-registry.d.ts.map

package/dist/cjs/hooks/use-cellxfs-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cellxfs-registry.d.ts","sourceRoot":"","sources":["../../../hooks/use-cellxfs-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EAGpB,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,eAAO,MAAM,kBAAkB,GAC7B,SAAS,OAAO,GAAG,SAAS,GAAG,IAAI,EACnC,kBAAkB,QAAQ,CAAC,cAAc,CAAC,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC,oBAwBvE,CAAC"}

package/dist/cjs/hooks/use-cellxfs-registry.js

@@ -0,0 +1,22 @@
+import { useCallback, useRef, } from "react";
+import { CellXfsRegistry } from "../cellxfs-registry";
+export { CellXfsRegistry } from "../cellxfs-registry";
+export var useCellXfsRegistry = function (cellXfs, onChangeCellXfs) {
+    var cellXfsRegistryRef = useRef(undefined);
+    var getCellXfsRegistry = useCallback(function () {
+        if (!cellXfsRegistryRef.current) {
+            cellXfsRegistryRef.current = new CellXfsRegistry(cellXfs, onChangeCellXfs);
+        }
+        return cellXfsRegistryRef.current;
+    }, []);
+    var cellXfsRegistry = getCellXfsRegistry();
+    // Sync the registry's internal `cellXfs` synchronously during render, NOT
+    // in a layout effect. The renderer calls `getDerivedFormat` during the
+    // grid's `cells` useMemo (render phase) which resolves `uf.sid` through
+    // the registry — a layout-effect sync would leave the registry pointing
+    // at the previous `cellXfs` for that lookup, so newly-registered styles
+    // would resolve to `undefined` and a formula cell's derived format would
+    // be stuck stale until the next render.
+    cellXfsRegistry.setCellXfs(cellXfs);
+    return cellXfsRegistry;
+};

package/dist/cjs/hooks/use-citations.d.ts

@@ -0,0 +1,19 @@
+import type { Citation } from "@rowsncolumns/common-types";
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseCitationsProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    onChangeCitations: UseSpreadsheetProps<T, S>["onChangeCitations"];
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+};
+export declare const useCitations: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, onChangeCitations, createHistory, }: UseCitationsProps<T, S>) => {
+    onCreateCitation: (sheetId: number, rowIndex: number, columnIndex: number, citation: Citation) => void;
+    onCreateBatchCitations: (citations: Citation[]) => void;
+    onUpdateCitation: (citationId: string, updates: Partial<Omit<Citation, "id">>) => void;
+    onRemoveCitationFromCell: (sheetId: number, rowIndex: number, columnIndex: number) => void;
+    onDeleteCitation: (citationId: string) => void;
+};
+export {};
+//# sourceMappingURL=use-citations.d.ts.map

package/dist/cjs/hooks/use-citations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-citations.d.ts","sourceRoot":"","sources":["../../../hooks/use-citations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAUjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC1D,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,kEAK/D,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;gCAMX,MAAM,YACL,MAAM,eACH,MAAM,YACT,QAAQ;wCAiBR,QAAQ,EAAE;mCAaT,MAAM,WAAW,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;wCAajD,MAAM,YAAY,MAAM,eAAe,MAAM;mCAc1C,MAAM;CAgBtB,CAAC"}

package/dist/cjs/hooks/use-citations.js

@@ -0,0 +1,62 @@
+import { useCallback } from "react";
+import { createBatchCitations, createCitation, deleteCitation, removeCitationFromCell, updateCitation, } from "../interface/citations";
+export var useCitations = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeCitations = _a.onChangeCitations, createHistory = _a.createHistory;
+    /**
+     * Create a new citation and attach it to a cell
+     */
+    var onCreateCitation = useCallback(function (sheetId, rowIndex, columnIndex, citation) {
+        if (!createHistory)
+            return;
+        createCitation({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            onChangeCitations: onChangeCitations,
+            createHistory: createHistory,
+        })(sheetId, rowIndex, columnIndex, citation);
+    }, [locale, onChangeSheetData, onChangeCitations, createHistory]);
+    /**
+     * Create multiple citations in a batch (adds to citations array only)
+     */
+    var onCreateBatchCitations = useCallback(function (citations) {
+        createBatchCitations({
+            onChangeCitations: onChangeCitations,
+            createHistory: createHistory,
+        })(citations);
+    }, [onChangeCitations, createHistory]);
+    /**
+     * Update an existing citation
+     */
+    var onUpdateCitation = useCallback(function (citationId, updates) {
+        updateCitation({
+            onChangeCitations: onChangeCitations,
+            createHistory: createHistory,
+        })(citationId, updates);
+    }, [onChangeCitations, createHistory]);
+    /**
+     * Remove a citation from a cell
+     */
+    var onRemoveCitationFromCell = useCallback(function (sheetId, rowIndex, columnIndex) {
+        removeCitationFromCell({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            createHistory: createHistory,
+        })(sheetId, rowIndex, columnIndex);
+    }, [locale, onChangeSheetData, createHistory]);
+    /**
+     * Delete a citation completely (removes from array and from all cells)
+     */
+    var onDeleteCitation = useCallback(function (citationId) {
+        deleteCitation({
+            onChangeCitations: onChangeCitations,
+            createHistory: createHistory,
+        })(citationId);
+    }, [onChangeCitations, createHistory]);
+    return {
+        onCreateCitation: onCreateCitation,
+        onCreateBatchCitations: onCreateBatchCitations,
+        onUpdateCitation: onUpdateCitation,
+        onRemoveCitationFromCell: onRemoveCitationFromCell,
+        onDeleteCitation: onDeleteCitation,
+    };
+};

package/dist/cjs/hooks/use-comments.d.ts

@@ -0,0 +1,14 @@
+import type { CellData, Sheet } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+type UseCommentsProps<T extends CellData, S extends Sheet> = {
+    locale?: string;
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    createHistory?: () => (patches: SpreadsheetPatch) => void;
+};
+export declare const useComments: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, createHistory, }: UseCommentsProps<T, S>) => {
+    onInsertComment: (sheetId: number, rowIndex: number, columnIndex: number, commentThreadId: string | number | undefined) => void;
+    onRemoveComment: (sheetId: number, rowIndex: number, columnIndex: number) => void;
+};
+export {};
+//# sourceMappingURL=use-comments.d.ts.map

package/dist/cjs/hooks/use-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-comments.d.ts","sourceRoot":"","sources":["../../../hooks/use-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAMjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,KAAK,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,+CAI9D,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;+BAGV,MAAM,YACL,MAAM,eACH,MAAM,mBACF,MAAM,GAAG,MAAM,GAAG,SAAS;+BA8BpC,MAAM,YAAY,MAAM,eAAe,MAAM;CA6B1D,CAAC"}

package/dist/cjs/hooks/use-comments.js

@@ -0,0 +1,49 @@
+import { __read } from "tslib";
+import { produceWithPatches } from "immer";
+import { useCallback } from "react";
+import { createSheetDraft } from "../api/immer-utils";
+import { SheetCell } from "../sheet-cell";
+export var useComments = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, createHistory = _a.createHistory;
+    var onInsertComment = useCallback(function (sheetId, rowIndex, columnIndex, commentThreadId) {
+        var saveHistory = createHistory === null || createHistory === void 0 ? void 0 : createHistory();
+        var sheetCell = new SheetCell();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                var cellData = (_a = currentSheet[rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                    locale: locale,
+                });
+                sheetCell.updateCommentThreadId(commentThreadId);
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    }, [locale, onChangeSheetData, createHistory]);
+    var onRemoveComment = useCallback(function (sheetId, rowIndex, columnIndex) {
+        var saveHistory = createHistory === null || createHistory === void 0 ? void 0 : createHistory();
+        var sheetCell = new SheetCell();
+        onChangeSheetData === null || onChangeSheetData === void 0 ? void 0 : onChangeSheetData(function (prevSheetData) {
+            var _a = __read(produceWithPatches(prevSheetData, function (draft) {
+                var _a;
+                var currentSheet = createSheetDraft(draft, sheetId, rowIndex);
+                var cellData = (_a = currentSheet[rowIndex].values) === null || _a === void 0 ? void 0 : _a[columnIndex];
+                sheetCell.assign(sheetId, { rowIndex: rowIndex, columnIndex: columnIndex }, cellData, {
+                    locale: locale,
+                });
+                sheetCell.clearCommentThreadId();
+                currentSheet[rowIndex].values[columnIndex] = sheetCell.getCellData();
+            }), 3), nextState = _a[0], patches = _a[1], inversePatches = _a[2];
+            saveHistory === null || saveHistory === void 0 ? void 0 : saveHistory({
+                sheetData: { patches: patches, inversePatches: inversePatches },
+            });
+            return nextState;
+        });
+    }, [locale, onChangeSheetData, createHistory]);
+    return { onInsertComment: onInsertComment, onRemoveComment: onRemoveComment };
+};

package/dist/cjs/hooks/use-conditional-formatting-rules.d.ts

@@ -0,0 +1,22 @@
+import type { ConditionalFormatRule } from "@rowsncolumns/spreadsheet";
+import type { useCalculation } from "./use-calculation";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseConditionalFormattingRulesProps = {
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    /**
+     * Create a new history
+     * @returns
+     */
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    /**
+     * Callback to update conditional formatting
+     */
+    onChangeConditionalFormats?: React.Dispatch<React.SetStateAction<ConditionalFormatRule[]>>;
+};
+export declare const useConditionalFormattingRules: ({ enqueueCalculation, createHistory, onChangeConditionalFormats, }: UseConditionalFormattingRulesProps) => {
+    onCreateConditionalFormattingRule: (rule: ConditionalFormatRule) => void;
+    onUpdateConditionalFormattingRule: (updatedRule: ConditionalFormatRule, previousRule: ConditionalFormatRule) => void;
+    onDeleteConditionalFormattingRule: (rule: ConditionalFormatRule) => void;
+    onPreviewConditionalFormattingRule: (rule: ConditionalFormatRule) => void;
+};
+//# sourceMappingURL=use-conditional-formatting-rules.d.ts.map

package/dist/cjs/hooks/use-conditional-formatting-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conditional-formatting-rules.d.ts","sourceRoot":"","sources":["../../../hooks/use-conditional-formatting-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAUvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAcxD,MAAM,MAAM,kCAAkC,GAAG;IAC/C,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD;;OAEG;IACH,0BAA0B,CAAC,EAAE,KAAK,CAAC,QAAQ,CACzC,KAAK,CAAC,cAAc,CAAC,qBAAqB,EAAE,CAAC,CAC9C,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAI,oEAI3C,kCAAkC;8CAK1B,qBAAqB;qDAwBb,qBAAqB,gBACpB,qBAAqB;8CA2B9B,qBAAqB;+CAuBrB,qBAAqB;CAgB/B,CAAC"}

package/dist/cjs/hooks/use-conditional-formatting-rules.js

@@ -0,0 +1,95 @@
+import { __values } from "tslib";
+import { useCallback } from "react";
+import { createConditionalFormattingRule, deleteConditionalFormattingRule, previewConditionalFormattingRule, updateConditionalFormattingRule, } from "../interface/conditional-formatting-rules";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+// CF rules carry one or more ranges; each range names a sheetId. A
+// rule is editable only if EVERY sheet it touches is editable.
+var ruleSheetsEditable = function (rule, canEditSheet) {
+    var e_1, _a;
+    var _b;
+    try {
+        for (var _c = __values((_b = rule.ranges) !== null && _b !== void 0 ? _b : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var range = _d.value;
+            if (!canEditSheet(range.sheetId))
+                return false;
+        }
+    }
+    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 true;
+};
+export var useConditionalFormattingRules = function (_a) {
+    var enqueueCalculation = _a.enqueueCalculation, createHistory = _a.createHistory, onChangeConditionalFormats = _a.onChangeConditionalFormats;
+    var canEditSheet = useCanEditSheet();
+    // Create new rule
+    var onCreateConditionalFormattingRule = useCallback(function (rule) {
+        if (!ruleSheetsEditable(rule, canEditSheet)) {
+            console.debug("Cannot create conditional formatting rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        createConditionalFormattingRule({
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+        })(rule);
+    }, [
+        createHistory,
+        enqueueCalculation,
+        onChangeConditionalFormats,
+        canEditSheet,
+    ]);
+    // Update an existing rule
+    var onUpdateConditionalFormattingRule = useCallback(function (updatedRule, previousRule) {
+        if (!ruleSheetsEditable(previousRule, canEditSheet) ||
+            !ruleSheetsEditable(updatedRule, canEditSheet)) {
+            console.debug("Cannot update conditional formatting rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        updateConditionalFormattingRule({
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+        })(updatedRule, previousRule);
+    }, [
+        createHistory,
+        onChangeConditionalFormats,
+        enqueueCalculation,
+        canEditSheet,
+    ]);
+    // Delete conditional formatting
+    var onDeleteConditionalFormattingRule = useCallback(function (rule) {
+        if (!ruleSheetsEditable(rule, canEditSheet)) {
+            console.debug("Cannot delete conditional formatting rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        deleteConditionalFormattingRule({
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+        })(rule);
+    }, [
+        enqueueCalculation,
+        onChangeConditionalFormats,
+        createHistory,
+        canEditSheet,
+    ]);
+    // on Preview conditional formatting — non-destructive, no gate
+    var onPreviewConditionalFormattingRule = useCallback(function (rule) {
+        previewConditionalFormattingRule({
+            enqueueCalculation: enqueueCalculation,
+            createHistory: createHistory,
+            onChangeConditionalFormats: onChangeConditionalFormats,
+        })(rule);
+    }, [enqueueCalculation, createHistory, onChangeConditionalFormats]);
+    return {
+        onCreateConditionalFormattingRule: onCreateConditionalFormattingRule,
+        onUpdateConditionalFormattingRule: onUpdateConditionalFormattingRule,
+        onDeleteConditionalFormattingRule: onDeleteConditionalFormattingRule,
+        onPreviewConditionalFormattingRule: onPreviewConditionalFormattingRule,
+    };
+};

package/dist/cjs/hooks/use-data-validation-rules.d.ts

@@ -0,0 +1,54 @@
+import type { useGetEffectiveValuesFromRange } from "@rowsncolumns/spreadsheet";
+import { type CellData, type DataValidationRuleRecord, type Sheet } from "@rowsncolumns/spreadsheet";
+import type { CellXfsRegistry } from "../cellxfs-registry";
+import { type CreateDataValidationRuleOptions } from "../interface/data-validation-rules";
+import type { SharedStringRegistry } from "../shared-string-registry";
+import type { useCalculation } from "./use-calculation";
+import type { UseSpreadsheetProps } from "./use-spreadsheet-state";
+import type { SpreadsheetPatch } from "./use-undo-redo";
+export type UseDataValidationRuleProps<T extends CellData, S extends Sheet> = {
+    /**
+     * Current locale
+     */
+    locale?: string;
+    /**
+     * Queue up for calculation
+     */
+    enqueueCalculation: ReturnType<typeof useCalculation>["enqueueCalculation"];
+    /**
+     * Create a new history
+     * @returns
+     */
+    createHistory: () => (patches: SpreadsheetPatch) => void;
+    /**
+     * Callback to update conditional formatting
+     */
+    onChangeDataValidations?: React.Dispatch<React.SetStateAction<DataValidationRuleRecord[]>>;
+    /**
+     * Validation rules are attached to cells
+     */
+    onChangeSheetData: UseSpreadsheetProps<T, S>["onChangeSheetData"];
+    /**
+     * Get effective values from range
+     */
+    getEffectiveValuesFromRange?: ReturnType<typeof useGetEffectiveValuesFromRange>;
+    getSheetName(sheetId: number): string;
+    /**
+     * Style registry — required to round-trip `uf: { sid }` style references
+     * when stamping/clearing data validation on cells. Without it, the cell's
+     * `uf` is dropped on write.
+     */
+    cellXfsRegistry?: CellXfsRegistry;
+    /**
+     * Shared-string registry — paired with `cellXfsRegistry` for the same
+     * round-trip reason on `ss` rich-text references.
+     */
+    sharedStringRegistry?: SharedStringRegistry;
+};
+export declare const useDataValidationRules: <T extends CellData, S extends Sheet>({ locale, onChangeSheetData, onChangeDataValidations, createHistory, enqueueCalculation, getEffectiveValuesFromRange, getSheetName, cellXfsRegistry, sharedStringRegistry, }: UseDataValidationRuleProps<T, S>) => {
+    onCreateDataValidationRule: (rule: DataValidationRuleRecord, options?: CreateDataValidationRuleOptions) => void;
+    onUpdateDataValidationRule: (rule: DataValidationRuleRecord, previousRule: DataValidationRuleRecord) => void;
+    onDeleteDataValidationRule: (rule: DataValidationRuleRecord) => void;
+    onDeleteDataValidationRules: (rules: DataValidationRuleRecord[]) => void;
+};
+//# sourceMappingURL=use-data-validation-rules.d.ts.map

package/dist/cjs/hooks/use-data-validation-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-data-validation-rules.d.ts","sourceRoot":"","sources":["../../../hooks/use-data-validation-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAChF,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,wBAAwB,EAC7B,KAAK,KAAK,EACX,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EACL,KAAK,+BAA+B,EAKrC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAexD,MAAM,MAAM,0BAA0B,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,IAAI;IAC5E;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,kBAAkB,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,oBAAoB,CAAC,CAAC;IAC5E;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACzD;;OAEG;IACH,uBAAuB,CAAC,EAAE,KAAK,CAAC,QAAQ,CACtC,KAAK,CAAC,cAAc,CAAC,wBAAwB,EAAE,CAAC,CACjD,CAAC;IACF;;OAEG;IACH,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC;IAClE;;OAEG;IACH,2BAA2B,CAAC,EAAE,UAAU,CACtC,OAAO,8BAA8B,CACtC,CAAC;IACF,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC;;;;OAIG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,KAAK,EAAE,8KAUzE,0BAA0B,CAAC,CAAC,EAAE,CAAC,CAAC;uCAMvB,wBAAwB,YACpB,+BAA+B;uCAqCnC,wBAAwB,gBAChB,wBAAwB;uCA8EjC,wBAAwB;yCAvCvB,wBAAwB,EAAE;CAwErC,CAAC"}

package/dist/cjs/hooks/use-data-validation-rules.js

@@ -0,0 +1,151 @@
+import { __values } from "tslib";
+import { useCallback } from "react";
+import { createDataValidationRule, deleteDataValidationRule, deleteDataValidationRules, updateDataValidationRule, } from "../interface/data-validation-rules";
+import { useCanEditSheet } from "./use-can-edit-cellrange";
+// DV rules are anchored to one or more ranges; each range names a
+// sheetId. A rule is editable only if EVERY sheet it touches is
+// editable.
+var dvRuleSheetsEditable = function (rule, canEditSheet) {
+    var e_1, _a;
+    var _b;
+    try {
+        for (var _c = __values((_b = rule.ranges) !== null && _b !== void 0 ? _b : []), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var range = _d.value;
+            if (!canEditSheet(range.sheetId))
+                return false;
+        }
+    }
+    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 true;
+};
+export var useDataValidationRules = function (_a) {
+    var locale = _a.locale, onChangeSheetData = _a.onChangeSheetData, onChangeDataValidations = _a.onChangeDataValidations, createHistory = _a.createHistory, enqueueCalculation = _a.enqueueCalculation, getEffectiveValuesFromRange = _a.getEffectiveValuesFromRange, getSheetName = _a.getSheetName, cellXfsRegistry = _a.cellXfsRegistry, sharedStringRegistry = _a.sharedStringRegistry;
+    var canEditSheet = useCanEditSheet();
+    // Create new rule
+    var onCreateDataValidationRule = useCallback(function (rule, options) {
+        if (!(options === null || options === void 0 ? void 0 : options.importSource) && !dvRuleSheetsEditable(rule, canEditSheet)) {
+            console.debug("Cannot create data validation rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        createDataValidationRule({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            onChangeDataValidations: onChangeDataValidations,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+            getSheetName: getSheetName,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+        })(rule, options);
+    }, [
+        locale,
+        getEffectiveValuesFromRange,
+        enqueueCalculation,
+        createHistory,
+        onChangeSheetData,
+        onChangeDataValidations,
+        getSheetName,
+        canEditSheet,
+        cellXfsRegistry,
+        sharedStringRegistry,
+    ]);
+    // Update existing rule
+    var onUpdateDataValidationRule = useCallback(function (rule, previousRule) {
+        if (!dvRuleSheetsEditable(rule, canEditSheet) ||
+            !dvRuleSheetsEditable(previousRule, canEditSheet)) {
+            console.debug("Cannot update data validation rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        updateDataValidationRule({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            onChangeDataValidations: onChangeDataValidations,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            getEffectiveValuesFromRange: getEffectiveValuesFromRange,
+            getSheetName: getSheetName,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+        })(rule, previousRule);
+    }, [
+        locale,
+        getEffectiveValuesFromRange,
+        enqueueCalculation,
+        createHistory,
+        onChangeSheetData,
+        onChangeDataValidations,
+        getSheetName,
+        canEditSheet,
+        cellXfsRegistry,
+        sharedStringRegistry,
+    ]);
+    // Remove all rules
+    var onDeleteDataValidationRules = useCallback(function (rules) {
+        // Filter out rules whose sheets are protected. Bulk delete
+        // skips them silently rather than aborting the whole call —
+        // that matches Excel, which only blocks the protected ones.
+        var allowed = rules.filter(function (r) {
+            return dvRuleSheetsEditable(r, canEditSheet);
+        });
+        if (allowed.length === 0) {
+            console.debug("Cannot delete data validation rules — all are on protected sheets.");
+            return;
+        }
+        deleteDataValidationRules({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            onChangeDataValidations: onChangeDataValidations,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            getSheetName: getSheetName,
+            cellXfsRegistry: cellXfsRegistry,
+            sharedStringRegistry: sharedStringRegistry,
+        })(allowed);
+    }, [
+        locale,
+        enqueueCalculation,
+        onChangeSheetData,
+        onChangeDataValidations,
+        createHistory,
+        getSheetName,
+        canEditSheet,
+        cellXfsRegistry,
+        sharedStringRegistry,
+    ]);
+    // Delete single rule
+    var onDeleteDataValidationRule = useCallback(function (rule) {
+        if (!dvRuleSheetsEditable(rule, canEditSheet)) {
+            console.debug("Cannot delete data validation rule — one of its ranges is on a protected sheet.");
+            return;
+        }
+        deleteDataValidationRule({
+            locale: locale,
+            onChangeSheetData: onChangeSheetData,
+            onChangeDataValidations: onChangeDataValidations,
+            createHistory: createHistory,
+            enqueueCalculation: enqueueCalculation,
+            getSheetName: getSheetName,
+        })(rule);
+    }, [
+        locale,
+        enqueueCalculation,
+        onChangeSheetData,
+        onChangeDataValidations,
+        canEditSheet,
+        createHistory,
+        getSheetName,
+    ]);
+    return {
+        onCreateDataValidationRule: onCreateDataValidationRule,
+        onUpdateDataValidationRule: onUpdateDataValidationRule,
+        onDeleteDataValidationRule: onDeleteDataValidationRule,
+        onDeleteDataValidationRules: onDeleteDataValidationRules,
+    };
+};