@rowsncolumns/utils 9.2.35

package/dist/cjs/selection.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnIndexFromColumnName = exports.pixelToPoint = exports.pointToPixel = exports.cellToArea = exports.rescopeSheetRangesOnMove = exports.areaIntersection = exports.areaInsideArea = exports.areaIntersects = exports.selectionFromActiveCell = exports.isCellWithinBounds = exports.isAreasEqual = exports.generateSelectionsFromFormula = exports.checkIfStringIsReference = exports.selectionToAddress = exports.addressToSheetRange = exports.addressToSelection = exports.DEFAULT_ACTIVE_CELL = exports.DEFAULT_COLUMN_WIDTH = exports.DEFAULT_ROW_HEIGHT = exports.DEFAULT_COLUMN_COUNT = exports.DEFAULT_ROW_COUNT = exports.MAX_COLUMN_COUNT = exports.MAX_ROW_COUNT = exports.isSelection = void 0;
+var tslib_1 = require("tslib");
+var string_1 = require("./string");
+var typeguards_1 = require("./typeguards");
+var string_2 = require("./string");
+var isSelection = function (sel) {
+    return !!(sel === null || sel === void 0 ? void 0 : sel.range);
+};
+exports.isSelection = isSelection;
+exports.MAX_ROW_COUNT = 1048576;
+exports.MAX_COLUMN_COUNT = 16384;
+exports.DEFAULT_ROW_COUNT = 1000;
+exports.DEFAULT_COLUMN_COUNT = 100;
+exports.DEFAULT_ROW_HEIGHT = 21;
+exports.DEFAULT_COLUMN_WIDTH = 100;
+exports.DEFAULT_ACTIVE_CELL = Object.freeze({
+    rowIndex: 1,
+    columnIndex: 1,
+});
+var addressToSelection = function (address, rowCount, columnCount) {
+    if (rowCount === void 0) { rowCount = exports.MAX_ROW_COUNT; }
+    if (columnCount === void 0) { columnCount = exports.MAX_COLUMN_COUNT; }
+    var _a = tslib_1.__read(address.split(":"), 2), from = _a[0], to = _a[1];
+    if (!from)
+        return undefined;
+    if (!to)
+        to = from;
+    var fromCell = (0, string_2.addressToCell)(from, {
+        position: "start",
+        rowCount: rowCount,
+        columnCount: columnCount,
+    });
+    var toCell = (0, string_2.addressToCell)(to, {
+        position: "end",
+        rowCount: rowCount,
+        columnCount: columnCount,
+    });
+    if (!fromCell || !toCell)
+        return undefined;
+    return { range: (0, string_2.selectionBoundsFromCells)(fromCell, toCell) };
+};
+exports.addressToSelection = addressToSelection;
+var addressToSheetRange = function (address, sheetId, rowCount, columnCount) {
+    if (rowCount === void 0) { rowCount = exports.MAX_ROW_COUNT; }
+    if (columnCount === void 0) { columnCount = exports.MAX_COLUMN_COUNT; }
+    var selection = (0, exports.addressToSelection)(address, rowCount, columnCount);
+    if (!selection) {
+        return undefined;
+    }
+    return tslib_1.__assign({ sheetId: sheetId }, selection.range);
+};
+exports.addressToSheetRange = addressToSheetRange;
+/**
+ * Convert a selection object to A1 address form (optionally sheet-qualified).
+ */
+var selectionToAddress = function (selection, sheetName, merges, rowCount, columnCount) {
+    if (merges === void 0) { merges = []; }
+    if (rowCount === void 0) { rowCount = exports.MAX_ROW_COUNT; }
+    if (columnCount === void 0) { columnCount = exports.MAX_COLUMN_COUNT; }
+    if (!selection) {
+        return undefined;
+    }
+    var mergedCell = merges === null || merges === void 0 ? void 0 : merges.find(function (merge) {
+        return (0, exports.isAreasEqual)(selection.range, merge);
+    });
+    var _a = mergedCell
+        ? (0, exports.cellToArea)({
+            rowIndex: mergedCell.startRowIndex,
+            columnIndex: mergedCell.startColumnIndex,
+        })
+        : selection.range, startRowIndex = _a.startRowIndex, startColumnIndex = _a.startColumnIndex, endRowIndex = _a.endRowIndex, endColumnIndex = _a.endColumnIndex;
+    var isFullColumn = startRowIndex === 1 && endRowIndex === rowCount;
+    var isFullRow = startColumnIndex === 1 && endColumnIndex === columnCount;
+    var from = (0, string_2.cellToAddress)({
+        rowIndex: startRowIndex,
+        columnIndex: startColumnIndex,
+    }, undefined, undefined, isFullColumn, isFullRow);
+    var to = (0, string_2.cellToAddress)({
+        rowIndex: endRowIndex,
+        columnIndex: endColumnIndex,
+    }, undefined, undefined, isFullColumn, isFullRow);
+    var cellAddress = from === to && !isFullColumn && !isFullRow ? from : "".concat(from, ":").concat(to || "");
+    return "".concat(sheetName ? (0, string_2.sanitizeSheetName)(sheetName) + "!" : "").concat(cellAddress);
+};
+exports.selectionToAddress = selectionToAddress;
+var checkIfStringIsReference = function (value) {
+    if (!value)
+        return false;
+    var v = String(value).trim();
+    var expr = v.startsWith("=") ? v.slice(1) : v;
+    var refRegex = /^(?:[^!]+!)?\$?[A-Z]+\$?\d+(?::\$?[A-Z]+\$?\d+)?$/i;
+    return refRegex.test(expr);
+};
+exports.checkIfStringIsReference = checkIfStringIsReference;
+var generateSelectionsFromFormula = function (value, _sheetId, currentSheetName, activeCell, rowCount, columnCount, tokenizer, getSelectionFromTable, getSelectionFromNamedRange) {
+    var e_1, _a;
+    var _b, _c;
+    if (rowCount === void 0) { rowCount = exports.MAX_ROW_COUNT; }
+    if (columnCount === void 0) { columnCount = exports.MAX_COLUMN_COUNT; }
+    var selections = [];
+    if (!value)
+        return selections;
+    if (tokenizer && !(0, typeguards_1.isNil)(_sheetId)) {
+        var sheetId = _sheetId;
+        var tokens = (_b = tokenizer(value, currentSheetName)) !== null && _b !== void 0 ? _b : [];
+        try {
+            for (var tokens_1 = tslib_1.__values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+                var token = tokens_1_1.value;
+                if (token.structured && getSelectionFromTable) {
+                    var structuredSelection = getSelectionFromTable(sheetId, activeCell, token.tableName, token.columnNames, token.thisRow, token.specialItem);
+                    if (structuredSelection && (0, exports.isSelection)(structuredSelection)) {
+                        selections.push(structuredSelection);
+                    }
+                }
+                if (token.isNamedRange && getSelectionFromNamedRange) {
+                    var namedRangeSelection = getSelectionFromNamedRange(token.image);
+                    if (namedRangeSelection && (0, exports.isSelection)(namedRangeSelection)) {
+                        selections.push(namedRangeSelection);
+                    }
+                }
+                if (token.selection) {
+                    var address = token.image.slice(token.image.indexOf("!") + 1);
+                    var selectionRange = (0, exports.addressToSelection)(address, rowCount, columnCount);
+                    if (selectionRange) {
+                        selections.push(tslib_1.__assign(tslib_1.__assign({}, selectionRange), { sheetName: (0, string_1.desanitizeSheetName)((_c = token.sheetName) !== null && _c !== void 0 ? _c : currentSheetName) }));
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return selections;
+    }
+    var input = value.startsWith("=") ? value.slice(1) : value;
+    var refPattern = /((?:'[^']+'|[^'!,]+)!)?\$?[A-Z]+\$?\d+(?::\$?[A-Z]+\$?\d+)?/g;
+    var m;
+    while ((m = refPattern.exec(input))) {
+        var token = m[0];
+        var _d = tslib_1.__read(token.includes("!")
+            ? [
+                token.slice(0, token.indexOf("!")),
+                token.slice(token.indexOf("!") + 1),
+            ]
+            : [undefined, token], 2), maybeSheet = _d[0], addr = _d[1];
+        var sel = (0, exports.addressToSelection)(addr, rowCount, columnCount);
+        if (sel) {
+            selections.push(tslib_1.__assign(tslib_1.__assign({}, sel), { sheetName: maybeSheet
+                    ? maybeSheet.replace(/!$/, "").replace(/^'|'$/g, "") || undefined
+                    : currentSheetName }));
+        }
+    }
+    return selections;
+};
+exports.generateSelectionsFromFormula = generateSelectionsFromFormula;
+/**
+ * Check if two ranges are equal.
+ */
+var isAreasEqual = function (area1, area2) {
+    if (area1 === undefined || area2 === undefined) {
+        return false;
+    }
+    return (area1.endRowIndex === area2.endRowIndex &&
+        area1.startRowIndex === area2.startRowIndex &&
+        area1.startColumnIndex === area2.startColumnIndex &&
+        area1.endColumnIndex === area2.endColumnIndex);
+};
+exports.isAreasEqual = isAreasEqual;
+/**
+ * Check if a cell is inside the provided range bounds.
+ */
+var isCellWithinBounds = function (cell, bounds) {
+    if (!bounds) {
+        return false;
+    }
+    if (cell.rowIndex < bounds.startRowIndex ||
+        cell.rowIndex > bounds.endRowIndex) {
+        return false;
+    }
+    if (cell.columnIndex < bounds.startColumnIndex ||
+        cell.columnIndex > bounds.endColumnIndex) {
+        return false;
+    }
+    return true;
+};
+exports.isCellWithinBounds = isCellWithinBounds;
+/**
+ * Return a single-cell selection for the active cell.
+ */
+var selectionFromActiveCell = function (activeCell) {
+    if (!activeCell)
+        return [];
+    return [
+        {
+            range: {
+                startRowIndex: activeCell.rowIndex,
+                startColumnIndex: activeCell.columnIndex,
+                endRowIndex: activeCell.rowIndex,
+                endColumnIndex: activeCell.columnIndex,
+            },
+        },
+    ];
+};
+exports.selectionFromActiveCell = selectionFromActiveCell;
+/**
+ * Check if two ranges overlap.
+ */
+var areaIntersects = function (area1, area2) {
+    if (!area2) {
+        return false;
+    }
+    if (area1.startColumnIndex > area2.endColumnIndex ||
+        area2.startColumnIndex > area1.endColumnIndex) {
+        return false;
+    }
+    if (area1.startRowIndex > area2.endRowIndex ||
+        area2.startRowIndex > area1.endRowIndex) {
+        return false;
+    }
+    return true;
+};
+exports.areaIntersects = areaIntersects;
+/**
+ * Check if `needle` range is fully inside `haystack`.
+ */
+var areaInsideArea = function (needle, haystack) {
+    return (needle.startRowIndex >= haystack.startRowIndex &&
+        needle.endRowIndex <= haystack.endRowIndex &&
+        needle.startColumnIndex >= haystack.startColumnIndex &&
+        needle.endColumnIndex <= haystack.endColumnIndex);
+};
+exports.areaInsideArea = areaInsideArea;
+/**
+ * Intersection of two ranges, or `null` when they don't overlap.
+ */
+var areaIntersection = function (area1, area2) {
+    var startRowIndex = Math.max(area1.startRowIndex, area2.startRowIndex);
+    var endRowIndex = Math.min(area1.endRowIndex, area2.endRowIndex);
+    var startColumnIndex = Math.max(area1.startColumnIndex, area2.startColumnIndex);
+    var endColumnIndex = Math.min(area1.endColumnIndex, area2.endColumnIndex);
+    if (startRowIndex > endRowIndex || startColumnIndex > endColumnIndex) {
+        return null;
+    }
+    return { startRowIndex: startRowIndex, endRowIndex: endRowIndex, startColumnIndex: startColumnIndex, endColumnIndex: endColumnIndex };
+};
+exports.areaIntersection = areaIntersection;
+/**
+ * Re-scope a rule's ranges after a drag-move of `from` → `to` on `sheetId`, so
+ * range-scoped rules (conditional formats, data validations) travel with the
+ * moved cells the way Excel and Google Sheets carry them:
+ *
+ * - a range on another sheet, or untouched by the move, is kept as-is
+ * - a range that travelled entirely inside the moved area is shifted with it
+ * - a range that only partially overlaps the moved area keeps its original
+ *   scope (the source cells left behind keep the rule) and gains the shifted
+ *   overlap at the destination — unless one of the rule's ranges already
+ *   covers that destination
+ *
+ * Returns the new ranges, or `null` when the move leaves every range
+ * untouched, so callers can skip the rule update entirely (no history entry,
+ * no re-evaluation).
+ */
+var rescopeSheetRangesOnMove = function (ranges, sheetId, from, to) {
+    var e_2, _a, e_3, _b;
+    var rowDelta = to.startRowIndex - from.startRowIndex;
+    var columnDelta = to.startColumnIndex - from.startColumnIndex;
+    if (rowDelta === 0 && columnDelta === 0) {
+        return null;
+    }
+    var shift = function (range) { return (tslib_1.__assign(tslib_1.__assign({}, range), { startRowIndex: range.startRowIndex + rowDelta, endRowIndex: range.endRowIndex + rowDelta, startColumnIndex: range.startColumnIndex + columnDelta, endColumnIndex: range.endColumnIndex + columnDelta })); };
+    var changed = false;
+    var next = [];
+    var shiftedOverlaps = [];
+    try {
+        for (var ranges_1 = tslib_1.__values(ranges), ranges_1_1 = ranges_1.next(); !ranges_1_1.done; ranges_1_1 = ranges_1.next()) {
+            var range = ranges_1_1.value;
+            if (range.sheetId !== sheetId) {
+                next.push(range);
+                continue;
+            }
+            var overlap = (0, exports.areaIntersection)(range, from);
+            if (!overlap) {
+                next.push(range);
+                continue;
+            }
+            if ((0, exports.areaInsideArea)(range, from)) {
+                next.push(shift(range));
+                changed = true;
+                continue;
+            }
+            next.push(range);
+            shiftedOverlaps.push(shift(tslib_1.__assign(tslib_1.__assign({}, overlap), { sheetId: range.sheetId })));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (ranges_1_1 && !ranges_1_1.done && (_a = ranges_1.return)) _a.call(ranges_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var _loop_1 = function (shifted) {
+        var covered = next.some(function (range) {
+            return range.sheetId === sheetId && (0, exports.areaInsideArea)(shifted, range);
+        });
+        if (covered) {
+            return "continue";
+        }
+        next.push(shifted);
+        changed = true;
+    };
+    try {
+        for (var shiftedOverlaps_1 = tslib_1.__values(shiftedOverlaps), shiftedOverlaps_1_1 = shiftedOverlaps_1.next(); !shiftedOverlaps_1_1.done; shiftedOverlaps_1_1 = shiftedOverlaps_1.next()) {
+            var shifted = shiftedOverlaps_1_1.value;
+            _loop_1(shifted);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (shiftedOverlaps_1_1 && !shiftedOverlaps_1_1.done && (_b = shiftedOverlaps_1.return)) _b.call(shiftedOverlaps_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return changed ? next : null;
+};
+exports.rescopeSheetRangesOnMove = rescopeSheetRangesOnMove;
+/**
+ * Convert a cell coordinate into a single-cell range.
+ */
+var cellToArea = function (_a) {
+    var rowIndex = _a.rowIndex, columnIndex = _a.columnIndex;
+    return {
+        startRowIndex: rowIndex,
+        startColumnIndex: columnIndex,
+        endColumnIndex: columnIndex,
+        endRowIndex: rowIndex,
+    };
+};
+exports.cellToArea = cellToArea;
+/**
+ * Convert font size from points to pixels.
+ */
+var pointToPixel = function (pt) { return Math.round((13 / 10) * pt); };
+exports.pointToPixel = pointToPixel;
+/**
+ * Convert font size from pixels to points.
+ */
+var pixelToPoint = function (px) { return Math.round((px / 13) * 10); };
+exports.pixelToPoint = pixelToPoint;
+/**
+ * Resolve a table column name to absolute column index.
+ */
+var getColumnIndexFromColumnName = function (table, columnName) {
+    var _a;
+    var fromIndex = (_a = table.columns) === null || _a === void 0 ? void 0 : _a.findIndex(function (col) { return col.name === columnName; });
+    if (fromIndex == null || fromIndex === -1) {
+        return undefined;
+    }
+    return table.range.startColumnIndex + fromIndex;
+};
+exports.getColumnIndexFromColumnName = getColumnIndexFromColumnName;

package/dist/cjs/shared-string-canonical.d.ts

@@ -0,0 +1,18 @@
+import type { TextFormatRun } from "@rowsncolumns/common-types";
+/**
+ * Deterministic string form of a (text, runs) pair, suitable as input to
+ * `contentHash` for rich shared-string entries.
+ *
+ * Two rich entries that render identically produce the same canonical string
+ * regardless of property ordering or absent-vs-false boolean variations. The
+ * leading `RICH_MARKER` (control characters) guarantees a rich canonical can
+ * never equal any plain shared-string text, so plain↔rich never collide on
+ * the downstream content hash.
+ *
+ * IMPORTANT: This is the dedup key for shared-string IDs across sessions.
+ * Changing the format, key order, or stripping rules invalidates every
+ * existing rich-string ID. Mirror updates here in any other-language port
+ * (e.g. Python) used in the same collaboration session.
+ */
+export declare const canonicalizeRichSharedString: (text: string, runs: readonly TextFormatRun[]) => string;
+//# sourceMappingURL=shared-string-canonical.d.ts.map

package/dist/cjs/shared-string-canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-string-canonical.d.ts","sourceRoot":"","sources":["../../shared-string-canonical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,aAAa,EACd,MAAM,4BAA4B,CAAC;AAkDpC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,4BAA4B,GACvC,MAAM,MAAM,EACZ,MAAM,SAAS,aAAa,EAAE,KAC7B,MAGF,CAAC"}

package/dist/cjs/shared-string-canonical.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalizeRichSharedString = void 0;
+// U+0001 (START OF HEADING). Cell text shouldn't contain control chars, so
+// using it as a separator and as the `RICH_MARKER` prefix guarantees the rich
+// canonical string can never collide with any plain shared-string value.
+// Built via fromCharCode rather than a string literal so the control byte is
+// visible in source.
+var SEP = String.fromCharCode(1);
+var RICH_MARKER = "".concat(SEP, "RICH").concat(SEP);
+var canonicalizeColor = function (color) {
+    if (color == null)
+        return "";
+    if (typeof color === "string")
+        return "s:".concat(color);
+    var tint = color.tint == null ? "" : color.tint;
+    return "t:".concat(color.theme, ":").concat(tint);
+};
+// Fixed key order. Skips null/undefined and false-equivalent booleans so a
+// producer that writes `{ bold: true }` hashes identically to one that writes
+// `{ bold: true, italic: false }`. Any new field added to `TextFormat` MUST be
+// appended here, otherwise rich entries differing only in the new field will
+// collapse and dedup incorrectly.
+var canonicalizeFormat = function (format) {
+    if (!format)
+        return "";
+    var parts = [];
+    if (format.bold)
+        parts.push("b");
+    if (format.italic)
+        parts.push("i");
+    if (format.strikethrough)
+        parts.push("s");
+    if (format.underline)
+        parts.push("u");
+    if (format.color != null)
+        parts.push("c=".concat(canonicalizeColor(format.color)));
+    if (format.fontFamily)
+        parts.push("ff=".concat(format.fontFamily));
+    if (format.fontSize != null)
+        parts.push("fs=".concat(format.fontSize));
+    if (format.baselineOffset)
+        parts.push("bo=".concat(format.baselineOffset));
+    return parts.join(",");
+};
+var canonicalizeMention = function (mention) {
+    return "v=".concat(mention.value, ",l=").concat(mention.label);
+};
+var canonicalizeRun = function (run) {
+    if (run.nodeType === "mention") {
+        return "M:".concat(run.startIndex, ":").concat(run.endIndex, ":").concat(canonicalizeMention(run.mention));
+    }
+    return "T:".concat(run.startIndex, ":").concat(run.endIndex, ":").concat(canonicalizeFormat(run.format));
+};
+/**
+ * Deterministic string form of a (text, runs) pair, suitable as input to
+ * `contentHash` for rich shared-string entries.
+ *
+ * Two rich entries that render identically produce the same canonical string
+ * regardless of property ordering or absent-vs-false boolean variations. The
+ * leading `RICH_MARKER` (control characters) guarantees a rich canonical can
+ * never equal any plain shared-string text, so plain↔rich never collide on
+ * the downstream content hash.
+ *
+ * IMPORTANT: This is the dedup key for shared-string IDs across sessions.
+ * Changing the format, key order, or stripping rules invalidates every
+ * existing rich-string ID. Mirror updates here in any other-language port
+ * (e.g. Python) used in the same collaboration session.
+ */
+var canonicalizeRichSharedString = function (text, runs) {
+    var runsKey = runs.map(canonicalizeRun).join(";");
+    return "".concat(RICH_MARKER).concat(text).concat(SEP).concat(runsKey);
+};
+exports.canonicalizeRichSharedString = canonicalizeRichSharedString;

package/dist/cjs/sort.d.ts

@@ -0,0 +1,15 @@
+export type BaseSheet = {
+    index?: number | null;
+    title: string;
+    hidden?: boolean | null;
+    sheetId: number;
+} & Record<string, any>;
+/**
+ * Sort sheets by index
+ * @param sheets
+ * @returns
+ */
+export declare const sortSheetsByIndex: <S extends BaseSheet>(sheets: S[], includeHidden?: boolean) => (S & {
+    index: number;
+})[];
+//# sourceMappingURL=sort.d.ts.map

package/dist/cjs/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../sort.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACxB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,SAAS,EACnD,QAAQ,CAAC,EAAE,EACX,gBAAgB,OAAO;;IA0CxB,CAAC"}

package/dist/cjs/sort.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortSheetsByIndex = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Sort sheets by index
+ * @param sheets
+ * @returns
+ */
+var sortSheetsByIndex = function (sheets, includeHidden) {
+    var filtered = sheets
+        .filter(Boolean)
+        .filter(function (sheet) {
+        return includeHidden ? sheet.title : !sheet.hidden && sheet.title;
+    });
+    // Remove duplicate sheets with the same sheetId, keeping only the first occurrence
+    var seen = new Set();
+    var deduplicated = filtered.filter(function (sheet) {
+        if (seen.has(sheet.sheetId)) {
+            return false;
+        }
+        seen.add(sheet.sheetId);
+        return true;
+    });
+    // Collect indices that are already defined
+    var usedIndices = new Set(deduplicated
+        .map(function (sheet) { return sheet.index; })
+        .filter(function (index) { return index !== undefined && index !== null; }));
+    // Assign indices to sheets without one, starting from 0 and skipping used indices
+    var nextIndex = 0;
+    var getNextAvailableIndex = function () {
+        while (usedIndices.has(nextIndex)) {
+            nextIndex++;
+        }
+        return nextIndex++;
+    };
+    return deduplicated
+        .map(function (sheet) {
+        var _a;
+        return tslib_1.__assign(tslib_1.__assign({}, sheet), { index: (_a = sheet.index) !== null && _a !== void 0 ? _a : getNextAvailableIndex() });
+    })
+        .sort(function (a, b) { var _a, _b; return ((_a = a.index) !== null && _a !== void 0 ? _a : 0) - ((_b = b.index) !== null && _b !== void 0 ? _b : 0); });
+};
+exports.sortSheetsByIndex = sortSheetsByIndex;

package/dist/cjs/string.d.ts

@@ -0,0 +1,74 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+/**
+ * Convert cell to bounds.
+ * Its better to use gridref.current.getCellBounds() instead as it caters
+ * to merged cells
+ * @param cell
+ * @returns
+ */
+export declare const convertCellToRange: (cell: CellInterface) => GridRange;
+/**
+ * Converts address string to CellInterface
+ * @param address
+ */
+export declare const addressToCell: (address: string, options?: {
+    position?: "start" | "end";
+    rowCount?: number;
+    columnCount?: number;
+}) => CellInterface | null;
+/**
+ * Gets column  from address $G => G
+ * @param address
+ */
+export declare const getColumnNameFromAddress: (address: string) => string | undefined;
+/**
+ * Gets rowIndex from address $1 => 1
+ * @param address
+ */
+export declare const getRowIndexFromAddress: (address: string) => string | undefined;
+/**
+ * Convert cellInterface to address string
+ * @param cell
+ */
+export declare const cellToAddress: (cell: CellInterface | null, isAbsoluteColumn?: boolean, isAbsoluteRow?: boolean, isFullColumn?: boolean, isFullRow?: boolean) => string | null;
+/**
+ * Convert a cell range to address
+ * @param sheetName
+ * @param range
+ * @returns
+ */
+export declare const cellRangeToAddress: (sheetName: string | undefined, range: GridRange) => string;
+export declare const sanitizeSheetName: (name: string | undefined) => string | undefined;
+/**
+ * Remove single quotes from sheetname
+ * 'Sheet Space!A4' => Sheet Space
+ * @param name
+ * @returns
+ */
+export declare const desanitizeSheetName: (name: string | undefined) => string | undefined;
+/**
+ * Escape special characters
+ * @param str
+ * @returns
+ */
+export declare const escapeCharacters: (str: string) => string;
+/**
+ * Get selection from start and end cell
+ * @param start
+ * @param end
+ * @param sheetName
+ * @returns
+ */
+export declare const selectionBoundsFromCells: (start: CellInterface, end?: CellInterface | null) => GridRange;
+export declare const supplant: (s: string, o: Record<string, any>) => string;
+/**
+ * Normalize an external hyperlink target for the browser. A stored URL
+ * without a scheme ("paradigm.xyz") would otherwise be resolved relative to
+ * the current page. Prefixes https:// unless the URL already has a scheme
+ * (https:, mailto:, tel:, …), is protocol-relative ("//host"), or is a
+ * fragment/path reference.
+ * @param url
+ * @returns
+ */
+export declare const normalizeExternalUrl: (url: string) => string;
+//# sourceMappingURL=string.d.ts.map

package/dist/cjs/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../string.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAK3E;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,aAAa,KAAG,SAKvD,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,SAAS,MAAM,EACf,UAAS;IACP,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,KACL,aAAa,GAAG,IAuDlB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,uBAEvD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,uBAErD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,MAAM,aAAa,GAAG,IAAI,EAC1B,0BAAwB,EACxB,uBAAqB,EACrB,sBAAoB,EACpB,mBAAiB,KAChB,MAAM,GAAG,IAiBX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,WAAW,MAAM,GAAG,SAAS,EAC7B,OAAO,SAAS,WAUjB,CAAC;AAGF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,GAAG,SAAS,uBASzD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,GAAG,SAAS,uBAgB3D,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,WAI3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,aAAa,EACpB,MAAK,aAAa,GAAG,IAAY,KAChC,SAQF,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,WAKzD,CAAC;AAKF;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,WAY/C,CAAC"}