@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/hooks/use-keyboard-handler.js

@@ -0,0 +1,472 @@
+import { Direction, selectionFromActiveCell } from "@rowsncolumns/grid";
+import { getLongDateFormat } from "@rowsncolumns/utils";
+import { useCallback } from "react";
+import { useCallbackRef } from "./use-callback-ref";
+export const useKeyboardHandler = ({ sheetId, locale, selectedRows, selectedColumns, showFormulas, defaultFontSizePoint, onShowFormulas, onChangeFormatting, onRepeatFormatting, onClearFormatting, onSelectNextSheet, onSelectPreviousSheet, onCreateNewSheet, onFillRange, disableFillRightShortcut, 
+// Inserts
+onInsertTime, onInsertDate, onInsertDateTime, onInsertNote, onInsertAutoSum, onRedo, onUndo, onRequestSearch, onRequestReplace, onRequestFormatCells, onRequestInsertComment, onRequestInsertLink, onCreateTable, onCreateBasicFilter, clearCopiedSelections, getCellFormat, onShowContextMenu, onHideColumn, onGroupColumns, onUngroupColumns, 
+// Rows
+onHideRow, onGroupRows, onUngroupRows, onDeleteRow, onInsertRow, 
+// Quick edit
+onAddQuickEdit, canEditCell, isSheetFocused, activeCell, selections, }) => {
+    return useCallbackRef(useCallback((e) => {
+        const isCtrl = e.ctrlKey; // Ctrl
+        const isMeta = e.metaKey || (!e.metaKey && e.ctrlKey); // Command
+        const isShift = e.shiftKey; // Shift
+        const isAlt = e.altKey; // option
+        const key = e.key;
+        const code = e.code;
+        const longDateFormat = getLongDateFormat(locale);
+        const currencySymbol = "$";
+        const { rowIndex, columnIndex } = activeCell;
+        // Alt+Shift+Arrow: Excel-style group / ungroup. Right = group,
+        // Left = ungroup. The axis (row vs column) is derived from the
+        // current selection — whichever dimension is fully selected.
+        if (isAlt && isShift && !isMeta) {
+            if (code === "ArrowRight" || code === "ArrowLeft") {
+                const rowIds = Object.keys(selectedRows).map(Number);
+                const colIds = Object.keys(selectedColumns).map(Number);
+                const isGroup = code === "ArrowRight";
+                if (rowIds.length > 0) {
+                    if (isGroup)
+                        onGroupRows?.(sheetId, rowIds);
+                    else
+                        onUngroupRows?.(sheetId, rowIds);
+                    e.preventDefault();
+                    return;
+                }
+                if (colIds.length > 0) {
+                    if (isGroup)
+                        onGroupColumns?.(sheetId, colIds);
+                    else
+                        onUngroupColumns?.(sheetId, colIds);
+                    e.preventDefault();
+                    return;
+                }
+            }
+        }
+        // Allow certain navigation and non-editing operations
+        if (isMeta) {
+            // Cmd/Ctrl + Option/Alt + M
+            if (isAlt && code === "KeyM") {
+                onRequestInsertComment?.(sheetId, activeCell);
+                e.preventDefault();
+                return;
+            }
+            switch (key) {
+                // Cmd/Ctrl + PageDown
+                case "PageDown":
+                    onSelectNextSheet?.(sheetId);
+                    e.preventDefault();
+                    return;
+                // Cmd/Ctrl + PageUp
+                case "PageUp":
+                    onSelectPreviousSheet?.(sheetId);
+                    e.preventDefault();
+                    return;
+                // Cmd/Ctrl + J
+                case "j": {
+                    const selection = selections.length
+                        ? selections[0]
+                        : selectionFromActiveCell(activeCell)[0];
+                    if (selection) {
+                        onAddQuickEdit?.({
+                            ...selection.range,
+                            sheetId,
+                        });
+                    }
+                    break;
+                }
+                // Cmd/Ctrl + Z (Shift for redo). preventDefault so the
+                // browser's document-level historyUndo doesn't also fire and
+                // pop edits made in other editable hosts on the page.
+                case "z":
+                    if (isShift) {
+                        onRedo?.();
+                    }
+                    else {
+                        onUndo?.();
+                    }
+                    e.preventDefault();
+                    return;
+                // Cmd/Ctrl + Y
+                case "y":
+                    onRedo?.();
+                    e.preventDefault();
+                    return;
+                // Cmd/Ctrl + F
+                case "f":
+                    if (!isShift) {
+                        onRequestSearch?.();
+                        e.preventDefault();
+                    }
+                    return;
+                // Cmd/Ctrl + H — Find & Replace
+                case "h":
+                    if (!isShift) {
+                        onRequestReplace?.();
+                        e.preventDefault();
+                    }
+                    return;
+                // Cmd/Ctrl + K — Insert link
+                case "k":
+                    if (!isShift) {
+                        onRequestInsertLink?.(sheetId, activeCell, selections);
+                        e.preventDefault();
+                    }
+                    return;
+            }
+        }
+        if (isAlt) {
+            switch (key) {
+                // Option/Alt + ArrowUp
+                case "ArrowUp":
+                    onSelectPreviousSheet?.(sheetId);
+                    e.preventDefault();
+                    return;
+                // Option/Alt + ArrowDown
+                case "ArrowDown":
+                    onSelectNextSheet?.(sheetId);
+                    e.preventDefault();
+                    return;
+            }
+        }
+        if (isShift) {
+            switch (key) {
+                // Shift + F10
+                case "F10":
+                    onShowContextMenu?.(activeCell);
+                    return;
+                // Shift + F11
+                case "F11":
+                    onCreateNewSheet?.();
+                    return;
+            }
+        }
+        // Escape
+        if (key === "Escape") {
+            clearCopiedSelections();
+            return;
+        }
+        // Early return if cell cannot be edited for formatting operations
+        if (!canEditCell(sheetId, activeCell)) {
+            return;
+            // Block all other operations for non-editable cells
+        }
+        // Default border
+        // TODO @vinay, Use selected border color
+        const border = {
+            width: 1,
+            style: "solid",
+            color: { theme: 1 },
+        };
+        if (isMeta) {
+            switch (key) {
+                // Cmd/Ctrl + B
+                case "b":
+                    onChangeFormatting?.(sheetId, activeCell, selections, "textFormat", {
+                        bold: !getCellFormat?.(sheetId, rowIndex, columnIndex)
+                            ?.textFormat?.bold,
+                    });
+                    e.preventDefault();
+                    break;
+                // Cmd/Ctrl + I
+                case "i":
+                    if (!isShift) {
+                        onChangeFormatting?.(sheetId, activeCell, selections, "textFormat", {
+                            italic: !getCellFormat?.(sheetId, rowIndex, columnIndex)
+                                ?.textFormat?.italic,
+                        });
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + U
+                case "u":
+                    onChangeFormatting?.(sheetId, activeCell, selections, "textFormat", {
+                        underline: !getCellFormat?.(sheetId, rowIndex, columnIndex)
+                            ?.textFormat?.underline,
+                    });
+                    e.preventDefault();
+                    break;
+                // Cmd/Ctrl + Shift + X
+                case "x":
+                    if (isShift) {
+                        onChangeFormatting?.(sheetId, activeCell, selections, "textFormat", {
+                            strikethrough: !getCellFormat?.(sheetId, rowIndex, columnIndex)?.textFormat?.strikethrough,
+                        });
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + \
+                case "\\":
+                    onClearFormatting?.(sheetId, activeCell, selections);
+                    e.preventDefault();
+                    break;
+                // Cmd/Ctrl + Enter
+                case "Enter":
+                    onFillRange?.(sheetId, activeCell, selections);
+                    break;
+                // Cmd/Ctrl + D
+                case "d":
+                    onFillRange?.(sheetId, activeCell, selections, Direction.Down);
+                    e.preventDefault();
+                    break;
+                // Cmd/Ctrl + ;
+                case ";":
+                    e.preventDefault();
+                    if (isShift) {
+                        onInsertTime?.(sheetId, activeCell, selections);
+                    }
+                    else {
+                        onInsertDate?.(sheetId, activeCell, selections);
+                    }
+                    break;
+                // Cmd/Ctrl + Shift + L/E/R (or Cmd/Ctrl + R for fill right)
+                case "l":
+                case "e":
+                case "r":
+                    if (isShift) {
+                        const alignment = key === "l" ? "left" : key === "e" ? "center" : "right";
+                        onChangeFormatting?.(sheetId, activeCell, selections, "horizontalAlignment", alignment);
+                        e.preventDefault();
+                    }
+                    else if (key === "r") {
+                        if (disableFillRightShortcut) {
+                            return;
+                        }
+                        // Fill right
+                        // We have to be smart to not interfere with reload
+                        // keyboard shortcut
+                        if (onFillRange) {
+                            onFillRange?.(sheetId, activeCell, selections, Direction.Right);
+                            // Prevent browser reload if the sheet is focused
+                            if (activeCell && isSheetFocused()) {
+                                e.preventDefault();
+                            }
+                        }
+                        break;
+                    }
+                    break;
+                // Cmd/Ctrl + Option/Alt + †
+                case "†":
+                    if (isAlt) {
+                        onCreateTable?.(sheetId, activeCell, selections, undefined, "TableStyleLight1");
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + Shift + , or .
+                case ",":
+                case ".":
+                    if (isShift) {
+                        const fontSize = getCellFormat?.(sheetId, rowIndex, columnIndex)?.textFormat
+                            ?.fontSize ?? defaultFontSizePoint;
+                        onChangeFormatting?.(sheetId, activeCell, selections, "textFormat", {
+                            fontSize: Number(fontSize) + (key === "," ? -1 : 1),
+                        });
+                    }
+                    break;
+                // Cmd/Ctrl + Shift + -
+                case "-":
+                    if (isShift) {
+                        onDeleteRow?.(sheetId, [rowIndex]);
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + Shift + =
+                case "=":
+                    if (isShift) {
+                        onInsertRow?.(sheetId, rowIndex, 1);
+                        e.preventDefault();
+                    }
+                    break;
+            }
+            // Digiits
+            switch (code) {
+                // Cmd/Ctrl + Option/Alt + 1
+                case "Digit1":
+                    if (isAlt) {
+                        onRequestFormatCells?.(sheetId, activeCell, selections);
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + Option/Alt + 9
+                case "Digit9":
+                    // TODO @vinay
+                    // Handle unhide rows onShift key press
+                    if (isAlt) {
+                        onHideRow?.(sheetId, Object.keys(selectedRows).map(Number));
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + Option/Alt + 0
+                case "Digit0":
+                    // TODO @vinay
+                    // Handle unhide column onShift key press
+                    if (isAlt) {
+                        onHideColumn?.(sheetId, Object.keys(selectedColumns).map(Number));
+                    }
+                    break;
+                // Cmd/Ctrl + `
+                case "Backquote":
+                    onShowFormulas?.(sheetId, !showFormulas);
+                    break;
+            }
+        }
+        // Alt key is pressed
+        if (isAlt) {
+            // Digits
+            switch (code) {
+                // Option/Alt + Shift + 1/2/3/4
+                case "Digit1":
+                case "Digit2":
+                case "Digit3":
+                case "Digit4":
+                    if (isShift) {
+                        const borders = code === "Digit1"
+                            ? { top: border }
+                            : code === "Digit2"
+                                ? { right: border }
+                                : code === "Digit3"
+                                    ? { bottom: border }
+                                    : { left: border };
+                        onChangeFormatting?.(sheetId, activeCell, selections, "borders", borders);
+                    }
+                    break;
+                // Option/Alt + Shift + 6
+                case "Digit6":
+                    if (isShift) {
+                        onChangeFormatting?.(sheetId, activeCell, selections, "borders", undefined);
+                    }
+                    break;
+                // Option/Alt + Shift + 7
+                case "Digit7":
+                    if (isShift) {
+                        onChangeFormatting?.(sheetId, activeCell, selections, "borders", { top: border, left: border, right: border, bottom: border });
+                    }
+                    break;
+                // Option/Alt + =
+                case "Equal":
+                    if (onInsertAutoSum) {
+                        onInsertAutoSum(sheetId, activeCell);
+                        e.preventDefault();
+                    }
+                    break;
+            }
+        }
+        // Shift key only
+        if (isShift) {
+            switch (key) {
+                // Shift + F2
+                case "F2":
+                    onInsertNote?.(sheetId, activeCell);
+                    break;
+            }
+            // Keycode
+            switch (code) {
+                // Option/Alt + Shift + ;
+                case "Semicolon":
+                    if (isAlt) {
+                        onInsertDateTime?.(sheetId, activeCell, selections);
+                        e.preventDefault();
+                    }
+                    break;
+                // Cmd/Ctrl + Shift + F
+                case "KeyF":
+                    if (isMeta) {
+                        onCreateBasicFilter?.(sheetId, activeCell, selections);
+                    }
+                    break;
+            }
+            // Ctrl key
+            if (isCtrl) {
+                switch (code) {
+                    // Ctrl + Shift + 1
+                    case "Digit1":
+                        onChangeFormatting?.(sheetId, activeCell, selections, "numberFormat", {
+                            type: "NUMBER",
+                            pattern: "#,##0.00",
+                        });
+                        break;
+                    // Ctrl + Shift + 2
+                    case "Digit2":
+                        onChangeFormatting?.(sheetId, activeCell, selections, "numberFormat", {
+                            type: "DATE_TIME",
+                            pattern: "hh:mm:ss",
+                        });
+                        break;
+                    // Ctrl + Shift + 3
+                    case "Digit3":
+                        onChangeFormatting?.(sheetId, activeCell, selections, "numberFormat", {
+                            type: "DATE",
+                            pattern: longDateFormat,
+                        });
+                        break;
+                    // Ctrl + Shift + 4
+                    case "Digit4":
+                        onChangeFormatting?.(sheetId, activeCell, selections, "numberFormat", {
+                            type: "CURRENCY",
+                            pattern: `_("${currencySymbol}"* #,##0.00_);_("${currencySymbol}"* (#,##0.00);_("${currencySymbol}"* "-"??_);_(@_)`,
+                        });
+                        break;
+                    // Ctrl + Shift + 5
+                    case "Digit5":
+                        onChangeFormatting?.(sheetId, activeCell, selections, "numberFormat", {
+                            type: "PERCENT",
+                            pattern: "0%",
+                        });
+                        break;
+                }
+            }
+        }
+        // F4
+        if (key === "F4") {
+            onRepeatFormatting?.(sheetId, activeCell, selections);
+        }
+    }, [
+        locale,
+        onChangeFormatting,
+        onRepeatFormatting,
+        getCellFormat,
+        defaultFontSizePoint,
+        activeCell,
+        selections,
+        clearCopiedSelections,
+        onClearFormatting,
+        onSelectNextSheet,
+        onSelectPreviousSheet,
+        onCreateNewSheet,
+        onFillRange,
+        onInsertTime,
+        onInsertDate,
+        onInsertDateTime,
+        onInsertNote,
+        onCreateTable,
+        onCreateBasicFilter,
+        onUndo,
+        onRedo,
+        onAddQuickEdit,
+        onRequestSearch,
+        onRequestReplace,
+        onRequestFormatCells,
+        onRequestInsertComment,
+        onRequestInsertLink,
+        onShowContextMenu,
+        onHideColumn,
+        onHideRow,
+        onGroupRows,
+        onUngroupRows,
+        onGroupColumns,
+        onUngroupColumns,
+        onShowFormulas,
+        isSheetFocused,
+        onInsertRow,
+        onInsertAutoSum,
+        onDeleteRow,
+        sheetId,
+        selectedColumns,
+        selectedRows,
+        showFormulas,
+        canEditCell,
+        disableFillRightShortcut,
+    ]));
+};

package/dist/esm/hooks/use-licensekey-validator.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+type UseLicenseKeyValidatorProps = {
+    licenseKey?: string;
+};
+export type LicenseType = "evaluation" | "solo" | "personal" | "professional" | "team" | "enterprise";
+export declare const useLicenseKeyValidator: ({ licenseKey, }: UseLicenseKeyValidatorProps) => readonly [boolean, LicenseType | undefined, React.JSX.Element | null];
+type ValidationResult = readonly [
+    isValid: boolean,
+    isExpired: boolean,
+    licenseType?: LicenseType
+];
+export declare const validateLicenseCode: (licenseCodeWithUserIdStartEndDate: string, options?: {
+    publicKey?: string;
+}) => Promise<ValidationResult>;
+export {};
+//# sourceMappingURL=use-licensekey-validator.d.ts.map

package/dist/esm/hooks/use-licensekey-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-licensekey-validator.d.ts","sourceRoot":"","sources":["../../../hooks/use-licensekey-validator.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAKxC,KAAK,2BAA2B,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AACF,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,MAAM,GACN,UAAU,GACV,cAAc,GACd,MAAM,GACN,YAAY,CAAC;AAcjB,eAAO,MAAM,sBAAsB,GAAI,iBAEpC,2BAA2B,0EA2C7B,CAAC;AAEF,KAAK,gBAAgB,GAAG,SAAS;IAC/B,OAAO,EAAE,OAAO;IAChB,SAAS,EAAE,OAAO;IAClB,WAAW,CAAC,EAAE,WAAW;CAC1B,CAAC;AA+DF,eAAO,MAAM,mBAAmB,GAC9B,mCAAmC,MAAM,EACzC,UAAU;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,KAC/B,OAAO,CAAC,gBAAgB,CA8C1B,CAAC"}

package/dist/esm/hooks/use-licensekey-validator.js

@@ -0,0 +1,140 @@
+import { canUseDOM } from "@rowsncolumns/grid";
+import { OpenInNewWindowIcon } from "@rowsncolumns/icons";
+import { useIsomorphicLayoutEffect } from "@rowsncolumns/ui";
+import { Stack } from "@rowsncolumns/ui";
+import React, { useState } from "react";
+import { DEFAULT_ARRAY } from "../config";
+import { releaseDate } from "../release-date";
+const EVALUATION_LICENSE_KEY = "evaluation-license";
+const algo = "SHA-256";
+const secret = "rowsncolumns-license";
+// v2 signed keys: `rowsncolumns.<base64url payload>.<base64url ECDSA P-256
+// signature>`. The payload (id, licensee, type, end) is covered by the
+// signature, so the version-cutoff date cannot be edited. Keys are minted
+// with scripts/license-keygen.mjs; the private key never ships.
+const V2_PREFIX = "rowsncolumns.";
+const V2_PUBLIC_KEY = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE+1nphJOQWgRXHVynHqUqfTeeNIIkwV6LcYfBxWq+GnguEkI6uIWfiQWw9xa/eGWg+dGcAqcWStJJknx74S7wqw==";
+export const useLicenseKeyValidator = ({ licenseKey, }) => {
+    const [isValid, setIsValid] = useState(true);
+    const [isExpired, setIsExpired] = useState(false);
+    const [licenseType, setLicenseType] = useState(undefined);
+    useIsomorphicLayoutEffect(() => {
+        if (!licenseKey) {
+            setIsValid(false);
+        }
+        async function validate() {
+            const isEvaluation = licenseKey === EVALUATION_LICENSE_KEY;
+            const [isValid, isExpired, licenseType] = isEvaluation
+                ? [true, false, "evaluation"]
+                : licenseKey
+                    ? await validateLicenseCode(licenseKey)
+                    : [false, false, undefined];
+            // Set license flags
+            setIsValid(isValid);
+            setIsExpired(isExpired);
+            setLicenseType(licenseType);
+        }
+        validate();
+    }, [licenseKey]);
+    const message = isValid
+        ? null
+        : isExpired
+            ? `You are using an evaluation version of Spreadsheet. Please enter a
+        license key to remove this message. Use the \`licenseKey\` prop in
+        CanvasGrid to validate your Spreadsheet license.`
+            : `The license provided is a valid Spreadsheet license, however it is not valid for the
+    current version of Spreadsheet being used. Please renew your license or use
+    the fallback version valid under your license.`;
+    return [
+        isValid,
+        licenseType,
+        isValid ? null : React.createElement(LicenseAlertMessage, { message: message }),
+    ];
+};
+const base64ToBytes = (value) => {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const binary = atob(normalized);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+};
+const validateV2LicenseCode = async (licenseCode, publicKey) => {
+    if (!canUseDOM) {
+        return [false, false, undefined];
+    }
+    // Allow local usage
+    if (!window.isSecureContext ||
+        (window.location.hostname === "localhost" && !window.crypto)) {
+        return [true, false, "professional"];
+    }
+    try {
+        const [payloadPart, signaturePart] = licenseCode
+            .slice(V2_PREFIX.length)
+            .split(".");
+        if (!payloadPart || !signaturePart) {
+            return [false, false, undefined];
+        }
+        const payloadBytes = base64ToBytes(payloadPart);
+        const key = await crypto.subtle.importKey("spki", base64ToBytes(publicKey), { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+        const isValid = await crypto.subtle.verify({ name: "ECDSA", hash: algo }, key, base64ToBytes(signaturePart), payloadBytes);
+        if (!isValid) {
+            return [false, false, undefined];
+        }
+        const payload = JSON.parse(new TextDecoder().decode(payloadBytes));
+        const isExpired = releaseDate > new Date(payload.end);
+        return [true, isExpired, payload.type];
+    }
+    catch {
+        return [false, false, undefined];
+    }
+};
+export const validateLicenseCode = async (licenseCodeWithUserIdStartEndDate, options) => {
+    if (licenseCodeWithUserIdStartEndDate.startsWith(V2_PREFIX)) {
+        return validateV2LicenseCode(licenseCodeWithUserIdStartEndDate, options?.publicKey ?? V2_PUBLIC_KEY);
+    }
+    const [licenseCodeWithUserId, startEndDates] = licenseCodeWithUserIdStartEndDate.split("|");
+    const [userId, licenseType, licenseCode] = licenseCodeWithUserId.split(/-(.*?)-(.*)/gi);
+    const [_, endDate] = startEndDates?.split(" ") ?? DEFAULT_ARRAY;
+    const endDateValue = new Date(endDate);
+    const decodedLicenseCode = licenseCode.replace(/-/g, "");
+    const licenseKey = `${userId}-${licenseType}-${secret}`;
+    const encoder = new TextEncoder();
+    const data = encoder.encode(licenseKey);
+    // Allow local usage
+    if (canUseDOM) {
+        if (!window.isSecureContext ||
+            (window.location.hostname === "localhost" && !window.crypto)) {
+            return [true, false, "professional"];
+        }
+        const isValid = await crypto.subtle
+            ?.digest(algo, data)
+            .then((hashBuffer) => {
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const hash = hashArray
+                .map((byte) => byte.toString(16).padStart(2, "0"))
+                .join(""); // Convert the hash buffer to hexadecimal string
+            return decodedLicenseCode === hash;
+        });
+        const isExpired = releaseDate > endDateValue;
+        return [
+            isValid,
+            isExpired,
+            licenseType,
+        ];
+    }
+    else {
+        return [false, false, undefined];
+    }
+};
+const LicenseAlertMessage = ({ message }) => {
+    return (React.createElement(Stack, { className: "absolute bottom-4 right-4 p-2 text-xs bg-rnc-muted-foreground/80 text-rnc-muted max-w-[500px] flex-col gap-4" },
+        React.createElement("div", null, message),
+        React.createElement("div", null,
+            "To purchase a license, please visit",
+            " ",
+            React.createElement("a", { className: "text-rnc-muted hover:text-rnc-muted active:text-rnc-muted focus:text-rnc-muted underline-offset-2", target: "_blank", href: "https://www.rowsncolumns.app/pricing", rel: "noreferrer" },
+                "www.rowsncolumns.app. ",
+                React.createElement(OpenInNewWindowIcon, null)))));
+};

package/dist/esm/hooks/use-memo-compare.d.ts

@@ -0,0 +1,2 @@
+export declare const useMemoCompare: <T>(next: T) => T;
+//# sourceMappingURL=use-memo-compare.d.ts.map

package/dist/esm/hooks/use-memo-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-memo-compare.d.ts","sourceRoot":"","sources":["../../../hooks/use-memo-compare.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,MAAM,CAAC,KAAG,CAS3C,CAAC"}

package/dist/esm/hooks/use-memo-compare.js

@@ -0,0 +1,13 @@
+import { useIsomorphicLayoutEffect } from "@rowsncolumns/grid";
+import isEqualComparator from "lodash/isEqual";
+import { useRef } from "react";
+export const useMemoCompare = (next) => {
+    const previousRef = useRef(undefined);
+    const previous = previousRef.current;
+    const isEqual = isEqualComparator(previous, next);
+    useIsomorphicLayoutEffect(() => {
+        if (!isEqual)
+            previousRef.current = next;
+    }, [next]);
+    return isEqual ? previous ?? next : next;
+};

package/dist/esm/hooks/use-merge.refs.d.ts

@@ -0,0 +1,4 @@
+import type * as React from "react";
+export declare function mergeRefs<T = any>(...refs: Array<React.MutableRefObject<T> | React.LegacyRef<T> | undefined | null>): React.RefCallback<T>;
+export declare function useMergeRefs<T = any>(...refs: Array<React.MutableRefObject<T> | React.LegacyRef<T> | undefined | null>): React.RefCallback<T>;
+//# sourceMappingURL=use-merge.refs.d.ts.map

package/dist/esm/hooks/use-merge.refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-merge.refs.d.ts","sourceRoot":"","sources":["../../../hooks/use-merge.refs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,GAAG,IAAI,EAAE,KAAK,CACZ,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAClE,GACA,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAUtB;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,GAAG,EAClC,GAAG,IAAI,EAAE,KAAK,CACZ,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAClE,GACA,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAEtB"}

package/dist/esm/hooks/use-merge.refs.js

@@ -0,0 +1,16 @@
+import { useMemo } from "react";
+export function mergeRefs(...refs) {
+    return (value) => {
+        refs.forEach((ref) => {
+            if (typeof ref === "function") {
+                ref(value);
+            }
+            else if (ref != null) {
+                ref.current = value;
+            }
+        });
+    };
+}
+export function useMergeRefs(...refs) {
+    return useMemo(() => mergeRefs(...refs), refs);
+}