@rowsncolumns/spreadsheet-state 28.0.66

package/dist/esm/api/intl.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Build a regex for locale grouping separators.
+ */
+export declare const buildGroupRegex: (group: string, global?: boolean) => RegExp;
+/**
+ * Get locale-specific separators and signs used for numeric parsing.
+ */
+export declare const getLocaleSeparators: (locale?: string) => {
+    group: string;
+    decimal: string;
+    minusSign: string;
+    percentSign: string;
+};
+/**
+ * Detect minus sign placement and accounting parentheses support.
+ */
+export declare const getSignInfo: (locale?: string) => {
+    minusSign: string;
+    prefix: boolean;
+    suffix: boolean;
+    allowParens: boolean;
+};
+/**
+ * Detect percent sign placement for the locale.
+ */
+export declare const getPercentSignInfo: (locale?: string) => {
+    sign: string;
+    prefix: boolean;
+    suffix: boolean;
+};
+/**
+ * Derive grouping sizes for the locale (e.g., 3-3 or 3-2-2).
+ */
+export declare const getGroupingInfo: (locale?: string) => {
+    primary: number;
+    secondary: number;
+    group: string;
+} | undefined;
+/**
+ * Map localized digits to ASCII digits for the locale.
+ */
+export declare const getLocaleDigitMap: (locale?: string) => Map<string, string>;
+/**
+ * Validate ISO currency codes using Intl.NumberFormat.
+ */
+export declare const isSupportedCurrencyCode: (code: string) => boolean;
+/**
+ * Collect locale month names (long + short) for disambiguation.
+ */
+export declare const getLocaleMonthNames: (localeCode?: string) => Set<string>;
+//# sourceMappingURL=intl.d.ts.map

package/dist/esm/api/intl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intl.d.ts","sourceRoot":"","sources":["../../../api/intl.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,EAAE,gBAAc,WAK5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM;;;;;CA2ClD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM;eA1E5B,MAAM;YAAU,OAAO;YAAU,OAAO;iBAAe,OAAO;CAqH5E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM;UAtHxC,MAAM;YAAU,OAAO;YAAU,OAAO;CAkJjD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM;aA/JlC,MAAM;eAAa,MAAM;WAAS,MAAM;aAgMpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,wBAkBhD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,YAuBnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,aAAa,MAAM,gBA0BtD,CAAC"}

package/dist/esm/api/intl.js

@@ -0,0 +1,257 @@
+const DEFAULT_GROUP = ",";
+const DEFAULT_DECIMAL = ".";
+const localeSeparatorCache = new Map();
+const groupingInfoCache = new Map();
+const signInfoCache = new Map();
+const percentInfoCache = new Map();
+const digitMapCache = new Map();
+const currencyCodeCache = new Map();
+const monthNameCache = new Map();
+const escapeForRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Build a regex for locale grouping separators.
+ */
+export const buildGroupRegex = (group, global = false) => {
+    if (/\s/.test(group) || group === "\u00A0" || group === "\u202F") {
+        return global ? /[ \u00A0\u202F]/g : /[ \u00A0\u202F]/;
+    }
+    return new RegExp(escapeForRegExp(group), global ? "g" : "");
+};
+/**
+ * Get locale-specific separators and signs used for numeric parsing.
+ */
+export const getLocaleSeparators = (locale) => {
+    if (!locale) {
+        return {
+            group: DEFAULT_GROUP,
+            decimal: DEFAULT_DECIMAL,
+            minusSign: "-",
+            percentSign: "%",
+        };
+    }
+    const cached = localeSeparatorCache.get(locale);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const parts = new Intl.NumberFormat(locale).formatToParts(12345.6);
+        const group = parts.find((part) => part.type === "group")?.value;
+        const decimal = parts.find((part) => part.type === "decimal")?.value;
+        const minusParts = new Intl.NumberFormat(locale).formatToParts(-1);
+        const minusSign = minusParts.find((part) => part.type === "minusSign")?.value;
+        const percentParts = new Intl.NumberFormat(locale, {
+            style: "percent",
+        }).formatToParts(1);
+        const percentSign = percentParts.find((part) => part.type === "percentSign")?.value;
+        const resolved = {
+            group: group ?? DEFAULT_GROUP,
+            decimal: decimal ?? DEFAULT_DECIMAL,
+            minusSign: minusSign ?? "-",
+            percentSign: percentSign ?? "%",
+        };
+        localeSeparatorCache.set(locale, resolved);
+        return resolved;
+    }
+    catch {
+        return {
+            group: DEFAULT_GROUP,
+            decimal: DEFAULT_DECIMAL,
+            minusSign: "-",
+            percentSign: "%",
+        };
+    }
+};
+/**
+ * Detect minus sign placement and accounting parentheses support.
+ */
+export const getSignInfo = (locale) => {
+    const key = locale ?? "__default__";
+    const cached = signInfoCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const { minusSign } = getLocaleSeparators(locale);
+    let prefix = true;
+    let suffix = false;
+    try {
+        const parts = new Intl.NumberFormat(locale).formatToParts(-1);
+        const minusIndex = parts.findIndex((part) => part.type === "minusSign");
+        const integerIndex = parts.findIndex((part) => part.type === "integer");
+        if (minusIndex !== -1 && integerIndex !== -1) {
+            prefix = minusIndex < integerIndex;
+            suffix = minusIndex > integerIndex;
+        }
+    }
+    catch {
+        prefix = true;
+        suffix = false;
+    }
+    let allowParens = false;
+    try {
+        const parts = new Intl.NumberFormat(locale, {
+            style: "currency",
+            currency: "USD",
+            currencySign: "accounting",
+        }).formatToParts(-1);
+        const hasOpen = parts.some((part) => part.type === "literal" && part.value.includes("("));
+        const hasClose = parts.some((part) => part.type === "literal" && part.value.includes(")"));
+        allowParens = hasOpen && hasClose;
+    }
+    catch {
+        allowParens = false;
+    }
+    const info = { minusSign, prefix, suffix, allowParens };
+    signInfoCache.set(key, info);
+    return info;
+};
+/**
+ * Detect percent sign placement for the locale.
+ */
+export const getPercentSignInfo = (locale) => {
+    const key = locale ?? "__default__";
+    const cached = percentInfoCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const { percentSign } = getLocaleSeparators(locale);
+    let prefix = false;
+    let suffix = true;
+    try {
+        const parts = new Intl.NumberFormat(locale, {
+            style: "percent",
+        }).formatToParts(1);
+        const percentIndex = parts.findIndex((part) => part.type === "percentSign");
+        const integerIndex = parts.findIndex((part) => part.type === "integer");
+        if (percentIndex !== -1 && integerIndex !== -1) {
+            prefix = percentIndex < integerIndex;
+            suffix = percentIndex > integerIndex;
+        }
+    }
+    catch {
+        prefix = false;
+        suffix = true;
+    }
+    const info = { sign: percentSign, prefix, suffix };
+    percentInfoCache.set(key, info);
+    return info;
+};
+/**
+ * Derive grouping sizes for the locale (e.g., 3-3 or 3-2-2).
+ */
+export const getGroupingInfo = (locale) => {
+    const key = locale ?? "__default__";
+    const cached = groupingInfoCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const { group } = getLocaleSeparators(locale);
+    if (!group) {
+        return undefined;
+    }
+    try {
+        const formatted = new Intl.NumberFormat(locale, {
+            useGrouping: true,
+        }).format(123456789);
+        const splitRegex = buildGroupRegex(group);
+        const parts = splitRegex
+            ? formatted.split(splitRegex).map((part) => part.replace(/\D/g, ""))
+            : [formatted.replace(/\D/g, "")];
+        if (parts.length <= 1) {
+            return undefined;
+        }
+        const sizes = parts.map((part) => part.length).filter((len) => len > 0);
+        if (sizes.length <= 1) {
+            return undefined;
+        }
+        const primary = sizes[sizes.length - 1];
+        const secondary = sizes.length > 1 ? sizes[sizes.length - 2] : primary;
+        const result = { primary, secondary, group };
+        groupingInfoCache.set(key, result);
+        return result;
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Map localized digits to ASCII digits for the locale.
+ */
+export const getLocaleDigitMap = (locale) => {
+    const key = locale ?? "__default__";
+    const cached = digitMapCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const map = new Map();
+    try {
+        const formatter = new Intl.NumberFormat(locale, { useGrouping: false });
+        for (let i = 0; i <= 9; i += 1) {
+            const formatted = formatter.format(i);
+            map.set(formatted, String(i));
+        }
+    }
+    catch {
+        // Leave map empty to keep ASCII digits as-is.
+    }
+    digitMapCache.set(key, map);
+    return map;
+};
+/**
+ * Validate ISO currency codes using Intl.NumberFormat.
+ */
+export const isSupportedCurrencyCode = (code) => {
+    const normalized = code.toUpperCase();
+    const cached = currencyCodeCache.get(normalized);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (typeof Intl.supportedValuesOf === "function") {
+        const supported = Intl.supportedValuesOf("currency");
+        const isSupported = supported.includes(normalized);
+        currencyCodeCache.set(normalized, isSupported);
+        return isSupported;
+    }
+    try {
+        new Intl.NumberFormat("en", {
+            style: "currency",
+            currency: normalized,
+        });
+        currencyCodeCache.set(normalized, true);
+        return true;
+    }
+    catch {
+        currencyCodeCache.set(normalized, false);
+        return false;
+    }
+};
+/**
+ * Collect locale month names (long + short) for disambiguation.
+ */
+export const getLocaleMonthNames = (localeCode) => {
+    const key = localeCode ?? "__default__";
+    const cached = monthNameCache.get(key);
+    if (cached) {
+        return cached;
+    }
+    const monthSet = new Set();
+    try {
+        const longFormatter = new Intl.DateTimeFormat(localeCode, {
+            month: "long",
+            timeZone: "UTC",
+        });
+        const shortFormatter = new Intl.DateTimeFormat(localeCode, {
+            month: "short",
+            timeZone: "UTC",
+        });
+        for (let i = 0; i < 12; i += 1) {
+            const date = new Date(Date.UTC(2020, i, 1));
+            monthSet.add(longFormatter.format(date).toLowerCase());
+            monthSet.add(shortFormatter.format(date).toLowerCase());
+        }
+    }
+    catch {
+        // Default to empty set.
+    }
+    monthNameCache.set(key, monthSet);
+    return monthSet;
+};

package/dist/esm/api/merges.d.ts

@@ -0,0 +1,7 @@
+import type { GridRange } from "@rowsncolumns/common-types";
+export declare const moveMergedCells: (mergedCells: GridRange[] | undefined | null, op: "column-insert" | "row-insert" | "column-remove" | "row-remove", referenceIndex: number, count?: number, condition?: (area: GridRange) => boolean) => GridRange[] | null | undefined;
+export declare const shrinkMergesOnRowDelete: (merges: GridRange[], deleteStart: number, deleteCount: number) => GridRange[];
+export declare const shrinkMergesOnColumnDelete: (merges: GridRange[], deleteStart: number, deleteCount: number) => GridRange[];
+export declare const expandMergesOnRowInsert: (merges: GridRange[], insertIndex: number, count: number) => GridRange[];
+export declare const expandMergesOnColumnInsert: (merges: GridRange[], insertIndex: number, count: number) => GridRange[];
+//# sourceMappingURL=merges.d.ts.map

package/dist/esm/api/merges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merges.d.ts","sourceRoot":"","sources":["../../../api/merges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAY5D,eAAO,MAAM,eAAe,GAC1B,aAAa,SAAS,EAAE,GAAG,SAAS,GAAG,IAAI,EAC3C,IAAI,eAAe,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,EACnE,gBAAgB,MAAM,EACtB,cAAS,EACT,YAAY,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,mCA2DzC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,aAAa,MAAM,gBA8CpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,SAAS,EAAE,EACnB,aAAa,MAAM,EACnB,OAAO,MAAM,gBAyBd,CAAC"}

package/dist/esm/api/merges.js

@@ -0,0 +1,174 @@
+/**
+ * Move merged cells when user is inserts, deletes row and columns
+ * @param mergedCells
+ * @param mode
+ * @param referenceIndex
+ */
+const isSingleCellMerge = (merge) => merge.startRowIndex === merge.endRowIndex &&
+    merge.startColumnIndex === merge.endColumnIndex;
+export const moveMergedCells = (mergedCells, op, referenceIndex, count = 1, condition) => {
+    if (!mergedCells) {
+        return mergedCells;
+    }
+    const checkCondition = (area) => condition ? condition(area) : true;
+    switch (op) {
+        case "column-insert": {
+            return mergedCells?.map((area) => {
+                if (area.startColumnIndex >= referenceIndex && checkCondition(area)) {
+                    return {
+                        ...area,
+                        startColumnIndex: area.startColumnIndex + count,
+                        endColumnIndex: area.endColumnIndex + count,
+                    };
+                }
+                return area;
+            });
+        }
+        case "row-insert": {
+            return mergedCells?.map((area) => {
+                if (area.startRowIndex >= referenceIndex && checkCondition(area)) {
+                    return {
+                        ...area,
+                        startRowIndex: area.startRowIndex + count,
+                        endRowIndex: area.endRowIndex + count,
+                    };
+                }
+                return area;
+            });
+        }
+        case "column-remove": {
+            return mergedCells?.map((area) => {
+                if (area.startColumnIndex >= referenceIndex && checkCondition(area)) {
+                    return {
+                        ...area,
+                        startColumnIndex: area.startColumnIndex - count,
+                        endColumnIndex: area.endColumnIndex - count,
+                    };
+                }
+                return area;
+            });
+        }
+        case "row-remove": {
+            return mergedCells?.map((area) => {
+                if (area.startRowIndex >= referenceIndex && checkCondition(area)) {
+                    return {
+                        ...area,
+                        startRowIndex: area.startRowIndex - count,
+                        endRowIndex: area.endRowIndex - count,
+                    };
+                }
+                return area;
+            });
+        }
+    }
+};
+export const shrinkMergesOnRowDelete = (merges, deleteStart, deleteCount) => {
+    const deleteEnd = deleteStart + deleteCount - 1;
+    return merges
+        .map((merge) => {
+        const { startRowIndex, endRowIndex } = merge;
+        if (endRowIndex < deleteStart) {
+            return merge;
+        }
+        if (startRowIndex > deleteEnd) {
+            return {
+                ...merge,
+                startRowIndex: startRowIndex - deleteCount,
+                endRowIndex: endRowIndex - deleteCount,
+            };
+        }
+        const rowsRemovedBeforeStart = Math.max(0, Math.min(deleteEnd, startRowIndex - 1) - deleteStart + 1);
+        const overlapStart = Math.max(startRowIndex, deleteStart);
+        const overlapEnd = Math.min(endRowIndex, deleteEnd);
+        const rowsRemovedInside = overlapEnd >= overlapStart ? overlapEnd - overlapStart + 1 : 0;
+        const remainingHeight = endRowIndex - startRowIndex + 1 - rowsRemovedInside;
+        if (remainingHeight <= 0) {
+            return null;
+        }
+        const newStartRowIndex = startRowIndex - rowsRemovedBeforeStart;
+        return {
+            ...merge,
+            startRowIndex: newStartRowIndex,
+            endRowIndex: newStartRowIndex + remainingHeight - 1,
+        };
+    })
+        .filter((merge) => !!merge)
+        .filter((merge) => !isSingleCellMerge(merge));
+};
+export const shrinkMergesOnColumnDelete = (merges, deleteStart, deleteCount) => {
+    const deleteEnd = deleteStart + deleteCount - 1;
+    return merges
+        .map((merge) => {
+        const { startColumnIndex, endColumnIndex } = merge;
+        if (endColumnIndex < deleteStart) {
+            return merge;
+        }
+        if (startColumnIndex > deleteEnd) {
+            return {
+                ...merge,
+                startColumnIndex: startColumnIndex - deleteCount,
+                endColumnIndex: endColumnIndex - deleteCount,
+            };
+        }
+        const colsRemovedBeforeStart = Math.max(0, Math.min(deleteEnd, startColumnIndex - 1) - deleteStart + 1);
+        const overlapStart = Math.max(startColumnIndex, deleteStart);
+        const overlapEnd = Math.min(endColumnIndex, deleteEnd);
+        const colsRemovedInside = overlapEnd >= overlapStart ? overlapEnd - overlapStart + 1 : 0;
+        const remainingWidth = endColumnIndex - startColumnIndex + 1 - colsRemovedInside;
+        if (remainingWidth <= 0) {
+            return null;
+        }
+        const newStartColumnIndex = startColumnIndex - colsRemovedBeforeStart;
+        return {
+            ...merge,
+            startColumnIndex: newStartColumnIndex,
+            endColumnIndex: newStartColumnIndex + remainingWidth - 1,
+        };
+    })
+        .filter((merge) => !!merge)
+        .filter((merge) => !isSingleCellMerge(merge));
+};
+export const expandMergesOnRowInsert = (merges, insertIndex, count) => {
+    return merges
+        .map((merge) => {
+        const { startRowIndex, endRowIndex } = merge;
+        if (endRowIndex < insertIndex) {
+            return merge;
+        }
+        if (startRowIndex >= insertIndex) {
+            return {
+                ...merge,
+                startRowIndex: startRowIndex + count,
+                endRowIndex: endRowIndex + count,
+            };
+        }
+        // Insertion happens inside merge; extend its height
+        return {
+            ...merge,
+            endRowIndex: endRowIndex + count,
+        };
+    })
+        .filter((merge) => !isSingleCellMerge(merge));
+};
+export const expandMergesOnColumnInsert = (merges, insertIndex, count) => {
+    return merges
+        .map((merge) => {
+        const { startColumnIndex, endColumnIndex } = merge;
+        if (endColumnIndex < insertIndex) {
+            return merge;
+        }
+        if (startColumnIndex >= insertIndex) {
+            return {
+                ...merge,
+                startColumnIndex: startColumnIndex + count,
+                endColumnIndex: endColumnIndex + count,
+            };
+        }
+        // Insertion happens inside merge; extend its width
+        return {
+            ...merge,
+            endColumnIndex: endColumnIndex + count,
+        };
+    })
+        .filter((merge) => !isSingleCellMerge(merge));
+};

package/dist/esm/api/outline.d.ts

@@ -0,0 +1,33 @@
+import type { DimensionProperties } from "@rowsncolumns/spreadsheet";
+/**
+ * Convert a sorted array of indices into contiguous half-open spans.
+ * `[3,4,5,8,9]` → `[{start:3,end:5},{start:8,end:9}]`. Used by group /
+ * ungroup hooks to handle multi-selection where the user lassoed
+ * non-adjacent rows.
+ */
+export declare const contiguousSpans: (sortedIndexes: number[]) => {
+    start: number;
+    end: number;
+}[];
+export declare const clampOutlineLevel: (level: number) => number;
+/**
+ * Given a SUMMARY row/column index, find the contiguous span of
+ * neighbour indices that belong to the group it summarizes. Returns
+ * `undefined` when `summaryIndex` doesn't sit adjacent to any
+ * higher-level outline rows on the expected side.
+ *
+ * @param summaryBelow `true` → group sits ABOVE the summary (Excel
+ *                    default). `false` → group sits BELOW.
+ */
+export declare const findGroupAtSummary: (metadata: Array<DimensionProperties | null | undefined> | undefined | null, summaryIndex: number, summaryBelow: boolean) => {
+    startIndex: number;
+    endIndex: number;
+    level: number;
+} | undefined;
+export declare const resolveSummaryBelow: (outlinePr?: {
+    summaryBelow?: boolean | null;
+}) => boolean;
+export declare const resolveSummaryRight: (outlinePr?: {
+    summaryRight?: boolean | null;
+}) => boolean;
+//# sourceMappingURL=outline.d.ts.map

package/dist/esm/api/outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../api/outline.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAWrE;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,eAAe,MAAM,EAAE;WAC/B,MAAM;SAAO,MAAM;GAU1C,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,WACc,CAAC;AAE9D;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,KAAK,CAAC,mBAAmB,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GAAG,IAAI,EAC1E,cAAc,MAAM,EACpB,cAAc,OAAO,KACpB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAe5D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,YAAY;IAC9C,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B,YAA+D,CAAC;AAEjE,eAAO,MAAM,mBAAmB,GAAI,YAAY;IAC9C,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B,YAA+D,CAAC"}

package/dist/esm/api/outline.js

@@ -0,0 +1,56 @@
+// Outline (row/column grouping) helpers — kept here so both the row
+// and column flavors of the hooks can share the math. Pure functions
+// that consume `Sparse<DimensionProperties>[]` style arrays.
+const MAX_OUTLINE_LEVEL = 7;
+const SUMMARY_BELOW_DEFAULT = true;
+const SUMMARY_RIGHT_DEFAULT = true;
+const levelAt = (metadata, index) => metadata?.[index]?.outlineLevel ?? 0;
+/**
+ * Convert a sorted array of indices into contiguous half-open spans.
+ * `[3,4,5,8,9]` → `[{start:3,end:5},{start:8,end:9}]`. Used by group /
+ * ungroup hooks to handle multi-selection where the user lassoed
+ * non-adjacent rows.
+ */
+export const contiguousSpans = (sortedIndexes) => {
+    const spans = [];
+    for (const idx of sortedIndexes) {
+        const last = spans[spans.length - 1];
+        if (last && idx === last.end + 1) {
+            last.end = idx;
+        }
+        else {
+            spans.push({ start: idx, end: idx });
+        }
+    }
+    return spans;
+};
+export const clampOutlineLevel = (level) => Math.max(0, Math.min(MAX_OUTLINE_LEVEL, Math.trunc(level)));
+/**
+ * Given a SUMMARY row/column index, find the contiguous span of
+ * neighbour indices that belong to the group it summarizes. Returns
+ * `undefined` when `summaryIndex` doesn't sit adjacent to any
+ * higher-level outline rows on the expected side.
+ *
+ * @param summaryBelow `true` → group sits ABOVE the summary (Excel
+ *                    default). `false` → group sits BELOW.
+ */
+export const findGroupAtSummary = (metadata, summaryIndex, summaryBelow) => {
+    if (!metadata)
+        return undefined;
+    // Children are at a strictly-deeper outline level. The summary's
+    // own level is whatever happens to be there (often 0).
+    const direction = summaryBelow ? -1 : 1;
+    const firstChildIndex = summaryIndex + direction;
+    const firstChildLevel = levelAt(metadata, firstChildIndex);
+    if (firstChildLevel === 0)
+        return undefined;
+    let cursor = firstChildIndex;
+    while (levelAt(metadata, cursor + direction) >= firstChildLevel) {
+        cursor += direction;
+    }
+    const startIndex = Math.min(firstChildIndex, cursor);
+    const endIndex = Math.max(firstChildIndex, cursor);
+    return { startIndex, endIndex, level: firstChildLevel };
+};
+export const resolveSummaryBelow = (outlinePr) => outlinePr?.summaryBelow !== false && SUMMARY_BELOW_DEFAULT;
+export const resolveSummaryRight = (outlinePr) => outlinePr?.summaryRight !== false && SUMMARY_RIGHT_DEFAULT;

package/dist/esm/api/parse-html.d.ts

@@ -0,0 +1,15 @@
+import type { CellInterface, GridRange } from "@rowsncolumns/common-types";
+import type { CellData, EmbeddedObject } from "@rowsncolumns/spreadsheet";
+import type { UseSpreadsheetProps } from "../hooks/use-spreadsheet-state";
+export declare const parseHtml: (clipboardValue: string, plainTextValue: string | undefined, activeCell: CellInterface, sheetId: number, preserveFormatting?: boolean, idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"], locale?: string, sanitizeHtml?: (html: string) => string) => Promise<{
+    results: (CellData | null | undefined)[][];
+    merges: GridRange[];
+    embeds: EmbeddedObject[];
+    rowHeights: number[];
+    columnWidths: number[];
+}>;
+export declare function extractTextContent(element: Element | Node): string;
+export declare const extractColor: (color: string | undefined | null) => string | undefined;
+export declare const getEmbedFromImageUrl: (imageUrl: string | undefined | null, sheetId: number, activeCell: CellInterface, idCreationStrategy?: UseSpreadsheetProps["idCreationStrategy"]) => Promise<EmbeddedObject | undefined>;
+export declare const convertTableToArrayOfNodes: (node: Element) => readonly [NodeListOf<HTMLTableRowElement>, (HTMLTableCellElement | null)[][]];
+//# sourceMappingURL=parse-html.d.ts.map

package/dist/esm/api/parse-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-html.d.ts","sourceRoot":"","sources":["../../../api/parse-html.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EAEV,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,QAAQ,EACR,cAAc,EAGf,MAAM,2BAA2B,CAAC;AAWnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAgE1E,eAAO,MAAM,SAAS,GACpB,gBAAgB,MAAM,EACtB,gBAAgB,MAAM,GAAG,SAAS,EAClC,YAAY,aAAa,EACzB,SAAS,MAAM,EACf,qBAAqB,OAAO,EAC5B,qBAAqB,mBAAmB,CAAC,oBAAoB,CAAC,EAC9D,SAAS,MAAM,EACf,eAAe,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;EAoDxC,CAAC;AAumBF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CAuBlE;AAgOD,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,SAAS,GAAG,IAAI,uBAY5D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,MAAM,GAAG,SAAS,GAAG,IAAI,EACnC,SAAS,MAAM,EACf,YAAY,aAAa,EACzB,qBAAqB,mBAAmB,CAAC,oBAAoB,CAAC,wCA2B/D,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,MAAM,OAAO,kFA2CvD,CAAC"}