@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/components/print-preview/settings.js

@@ -0,0 +1,227 @@
+// Print-preview settings model + paper/margin constants.
+//
+// All page dimensions are CSS px at 96 DPI — matches the conversion the
+// browser uses when emitting `@page { size: <px> <px> }`. Keeping units
+// consistent here means the screen-side preview blocks and the
+// print-side iframe both lay out from the same numbers.
+export const DPI = 96;
+const inches = (n) => Math.round(n * DPI);
+const mm = (n) => Math.round((n / 25.4) * DPI);
+const explicitInch = (w, h) => `${w}in ${h}in`;
+export const PAPER_SIZES = {
+    letter: {
+        id: "letter",
+        label: 'Letter (8.5" × 11")',
+        width: inches(8.5),
+        height: inches(11),
+        pageSize: "letter",
+    },
+    tabloid: {
+        id: "tabloid",
+        label: 'Tabloid (11" × 17")',
+        width: inches(11),
+        height: inches(17),
+        pageSize: explicitInch(11, 17),
+    },
+    legal: {
+        id: "legal",
+        label: 'Legal (8.5" × 14")',
+        width: inches(8.5),
+        height: inches(14),
+        pageSize: "legal",
+    },
+    statement: {
+        id: "statement",
+        label: 'Statement (5.5" × 8.5")',
+        width: inches(5.5),
+        height: inches(8.5),
+        pageSize: explicitInch(5.5, 8.5),
+    },
+    executive: {
+        id: "executive",
+        label: 'Executive (7.25" × 10.5")',
+        width: inches(7.25),
+        height: inches(10.5),
+        pageSize: explicitInch(7.25, 10.5),
+    },
+    folio: {
+        id: "folio",
+        label: 'Folio (8.5" × 13")',
+        width: inches(8.5),
+        height: inches(13),
+        pageSize: explicitInch(8.5, 13),
+    },
+    a3: {
+        id: "a3",
+        label: 'A3 (11.69" × 16.54")',
+        width: mm(297),
+        height: mm(420),
+        pageSize: "A3",
+    },
+    a4: {
+        id: "a4",
+        label: 'A4 (8.27" × 11.69")',
+        width: mm(210),
+        height: mm(297),
+        pageSize: "A4",
+    },
+    a5: {
+        id: "a5",
+        label: 'A5 (5.83" × 8.27")',
+        width: mm(148),
+        height: mm(210),
+        pageSize: "A5",
+    },
+    b4: {
+        id: "b4",
+        label: 'B4 (9.84" × 13.90")',
+        width: mm(250),
+        height: mm(353),
+        pageSize: "B4",
+    },
+    b5: {
+        id: "b5",
+        label: 'B5 (6.93" × 9.84")',
+        width: mm(176),
+        height: mm(250),
+        pageSize: "B5",
+    },
+};
+// Google Sheets defaults — matched per their print dialog. Custom is
+// stored in the settings object directly; the preset id is just for
+// the sidebar's radio group.
+export const MARGIN_PRESETS = {
+    normal: {
+        top: inches(0.75),
+        right: inches(0.7),
+        bottom: inches(0.75),
+        left: inches(0.7),
+    },
+    narrow: {
+        top: inches(0.25),
+        right: inches(0.25),
+        bottom: inches(0.25),
+        left: inches(0.25),
+    },
+    wide: {
+        top: inches(1),
+        right: inches(1),
+        bottom: inches(1),
+        left: inches(1),
+    },
+};
+export const DEFAULT_PRINT_SETTINGS = {
+    paperSize: "letter",
+    orientation: "portrait",
+    scaleMode: "100",
+    customScale: 1,
+    marginPreset: "normal",
+    customMargins: MARGIN_PRESETS.normal,
+    scope: "current-sheet",
+    showGridlines: true,
+    showNotes: false,
+    pageOrder: "over-then-down",
+    horizontalAlignment: "left",
+    verticalAlignment: "top",
+    headerFooter: {
+        pageNumbers: false,
+        workbookTitle: false,
+        sheetName: false,
+        currentDate: false,
+        currentTime: false,
+    },
+    repeatFrozenRows: false,
+    repeatFrozenColumns: false,
+};
+/**
+ * True when any header / footer field is enabled. Drives content-area
+ * sizing — we carve a fixed strip out of the page only when there's
+ * something to draw there.
+ */
+export const hasHeaderFooter = (settings) => {
+    const f = settings.headerFooter;
+    return (f.pageNumbers ||
+        f.workbookTitle ||
+        f.sheetName ||
+        f.currentDate ||
+        f.currentTime);
+};
+/** Fixed strip heights in CSS pixels. */
+export const HEADER_STRIP_HEIGHT = 28;
+export const FOOTER_STRIP_HEIGHT = 28;
+/**
+ * Resolve the active margin box. Falls back to Normal when an unknown
+ * preset id slips in (shouldn't happen in practice, but defends the
+ * pagination math from NaN width/height).
+ */
+export const resolveMargins = (settings) => {
+    if (settings.marginPreset === "custom")
+        return settings.customMargins;
+    return MARGIN_PRESETS[settings.marginPreset] ?? MARGIN_PRESETS.normal;
+};
+/**
+ * Resolve the outer page rectangle (paper size + orientation), in CSS
+ * pixels. Used both by the on-screen preview blocks and by the print
+ * stylesheet's `@page size`.
+ *
+ * `@page { size }` accepts `<keyword> landscape` (`letter landscape`,
+ * `A4 landscape`, …) but NOT `<W>in <H>in landscape`. For papers that
+ * already use explicit dimensions (Tabloid / Statement / Executive /
+ * Folio — no portable CSS keyword), we swap the two numbers manually
+ * in landscape rather than appending the keyword.
+ */
+export const resolvePageDimensions = (settings) => {
+    const paper = PAPER_SIZES[settings.paperSize] ?? PAPER_SIZES.letter;
+    const isExplicit = /\d/.test(paper.pageSize);
+    if (settings.orientation === "landscape") {
+        const swapped = isExplicit
+            ? paper.pageSize.replace(/^(\S+)\s+(\S+)$/, "$2 $1")
+            : `${paper.pageSize} landscape`;
+        return {
+            width: paper.height,
+            height: paper.width,
+            sizeKeyword: swapped,
+        };
+    }
+    return {
+        width: paper.width,
+        height: paper.height,
+        sizeKeyword: paper.pageSize,
+    };
+};
+/**
+ * Reserved px on each axis for the trailing cell border. With
+ * `border-collapse: collapse` the last row's bottom edge straddles
+ * the table's outer boundary (half inside the cell box, half
+ * outside); without this reserve `overflow: hidden` on the page-block
+ * content area clips the outer half and the closing line disappears.
+ *
+ * 1 px is enough now that `PageBlock` wraps every cell's content in a
+ * fixed-height div — without that wrapper, oversized content (e.g. a
+ * 48 pt glyph in a 20 px row) auto-grew the row past its declared
+ * height, the table extended past `block.height`, and the reserve
+ * had to absorb that whole overflow. We solved that at the root, so
+ * this stays at the bare CSS border allowance.
+ */
+const BORDER_RESERVE_PX = 1;
+/**
+ * Usable content rectangle inside one page = paper minus margins
+ * minus optional header/footer strips, minus a small reserve for the
+ * trailing cell border. The pagination engine walks rows/columns
+ * against this box.
+ */
+export const resolveContentArea = (settings) => {
+    const page = resolvePageDimensions(settings);
+    const margins = resolveMargins(settings);
+    const headerFooterReserve = hasHeaderFooter(settings)
+        ? HEADER_STRIP_HEIGHT + FOOTER_STRIP_HEIGHT
+        : 0;
+    return {
+        width: Math.max(0, page.width - margins.left - margins.right - BORDER_RESERVE_PX),
+        height: Math.max(0, page.height -
+            margins.top -
+            margins.bottom -
+            headerFooterReserve -
+            BORDER_RESERVE_PX),
+    };
+};

package/dist/esm/components/print-preview/use-page-layout.d.ts

@@ -0,0 +1,60 @@
+export type PageBlock = {
+    index: number;
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+    /** Sum of column widths in the block, in unscaled CSS px. */
+    width: number;
+    /** Sum of row heights in the block, in unscaled CSS px. */
+    height: number;
+};
+export type PageOrder = "over-then-down" | "down-then-over";
+export type PageLayoutInput = {
+    startRow: number;
+    endRow: number;
+    startColumn: number;
+    endColumn: number;
+    getColumnWidth: (columnIndex: number) => number;
+    getRowHeight: (rowIndex: number) => number;
+    contentWidth: number;
+    contentHeight: number;
+    scale: number;
+    /**
+     * "over-then-down" (Excel `overThenDown`) walks left-to-right then
+     * down. "down-then-over" walks vertically within a column band
+     * before moving to the next column band — Excel's default.
+     * @default "over-then-down"
+     */
+    pageOrder?: PageOrder;
+    /**
+     * Number of frozen rows/columns to reserve. They're subtracted from
+     * the band's usable content area on every page so the same frozen
+     * cells repeat on each page. Pagination then walks the
+     * NON-frozen body. Set to 0 to disable.
+     */
+    repeatRows?: number;
+    repeatColumns?: number;
+};
+export declare const computePageLayout: (input: PageLayoutInput) => PageBlock[];
+/**
+ * Total natural width / height of the print range (unscaled). Used by
+ * the "Fit to width" / "Fit to page" scale modes to compute a scale
+ * factor before laying out.
+ */
+export declare const measureRange: (startRow: number, endRow: number, startColumn: number, endColumn: number, getColumnWidth: (i: number) => number, getRowHeight: (i: number) => number) => {
+    width: number;
+    height: number;
+};
+/**
+ * Resolve the effective scale factor for the active scale mode.
+ *   `100`       → 1
+ *   `custom`    → settings.customScale (clamped to 0.1..4 by the UI)
+ *   `fit-width` → contentWidth / rangeWidth (capped at 1 — never upsize)
+ *   `fit-page`  → min of width-fit and height-fit
+ *
+ * Returns 1 when range dimensions are zero (empty sheet) to avoid
+ * divide-by-zero and infinite scale.
+ */
+export declare const resolveScale: (mode: "100" | "fit-width" | "fit-page" | "custom", customScale: number, rangeWidth: number, rangeHeight: number, contentWidth: number, contentHeight: number) => number;
+//# sourceMappingURL=use-page-layout.d.ts.map

package/dist/esm/components/print-preview/use-page-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-page-layout.d.ts","sourceRoot":"","sources":["../../../../components/print-preview/use-page-layout.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,SAAS,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG,gBAAgB,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AA2CF,eAAO,MAAM,iBAAiB,GAAI,OAAO,eAAe,KAAG,SAAS,EAwEnE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,aAAa,MAAM,EACnB,WAAW,MAAM,EACjB,gBAAgB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACrC,cAAc,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,KAClC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAMjC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,QAAQ,EACjD,aAAa,MAAM,EACnB,YAAY,MAAM,EAClB,aAAa,MAAM,EACnB,cAAc,MAAM,EACpB,eAAe,MAAM,KACpB,MAmBF,CAAC"}

package/dist/esm/components/print-preview/use-page-layout.js

@@ -0,0 +1,133 @@
+// Pagination math for print preview.
+//
+// Given the sheet's column widths + row heights and the page content
+// rectangle, produce a sequence of "page blocks" — each block being a
+// rectangular slice of the sheet that fits on one printed page. We
+// also expose the cumulative offsets so the on-screen preview can
+// position each block without re-summing.
+//
+// Strategy: greedy down-then-over (Excel's `pageOrder = "downThenOver"`
+// default). Iterate column-bands across the sheet; for each band,
+// iterate row-bands top to bottom. Page index walks row-bands within a
+// column-band first, mirroring Excel. The opposite order would be a
+// trivial swap if/when we add the `overThenDown` toggle.
+/**
+ * Slice the [startColumn..endColumn] range into bands such that each
+ * band's summed (scaled) width fits inside `contentWidth`. A single
+ * column wider than the page still gets its own band — splitting a
+ * column across pages isn't a thing Excel does either, the column
+ * just overflows.
+ *
+ * `EPSILON` covers sub-pixel float drift from accumulating
+ * `getSize(i) * scale` across many cells. Without it, "Fit to width"
+ * regularly ends with a tiny residual (`bandSize + cellSize` lands at
+ * e.g. `682.0000001 > 682`) that closes the band one column too
+ * early, spilling the last column onto its own page.
+ */
+const EPSILON = 0.5;
+const sliceAxis = (start, end, getSize, limit, scale) => {
+    const bands = [];
+    if (start > end || limit <= 0)
+        return bands;
+    let bandStart = start;
+    let bandSize = 0;
+    for (let i = start; i <= end; i++) {
+        const cellSize = getSize(i) * scale;
+        if (i > bandStart && bandSize + cellSize > limit + EPSILON) {
+            bands.push({ start: bandStart, end: i - 1, size: bandSize });
+            bandStart = i;
+            bandSize = cellSize;
+        }
+        else {
+            bandSize += cellSize;
+        }
+    }
+    bands.push({ start: bandStart, end, size: bandSize });
+    return bands;
+};
+export const computePageLayout = (input) => {
+    const { startRow, endRow, startColumn, endColumn, getColumnWidth, getRowHeight, contentWidth, contentHeight, scale, pageOrder = "over-then-down", repeatRows = 0, repeatColumns = 0, } = input;
+    // Sum the frozen rows/cols once — they always render at the top /
+    // left of every page, eating into the available content box.
+    let frozenRowHeight = 0;
+    const frozenRowEnd = Math.min(endRow, startRow + repeatRows - 1);
+    for (let r = startRow; r <= frozenRowEnd; r++) {
+        frozenRowHeight += getRowHeight(r) * scale;
+    }
+    let frozenColumnWidth = 0;
+    const frozenColEnd = Math.min(endColumn, startColumn + repeatColumns - 1);
+    for (let c = startColumn; c <= frozenColEnd; c++) {
+        frozenColumnWidth += getColumnWidth(c) * scale;
+    }
+    const bodyStartRow = startRow + repeatRows;
+    const bodyStartColumn = startColumn + repeatColumns;
+    const remainingWidth = Math.max(0, contentWidth - frozenColumnWidth);
+    const remainingHeight = Math.max(0, contentHeight - frozenRowHeight);
+    const columnBands = sliceAxis(bodyStartColumn, endColumn, getColumnWidth, remainingWidth, scale);
+    const rowBands = sliceAxis(bodyStartRow, endRow, getRowHeight, remainingHeight, scale);
+    const blocks = [];
+    let index = 0;
+    // Outer/inner loop selection toggles between "down-then-over"
+    // (column bands outer, Excel's default) and "over-then-down" (row
+    // bands outer, Google Sheets' default).
+    const outer = pageOrder === "down-then-over" ? columnBands : rowBands;
+    const inner = pageOrder === "down-then-over" ? rowBands : columnBands;
+    for (const o of outer) {
+        for (const i of inner) {
+            const colBand = pageOrder === "down-then-over" ? o : i;
+            const rowBand = pageOrder === "down-then-over" ? i : o;
+            blocks.push({
+                index: index++,
+                startRow: rowBand.start,
+                endRow: rowBand.end,
+                startColumn: colBand.start,
+                endColumn: colBand.end,
+                width: colBand.size + frozenColumnWidth,
+                height: rowBand.size + frozenRowHeight,
+            });
+        }
+    }
+    return blocks;
+};
+/**
+ * Total natural width / height of the print range (unscaled). Used by
+ * the "Fit to width" / "Fit to page" scale modes to compute a scale
+ * factor before laying out.
+ */
+export const measureRange = (startRow, endRow, startColumn, endColumn, getColumnWidth, getRowHeight) => {
+    let width = 0;
+    for (let c = startColumn; c <= endColumn; c++)
+        width += getColumnWidth(c);
+    let height = 0;
+    for (let r = startRow; r <= endRow; r++)
+        height += getRowHeight(r);
+    return { width, height };
+};
+/**
+ * Resolve the effective scale factor for the active scale mode.
+ *   `100`       → 1
+ *   `custom`    → settings.customScale (clamped to 0.1..4 by the UI)
+ *   `fit-width` → contentWidth / rangeWidth (capped at 1 — never upsize)
+ *   `fit-page`  → min of width-fit and height-fit
+ *
+ * Returns 1 when range dimensions are zero (empty sheet) to avoid
+ * divide-by-zero and infinite scale.
+ */
+export const resolveScale = (mode, customScale, rangeWidth, rangeHeight, contentWidth, contentHeight) => {
+    switch (mode) {
+        case "100":
+            return 1;
+        case "custom":
+            return customScale > 0 ? customScale : 1;
+        case "fit-width": {
+            if (rangeWidth <= 0)
+                return 1;
+            return Math.min(1, contentWidth / rangeWidth);
+        }
+        case "fit-page": {
+            if (rangeWidth <= 0 || rangeHeight <= 0)
+                return 1;
+            return Math.min(1, contentWidth / rangeWidth, contentHeight / rangeHeight);
+        }
+    }
+};

package/dist/esm/components/range-selector/index.d.ts

@@ -0,0 +1,25 @@
+import type { CellInterface, GridRange, SelectionArea } from "@rowsncolumns/grid";
+import React from "react";
+import type { NamedRange, Sheet, TableView } from "../../types";
+import type { CanvasGridProps, SelectionAttributes } from "../canvas-grid/typings";
+type NamedRangeSelectorProps<S extends Sheet> = {
+    activeCell: CellInterface;
+    selections?: SelectionArea<SelectionAttributes>[];
+    sheets?: S[];
+    namedRanges?: NamedRange[];
+    tables?: TableView[];
+    sheetId: number;
+    merges?: GridRange[] | null;
+    onChangeActiveCell: CanvasGridProps["onChangeActiveCell"];
+    onChangeSelections: CanvasGridProps["onChangeSelections"];
+    onChangeActiveSheet?: CanvasGridProps["onChangeActiveSheet"];
+    onDeleteNamedRange?: (id: NamedRange["namedRangeId"]) => void;
+    onRequestDefineNamedRange?: CanvasGridProps["onRequestDefineNamedRange"];
+    onRequestUpdateNamedRange?: (sheetId: number, namedRange: NamedRange) => void;
+    rowCount?: number;
+    columnCount?: number;
+};
+declare function RangeSelectorComponent<S extends Sheet>({ namedRanges, tables, sheets, merges, selections, activeCell, rowCount, columnCount, sheetId, onChangeActiveSheet, onChangeActiveCell, onChangeSelections, onRequestUpdateNamedRange, onDeleteNamedRange, onRequestDefineNamedRange, }: NamedRangeSelectorProps<S>): React.JSX.Element;
+export declare const RangeSelector: typeof RangeSelectorComponent;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/range-selector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../components/range-selector/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,aAAa,EACd,MAAM,oBAAoB,CAAC;AAiC5B,OAAO,KAAyD,MAAM,OAAO,CAAC;AAU9E,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAc,SAAS,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAEhC,KAAK,uBAAuB,CAAC,CAAC,SAAS,KAAK,IAAI;IAC9C,UAAU,EAAE,aAAa,CAAC;IAC1B,UAAU,CAAC,EAAE,aAAa,CAAC,mBAAmB,CAAC,EAAE,CAAC;IAClD,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;IACb,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAC5B,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,CAAC;IAC1D,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,CAAC;IAC1D,mBAAmB,CAAC,EAAE,eAAe,CAAC,qBAAqB,CAAC,CAAC;IAC7D,kBAAkB,CAAC,EAAE,CAAC,EAAE,EAAE,UAAU,CAAC,cAAc,CAAC,KAAK,IAAI,CAAC;IAC9D,yBAAyB,CAAC,EAAE,eAAe,CAAC,2BAA2B,CAAC,CAAC;IACzE,yBAAyB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAoLF,iBAAS,sBAAsB,CAAC,CAAC,SAAS,KAAK,EAAE,EAC/C,WAA2B,EAC3B,MAAsB,EACtB,MAAsB,EACtB,MAAM,EACN,UAA0B,EAC1B,UAAU,EACV,QAAwB,EACxB,WAA8B,EAC9B,OAAO,EACP,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,yBAAyB,GAC1B,EAAE,uBAAuB,CAAC,CAAC,CAAC,qBAyN5B;AAED,eAAO,MAAM,aAAa,EAErB,OAAO,sBAAsB,CAAC"}