@rowsncolumns/spreadsheet 10.2.68

package/dist/cjs/components/cell/cell-text-runs.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CellTextRuns = exports.computeSegmentTop = exports.computeLineMetrics = exports.resolveSegmentStyle = void 0;
+var tslib_1 = require("tslib");
+var react_1 = tslib_1.__importStar(require("react"));
+var react_konva_1 = require("react-konva");
+var themes_1 = require("../../themes");
+var rich_text_1 = require("./rich-text");
+var BASELINE_OFFSET_FONT_SCALE = 0.58;
+/**
+ * Canvas `ctx.font` takes CSS font shorthand — a family name that needs
+ * quoting (leading digit, slash, etc.) makes the whole assignment
+ * silently no-op, leaving the PREVIOUS segment's font active. Quote
+ * anything that isn't a single safe identifier; generic families
+ * (sans-serif, serif, …) must stay unquoted to keep their generic
+ * meaning.
+ */
+var toCssFontFamily = function (family) {
+    return family
+        .split(",")
+        .map(function (part) {
+        var trimmed = part.trim().replace(/^["']|["']$/g, "");
+        if (!trimmed)
+            return "";
+        return /^[a-zA-Z][a-zA-Z0-9-]*$/.test(trimmed)
+            ? trimmed
+            : "\"".concat(trimmed.replace(/"/g, ""), "\"");
+    })
+        .filter(Boolean)
+        .join(", ");
+};
+var buildFontString = function (r) {
+    var style = r.italic ? "italic" : "normal";
+    var weight = r.bold ? "bold" : "normal";
+    var family = r.fontFamily
+        ? "".concat(toCssFontFamily(r.fontFamily), ", sans-serif")
+        : "sans-serif";
+    return "".concat(style, " ").concat(weight, " ").concat(r.fontSize, "px ").concat(family);
+};
+/**
+ * Merge one segment's format overrides onto the resolved base style.
+ * Exported for unit tests; the sceneFunc below is the only runtime
+ * caller. `base.fontSize` is the un-scaled pixel size — when the
+ * merged style carries a `baselineOffset` (own or inherited from the
+ * base) the sup/sub font scale is applied here, exactly once.
+ */
+var resolveSegmentStyle = function (seg, base, theme) {
+    var _a, _b, _c, _d, _e, _f;
+    var f = seg.format;
+    var baselineOffset = (_a = f.baselineOffset) !== null && _a !== void 0 ? _a : base.baselineOffset;
+    var fontSize = typeof f.fontSize === "number"
+        ? (f.fontSize / pointFromPx(base.fontSize)) * base.fontSize
+        : base.fontSize;
+    return {
+        bold: (_b = f.bold) !== null && _b !== void 0 ? _b : base.bold,
+        italic: (_c = f.italic) !== null && _c !== void 0 ? _c : base.italic,
+        underline: (_d = f.underline) !== null && _d !== void 0 ? _d : base.underline,
+        strikethrough: (_e = f.strikethrough) !== null && _e !== void 0 ? _e : base.strikethrough,
+        color: f.color != null
+            ? (0, themes_1.getStringifiedColor)(f.color, theme) || base.color
+            : base.color,
+        fontFamily: (_f = f.fontFamily) !== null && _f !== void 0 ? _f : base.fontFamily,
+        // f.fontSize is in points to mirror the editor's TextFormat type,
+        // but at this paint layer everything is in pixels — scale ratio is
+        // applied by the caller via baseFontSize. For per-segment override
+        // we keep the relative point→px ratio from the cell base.
+        fontSize: baselineOffset
+            ? fontSize * BASELINE_OFFSET_FONT_SCALE
+            : fontSize,
+        baselineOffset: baselineOffset,
+    };
+};
+exports.resolveSegmentStyle = resolveSegmentStyle;
+/** Inverse of pointToPixel — used only when computing a per-segment scale. */
+var pointFromPx = function (px) { return px / 1.3333; };
+/**
+ * Fraction of the em box above the alphabetic baseline for typical
+ * Latin fonts. Used to baseline-align mixed-size runs on one line:
+ * with `textBaseline="top"`, a run's baseline sits ~`fontSize * 0.8`
+ * below its draw y, so smaller runs shift down by
+ * `(lineFontSize - runFontSize) * 0.8` to share the line's baseline —
+ * matching how Excel lays out mixed-size rich text.
+ */
+var ALPHABETIC_BASELINE_RATIO = 0.8;
+/**
+ * Per-line box metrics for a resolved rich-text block. Exported for
+ * unit tests; the sceneFunc below is the only runtime caller.
+ */
+var computeLineMetrics = function (resolvedLines, baseFontSize, lineHeight) {
+    var lineFontSizes = resolvedLines.map(function (rl) {
+        return rl.length ? Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(rl.map(function (_a) {
+            var r = _a.r;
+            return r.fontSize;
+        })), false)) : baseFontSize;
+    });
+    var lineHeights = lineFontSizes.map(function (fs) { return fs * lineHeight; });
+    var totalHeight = lineHeights.reduce(function (a, b) { return a + b; }, 0);
+    return { lineFontSizes: lineFontSizes, lineHeights: lineHeights, totalHeight: totalHeight };
+};
+exports.computeLineMetrics = computeLineMetrics;
+/**
+ * Vertical draw position (textBaseline="top") for one segment within
+ * its line box. Normal runs share the line's alphabetic baseline
+ * (smaller runs shift down), superscript hugs the line top, subscript
+ * hugs the line bottom. All three reduce to `lineTop` when the run's
+ * size equals the line's. Exported for unit tests.
+ */
+var computeSegmentTop = function (lineTop, lineFontSize, segFontSize, baselineOffset) {
+    if (baselineOffset === "superscript")
+        return lineTop;
+    if (baselineOffset === "subscript") {
+        return lineTop + (lineFontSize - segFontSize);
+    }
+    return lineTop + (lineFontSize - segFontSize) * ALPHABETIC_BASELINE_RATIO;
+};
+exports.computeSegmentTop = computeSegmentTop;
+/**
+ * Sum of advance widths of a single line of resolved segments, using
+ * the supplied context's `measureText`. Mutates ctx font as it walks
+ * but the caller is expected to reset it after.
+ */
+var measureLineWidth = function (ctx, lineSegments) {
+    var e_1, _a;
+    var total = 0;
+    try {
+        for (var lineSegments_1 = tslib_1.__values(lineSegments), lineSegments_1_1 = lineSegments_1.next(); !lineSegments_1_1.done; lineSegments_1_1 = lineSegments_1.next()) {
+            var _b = lineSegments_1_1.value, seg = _b.seg, r = _b.r;
+            ctx.setAttr("font", buildFontString(r));
+            total += ctx.measureText(seg.text).width;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (lineSegments_1_1 && !lineSegments_1_1.done && (_a = lineSegments_1.return)) _a.call(lineSegments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return total;
+};
+/**
+ * Word-wrap one input line into multiple render lines, given the
+ * available width and a measurer that respects per-atom font. Each
+ * input line's atoms are walked greedy-left-to-right; when adding
+ * the next non-whitespace atom would exceed `maxWidth` we flush the
+ * accumulated atoms as a render line.
+ *
+ * Trailing whitespace is dropped before flushing so wrapped lines
+ * don't carry visible "tails" on the right. Lines that consist of a
+ * single oversized word (longer than `maxWidth` on its own) are kept
+ * intact — the renderer will clip them, matching Konva's behaviour.
+ */
+var wrapAtomsForWidth = function (atoms, maxWidth, measure) {
+    var e_2, _a;
+    if (atoms.length === 0)
+        return [[]];
+    if (maxWidth <= 0)
+        return [atoms];
+    var result = [];
+    var line = [];
+    var lineWidth = 0;
+    var flushLine = function () {
+        // Strip trailing whitespace atoms from the line we're about to
+        // commit — they'd render past the wrap column otherwise.
+        while (line.length && line[line.length - 1].isWhitespace) {
+            line.pop();
+        }
+        result.push(line);
+        line = [];
+        lineWidth = 0;
+    };
+    try {
+        for (var atoms_1 = tslib_1.__values(atoms), atoms_1_1 = atoms_1.next(); !atoms_1_1.done; atoms_1_1 = atoms_1.next()) {
+            var atom = atoms_1_1.value;
+            var atomWidth = measure(atom);
+            if (lineWidth + atomWidth <= maxWidth) {
+                line.push(atom);
+                lineWidth += atomWidth;
+                continue;
+            }
+            if (atom.isWhitespace) {
+                // Whitespace that doesn't fit becomes the implicit line break.
+                flushLine();
+                continue;
+            }
+            if (line.length === 0) {
+                // Atom alone exceeds width — keep it on its own line; the
+                // renderer's right-edge clip will hide the overflow.
+                result.push([atom]);
+                lineWidth = 0;
+                continue;
+            }
+            flushLine();
+            line.push(atom);
+            lineWidth = atomWidth;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (atoms_1_1 && !atoms_1_1.done && (_a = atoms_1.return)) _a.call(atoms_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (line.length)
+        result.push(line);
+    if (result.length === 0)
+        result.push([]);
+    return result;
+};
+/**
+ * Re-collapse a wrapped atom list back into render-segments. Adjacent
+ * atoms sharing the same format reference get merged so paint touches
+ * `measureText` and `fillText` once per contiguous style run, not
+ * once per word.
+ */
+var atomsToSegments = function (atoms) {
+    if (atoms.length === 0)
+        return [];
+    var out = [];
+    var current = {
+        text: atoms[0].text,
+        format: atoms[0].format,
+    };
+    for (var i = 1; i < atoms.length; i++) {
+        var atom = atoms[i];
+        if (atom.format === current.format) {
+            current = { text: current.text + atom.text, format: current.format };
+        }
+        else {
+            out.push(current);
+            current = { text: atom.text, format: atom.format };
+        }
+    }
+    out.push(current);
+    return out;
+};
+/**
+ * Custom Konva renderer for `TextFormatRun[]`. Konva's built-in `Text`
+ * only supports a single style per node, so we fall back to a raw
+ * `Shape` with a sceneFunc that paints each segment with its own
+ * font / fill / decoration.
+ *
+ * Constraints (callers must honour):
+ *  - No text wrap. The cell falls back to the single-style `Text`
+ *    when `wrapStrategy === "wrap"` so wrap semantics stay correct.
+ *  - No rotation / stacked / shrink-to-fit. Same fallback rule.
+ *  - Mention runs render as their inline label only (no chrome).
+ */
+exports.CellTextRuns = react_1.default.memo(function (props) {
+    var x = props.x, y = props.y, width = props.width, height = props.height, padding = props.padding, value = props.value, runs = props.runs, baseColor = props.baseColor, baseFontFamily = props.baseFontFamily, baseFontSize = props.baseFontSize, baseBold = props.baseBold, baseItalic = props.baseItalic, baseUnderline = props.baseUnderline, baseStrikethrough = props.baseStrikethrough, baseBaselineOffset = props.baseBaselineOffset, horizontalAlign = props.horizontalAlign, verticalAlign = props.verticalAlign, lineHeight = props.lineHeight, wrap = props.wrap, theme = props.theme;
+    var sceneFunc = (0, react_1.useCallback)(function (context, _shape) {
+        var e_3, _a, e_4, _b, e_5, _c, e_6, _d, e_7, _e;
+        var baseResolved = {
+            bold: baseBold,
+            italic: baseItalic,
+            underline: baseUnderline,
+            strikethrough: baseStrikethrough,
+            color: baseColor !== null && baseColor !== void 0 ? baseColor : "#000000",
+            fontFamily: baseFontFamily !== null && baseFontFamily !== void 0 ? baseFontFamily : "sans-serif",
+            fontSize: baseFontSize,
+            baselineOffset: baseBaselineOffset,
+        };
+        var segments = (0, rich_text_1.buildRichTextSegments)(value, runs);
+        var inputLines = (0, rich_text_1.segmentsToLines)(segments);
+        var innerTop = padding;
+        var innerBottom = height - padding;
+        var innerHeight = Math.max(0, innerBottom - innerTop);
+        var innerLeftPre = padding;
+        var innerRightPre = width - padding;
+        var innerWidthPre = Math.max(0, innerRightPre - innerLeftPre);
+        // Atom-measurer used by the wrap algorithm. Mutates ctx.font as
+        // it walks; the per-segment paint loop below sets it again per
+        // segment so the mutation here is safe.
+        var measureAtom = function (atom) {
+            var r = (0, exports.resolveSegmentStyle)({ text: atom.text, format: atom.format }, baseResolved, theme);
+            context.setAttr("font", buildFontString(r));
+            return context.measureText(atom.text).width;
+        };
+        // Expand each \n-bounded input line into one or more render
+        // lines. When `wrap` is on, long lines get split on whitespace
+        // boundaries; otherwise each input line maps 1:1 to a render
+        // line and may visually clip at the right edge.
+        var lines = [];
+        try {
+            for (var inputLines_1 = tslib_1.__values(inputLines), inputLines_1_1 = inputLines_1.next(); !inputLines_1_1.done; inputLines_1_1 = inputLines_1.next()) {
+                var inputLine = inputLines_1_1.value;
+                if (inputLine.length === 0) {
+                    lines.push([]);
+                    continue;
+                }
+                if (!wrap) {
+                    lines.push(inputLine);
+                    continue;
+                }
+                var atoms = [];
+                try {
+                    for (var inputLine_1 = (e_4 = void 0, tslib_1.__values(inputLine)), inputLine_1_1 = inputLine_1.next(); !inputLine_1_1.done; inputLine_1_1 = inputLine_1.next()) {
+                        var seg = inputLine_1_1.value;
+                        try {
+                            for (var _f = (e_5 = void 0, tslib_1.__values((0, rich_text_1.segmentToAtoms)(seg))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                                var atom = _g.value;
+                                atoms.push(atom);
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (inputLine_1_1 && !inputLine_1_1.done && (_b = inputLine_1.return)) _b.call(inputLine_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                var wrapped = wrapAtomsForWidth(atoms, innerWidthPre, measureAtom);
+                try {
+                    for (var wrapped_1 = (e_6 = void 0, tslib_1.__values(wrapped)), wrapped_1_1 = wrapped_1.next(); !wrapped_1_1.done; wrapped_1_1 = wrapped_1.next()) {
+                        var wrappedLine = wrapped_1_1.value;
+                        lines.push(atomsToSegments(wrappedLine));
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (wrapped_1_1 && !wrapped_1_1.done && (_d = wrapped_1.return)) _d.call(wrapped_1);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (inputLines_1_1 && !inputLines_1_1.done && (_a = inputLines_1.return)) _a.call(inputLines_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        // We use textBaseline="top" so y values are the visual top of
+        // each line. Konva's Text positions text by line-box height
+        // (fontSize * lineHeight) and aligns the *box* — not the
+        // alphabetic baseline — within the cell. Matching that math
+        // exactly is what keeps rich-text cells visually flush with
+        // their plain-text neighbours.
+        //
+        // Each line's box is sized by its largest resolved run — Excel
+        // grows a mixed-size line to its tallest glyph — mirroring the
+        // sizer's `measureRichTextDimensions`. When every run matches
+        // the base font size this reduces to `baseFontSize * lineHeight`
+        // per line, i.e. exactly Konva Text's single-style layout.
+        var resolvedLines = lines.map(function (lineSegments) {
+            return lineSegments.map(function (seg) { return ({
+                seg: seg,
+                r: (0, exports.resolveSegmentStyle)(seg, baseResolved, theme),
+            }); });
+        });
+        var _h = (0, exports.computeLineMetrics)(resolvedLines, baseFontSize, lineHeight), lineFontSizes = _h.lineFontSizes, lineHeights = _h.lineHeights, totalH = _h.totalHeight;
+        var topY;
+        if (verticalAlign === "top") {
+            topY = innerTop;
+        }
+        else if (verticalAlign === "bottom") {
+            topY = innerBottom - totalH;
+        }
+        else {
+            // middle
+            topY = innerTop + (innerHeight - totalH) / 2;
+        }
+        var innerLeft = innerLeftPre;
+        var innerRight = innerRightPre;
+        var innerWidth = innerWidthPre;
+        context.setAttr("textBaseline", "top");
+        var lineOffsetY = 0;
+        for (var i = 0; i < resolvedLines.length; i++) {
+            var lineSegments = resolvedLines[i];
+            var lineFontSize = lineFontSizes[i];
+            var lineH = lineHeights[i];
+            var lineOffset = lineOffsetY;
+            lineOffsetY += lineH;
+            if (lineSegments.length === 0)
+                continue;
+            // Measure line first so we can do horizontal alignment +
+            // simple clipping at the right edge.
+            var lineWidth = measureLineWidth(context, lineSegments);
+            var startX = void 0;
+            if (horizontalAlign === "right") {
+                startX = innerRight - Math.min(lineWidth, innerWidth);
+            }
+            else if (horizontalAlign === "center") {
+                startX =
+                    innerLeft + (innerWidth - Math.min(lineWidth, innerWidth)) / 2;
+            }
+            else {
+                startX = innerLeft;
+            }
+            var cursorX = startX;
+            // Konva centers the glyph baseline inside the line-box: the
+            // box is `lineH` tall, the glyphs are ~`fontSize` tall, so
+            // there's a (lineH - fontSize)/2 sliver above and below. Shift
+            // our top-anchored draw down by that sliver so the glyph
+            // centerline lands where Konva's would.
+            var lineTop = topY + lineOffset + (lineH - lineFontSize) / 2;
+            try {
+                for (var lineSegments_2 = (e_7 = void 0, tslib_1.__values(lineSegments)), lineSegments_2_1 = lineSegments_2.next(); !lineSegments_2_1.done; lineSegments_2_1 = lineSegments_2.next()) {
+                    var _j = lineSegments_2_1.value, seg = _j.seg, r = _j.r;
+                    var font = buildFontString(r);
+                    context.setAttr("font", font);
+                    context.setAttr("fillStyle", r.color);
+                    var segWidth = context.measureText(seg.text).width;
+                    var segmentTop = (0, exports.computeSegmentTop)(lineTop, lineFontSize, r.fontSize, r.baselineOffset);
+                    // textBaseline="top" → glyphs paint downward from lineTop.
+                    context.fillText(seg.text, cursorX, segmentTop);
+                    // Underline / strikethrough are drawn manually because canvas
+                    // 2D has no native textDecoration. Positions are relative to
+                    // the line-top using approximate font-metric ratios.
+                    var decorationThickness = Math.max(1, Math.floor(r.fontSize / 14));
+                    if (r.underline) {
+                        var underlineY = segmentTop + r.fontSize * 0.95;
+                        context.fillRect(cursorX, underlineY, segWidth, decorationThickness);
+                    }
+                    if (r.strikethrough) {
+                        var strikeY = segmentTop + r.fontSize * 0.5;
+                        context.fillRect(cursorX, strikeY, segWidth, decorationThickness);
+                    }
+                    cursorX += segWidth;
+                    // Clip at right edge — once we run past `innerRight`, the
+                    // remaining segments would only paint outside the cell. The
+                    // Konva Shape's bounding rect already clips, but skipping
+                    // saves measure + paint cost on long values.
+                    if (cursorX > innerRight)
+                        break;
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (lineSegments_2_1 && !lineSegments_2_1.done && (_e = lineSegments_2.return)) _e.call(lineSegments_2);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }, [
+        value,
+        runs,
+        baseColor,
+        baseFontFamily,
+        baseFontSize,
+        baseBold,
+        baseItalic,
+        baseUnderline,
+        baseStrikethrough,
+        baseBaselineOffset,
+        horizontalAlign,
+        verticalAlign,
+        lineHeight,
+        wrap,
+        width,
+        height,
+        padding,
+        theme,
+    ]);
+    return (react_1.default.createElement(react_konva_1.Shape, { x: x, y: y, width: width, height: height, sceneFunc: sceneFunc, listening: false, perfectDrawEnabled: false }));
+});
+exports.CellTextRuns.displayName = "CellTextRuns";

package/dist/cjs/components/cell/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare const getLeftSpacing: (isCalculatedCell: boolean | undefined, expandable: boolean | undefined, showExpand: boolean | undefined, iconSpacing?: number, scale?: number) => number;
+export declare const getRightSpacing: (showFilter: boolean | undefined | null, showArrow: boolean | undefined | null, showExpand: boolean | undefined | null, iconSpacing?: number, scale?: number) => number;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/cjs/components/cell/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../components/cell/helpers.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc,GACzB,kBAAkB,OAAO,GAAG,SAAS,EACrC,YAAY,OAAO,GAAG,SAAS,EAC/B,YAAY,OAAO,GAAG,SAAS,EAC/B,cAAa,MAAU,EACvB,QAAO,MAAU,WAOlB,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,YAAY,OAAO,GAAG,SAAS,GAAG,IAAI,EACtC,WAAW,OAAO,GAAG,SAAS,GAAG,IAAI,EACrC,YAAY,OAAO,GAAG,SAAS,GAAG,IAAI,EACtC,cAAa,MAAU,EACvB,QAAO,MAAU,WAOlB,CAAC"}

package/dist/cjs/components/cell/helpers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRightSpacing = exports.getLeftSpacing = void 0;
+var config_1 = require("../../config");
+var getLeftSpacing = function (isCalculatedCell, expandable, showExpand, iconSpacing, scale) {
+    if (iconSpacing === void 0) { iconSpacing = 0; }
+    if (scale === void 0) { scale = 1; }
+    return ((isCalculatedCell ? (config_1.CALCULATED_ICON_WIDTH + iconSpacing) * scale : 0) +
+        (expandable ? (config_1.EXPAND_COLLAPSE_ICON_WIDTH + iconSpacing) * scale : 0) +
+        (showExpand ? (config_1.ARROW_DOWN_WIDTH + iconSpacing) * scale : 0));
+};
+exports.getLeftSpacing = getLeftSpacing;
+var getRightSpacing = function (showFilter, showArrow, showExpand, iconSpacing, scale) {
+    if (iconSpacing === void 0) { iconSpacing = 0; }
+    if (scale === void 0) { scale = 1; }
+    return ((showFilter ? (config_1.FILTER_ICON_WIDTH + iconSpacing) * scale : 0) +
+        (showArrow ? (config_1.ARROW_DOWN_WIDTH + iconSpacing) * scale : 0) +
+        (showExpand ? (config_1.ARROW_DOWN_WIDTH + iconSpacing) * scale : 0));
+};
+exports.getRightSpacing = getRightSpacing;

package/dist/cjs/components/cell/index.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { CellProps } from "./typings";
+export declare const Cell: React.MemoExoticComponent<(props: CellProps) => React.JSX.Element>;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/components/cell/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../components/cell/index.tsx"],"names":[],"mappings":"AAIA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAwCjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAU3C,eAAO,MAAM,IAAI,oCAAgB,SAAS,uBAsmBxC,CAAC"}