caplink-saas-ui-shared-component-library 1.76.0 → 1.77.0

package/dist/features/spreadsheet/core/clipboard/clipboard-manager.d.ts

@@ -0,0 +1,38 @@
+import { ClipboardEventType, CopyOperationResult, PasteOperationResult } from './types';
+import type * as Matrix from '../../model/matrix';
+import type * as Spreadsheet from '../../model/spreadsheet';
+/**
+ * Executes a paste operation
+ * @param event - The clipboard event from browser/React
+ * @param params - Parameters for the paste operation
+ * @returns Result with updated matrix and history entries
+ */
+export declare function paste(event: ClipboardEventType, params: {
+    targetPoint: Matrix.Point;
+    currentMatrix: Matrix.Matrix<unknown>;
+    columns: Spreadsheet.Column[];
+    selectedRanges: Matrix.PointRange[];
+    isStaticRows: boolean;
+    maxColumns: number;
+    enableCyclicRepeat?: boolean;
+}): PasteOperationResult;
+/**
+ * Copies a single cell to clipboard
+ * @param point - The cell position to copy
+ * @param currentMatrix - Current matrix state
+ * @returns Result with clipboard text and success status
+ */
+export declare function copySingleCellToClipboard(point: Matrix.Point, currentMatrix: Matrix.Matrix<unknown>): CopyOperationResult;
+/**
+ * Copies multiple ranges to clipboard
+ * @param ranges - The ranges to copy
+ * @param currentMatrix - Current matrix state
+ * @returns Result with clipboard text and success status
+ */
+export declare function copyRangesToClipboard(ranges: Matrix.PointRange[], currentMatrix: Matrix.Matrix<unknown>): CopyOperationResult;
+/**
+ * Writes text to system clipboard
+ * @param text - The text to write
+ * @returns Promise that resolves when write is complete
+ */
+export declare function writeToClipboard(text: string): Promise<void>;

package/dist/features/spreadsheet/core/clipboard/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Clipboard Module - Core functionality for copy/paste operations
+ *
+ * This module provides a clean, well-structured API for handling clipboard
+ * operations in the spreadsheet. It follows Domain-Driven Design principles
+ * with clear separation of concerns.
+ *
+ * Architecture:
+ * - types/: TypeScript interfaces and types
+ * - services/: Business logic services (data extraction, strategy selection)
+ * - operations/: Specific paste/copy implementations
+ *
+ * Usage Example:
+ * ```ts
+ * import {
+ *   paste,
+ *   copySingleCellToClipboard,
+ *   copyRangesToClipboard,
+ *   writeToClipboard,
+ * } from '@/features/spreadsheet/core/clipboard';
+ *
+ * // Paste operation
+ * const result = paste(event, {
+ *   targetPoint: { row: 0, column: 0 },
+ *   currentMatrix: matrix,
+ *   columns: columns,
+ *   selectedRanges: ranges,
+ *   isStaticRows: false,
+ *   maxColumns: 10,
+ *   enableCyclicRepeat: false, // Optional: Excel behavior
+ * });
+ *
+ * // Copy operations
+ * const copyResult = copyRangesToClipboard(ranges, matrix);
+ * await writeToClipboard(copyResult.clipboardText);
+ *
+ * // Single cell copy
+ * const singleResult = copySingleCellToClipboard(point, matrix);
+ * await writeToClipboard(singleResult.clipboardText);
+ * ```
+ */
+export { paste, copySingleCellToClipboard, copyRangesToClipboard, writeToClipboard, } from './clipboard-manager';
+export type { ClipboardEventType, PasteOperationConfig, PasteOperationResult, CopyOperationConfig, CopyOperationResult, HistoryEntry, ParsedClipboardData, PasteValidationResult, } from './types';
+export { PasteStrategy } from './types';
+export { extractAndParseClipboardData, formatMatrixForClipboard, isSingleCell, getClipboardDataDimensions, } from './services/clipboard-data-extractor';
+export { selectPasteStrategy } from './services/paste-strategy-selector';
+export { executePasteOperation } from './operations/paste-orchestrator';
+export { pasteSingleValueToSelection } from './operations/paste-single-value';
+export { pasteWithCyclicRepeat } from './operations/paste-with-cyclic-repeat';
+export { pasteWithOverlay } from './operations/paste-with-overlay';
+export { copySingleCell } from './operations/copy-single-cell';
+export { copyRange } from './operations/copy-range';

package/dist/features/spreadsheet/core/clipboard/operations/copy-range.d.ts

@@ -0,0 +1,6 @@
+import { CopyOperationConfig, CopyOperationResult } from '../types';
+/**
+ * Handles copying multiple cell ranges to clipboard
+ * Formats data as tab-separated values (TSV) compatible with Excel/Sheets
+ */
+export declare function copyRange(config: CopyOperationConfig): CopyOperationResult;

package/dist/features/spreadsheet/core/clipboard/operations/copy-single-cell.d.ts

@@ -0,0 +1,6 @@
+import { CopyOperationResult } from '../types';
+import type * as Matrix from '../../../model/matrix';
+/**
+ * Handles copying a single cell value to clipboard
+ */
+export declare function copySingleCell(point: Matrix.Point, currentMatrix: Matrix.Matrix<unknown>): CopyOperationResult;

package/dist/features/spreadsheet/core/clipboard/operations/paste-orchestrator.d.ts

@@ -0,0 +1,10 @@
+import { ClipboardEventType, PasteOperationConfig, PasteOperationResult } from '../types';
+/**
+ * Orchestrates the entire paste operation
+ * Determines strategy and delegates to appropriate handler
+ *
+ * @param event - The clipboard event
+ * @param config - Configuration for the paste operation
+ * @returns Result containing updated matrix and history entries
+ */
+export declare function executePasteOperation(event: ClipboardEventType, config: Omit<PasteOperationConfig, 'parsedData'>): PasteOperationResult;

package/dist/features/spreadsheet/core/clipboard/operations/paste-single-value.d.ts

@@ -0,0 +1,6 @@
+import { PasteOperationConfig, PasteOperationResult } from '../types';
+/**
+ * Handles pasting a single value to multiple selected cells
+ * This is used when user pastes one cell value into a larger selection
+ */
+export declare function pasteSingleValueToSelection(config: PasteOperationConfig): PasteOperationResult;

package/dist/features/spreadsheet/core/clipboard/operations/paste-with-cyclic-repeat.d.ts

@@ -0,0 +1,9 @@
+import { PasteOperationConfig, PasteOperationResult } from '../types';
+/**
+ * Handles pasting data with cyclic repetition to fill a larger selection
+ * Example: Pasting [A, B] into 5 cells results in [A, B, A, B, A]
+ *
+ * @param config - Paste operation configuration
+ * @param enableCyclicRepeat - If false, only paste data once (Excel behavior)
+ */
+export declare function pasteWithCyclicRepeat(config: PasteOperationConfig, enableCyclicRepeat?: boolean): PasteOperationResult;

package/dist/features/spreadsheet/core/clipboard/operations/paste-with-overlay.d.ts

@@ -0,0 +1,6 @@
+import { PasteOperationConfig, PasteOperationResult } from '../types';
+/**
+ * Handles pasting data by overlaying it on the matrix
+ * This may expand the matrix if needed (unless staticRows is true)
+ */
+export declare function pasteWithOverlay(config: PasteOperationConfig): PasteOperationResult;

package/dist/features/spreadsheet/core/clipboard/services/clipboard-data-extractor.d.ts

@@ -0,0 +1,30 @@
+import { ClipboardEventType, ParsedClipboardData } from '../types';
+import * as Matrix from '../../../model/matrix';
+/**
+ * Extracts text from clipboard event and parses it into matrix format
+ * @param event - The clipboard event (from browser or React)
+ * @returns Parsed data as a matrix of unknown values
+ */
+export declare function extractAndParseClipboardData(event: ClipboardEventType): ParsedClipboardData;
+/**
+ * Formats matrix data into clipboard-compatible string
+ * Columns are separated by tabs (\t), rows by newlines (\n)
+ * @param data - Matrix data to format
+ * @returns Formatted string ready for clipboard
+ */
+export declare function formatMatrixForClipboard(data: Matrix.Matrix<unknown>): string;
+/**
+ * Checks if parsed data represents a single cell
+ * @param data - Parsed clipboard data
+ * @returns True if data is a single cell (1x1 matrix)
+ */
+export declare function isSingleCell(data: ParsedClipboardData): boolean;
+/**
+ * Gets the dimensions of parsed clipboard data
+ * @param data - Parsed clipboard data
+ * @returns Object with rows and columns count
+ */
+export declare function getClipboardDataDimensions(data: ParsedClipboardData): {
+    rows: number;
+    columns: number;
+};

package/dist/features/spreadsheet/core/clipboard/services/paste-strategy-selector.d.ts

@@ -0,0 +1,9 @@
+import { ParsedClipboardData, PasteStrategy } from '../types';
+import type * as Matrix from '../../../model/matrix';
+/**
+ * Selects the appropriate paste strategy
+ * @param parsedData - The clipboard data to paste
+ * @param selectedRanges - Currently selected cell ranges
+ * @returns The strategy to use for pasting
+ */
+export declare function selectPasteStrategy(parsedData: ParsedClipboardData, selectedRanges: Matrix.PointRange[]): PasteStrategy;

package/dist/features/spreadsheet/core/clipboard/types/index.d.ts

@@ -0,0 +1,94 @@
+import { ClipboardEvent } from 'react';
+import type * as Matrix from '../../../model/matrix';
+import type * as Spreadsheet from '../../../model/spreadsheet';
+/**
+ * Represents the result of parsing clipboard data into a matrix format
+ */
+export type ParsedClipboardData = Matrix.Matrix<unknown>;
+/**
+ * Unified type for clipboard events from both browser and React
+ */
+export type ClipboardEventType = ClipboardEvent | globalThis.ClipboardEvent;
+/**
+ * Configuration for paste operations
+ */
+export interface PasteOperationConfig {
+    /** The target point where paste operation starts */
+    targetPoint: Matrix.Point;
+    /** The data to be pasted (already parsed into matrix format) */
+    parsedData: ParsedClipboardData;
+    /** Current matrix state */
+    currentMatrix: Matrix.Matrix<unknown>;
+    /** Column definitions with metadata */
+    columns: Spreadsheet.Column[];
+    /** Currently selected ranges */
+    selectedRanges: Matrix.PointRange[];
+    /** Whether the spreadsheet has static rows (no expansion allowed) */
+    isStaticRows: boolean;
+    /** Maximum number of columns allowed */
+    maxColumns: number;
+    /** Enable cyclic repetition when pasting (default: true) */
+    enableCyclicRepeat?: boolean;
+}
+/**
+ * Result of a paste operation
+ */
+export interface PasteOperationResult {
+    /** The updated matrix after paste */
+    updatedMatrix: Matrix.Matrix<unknown>;
+    /** History entries to track changes for undo */
+    historyEntries: HistoryEntry[];
+}
+/**
+ * Represents a single change in the spreadsheet for undo/redo
+ */
+export interface HistoryEntry {
+    /** The cell position that changed */
+    point: Matrix.Point;
+    /** The value before the change */
+    oldValue: unknown;
+    /** The value after the change */
+    newValue: unknown;
+    /** Unique identifier to group related changes (e.g., all cells from one paste) */
+    pastedId: string;
+}
+/**
+ * Determines which paste strategy to use
+ */
+export declare enum PasteStrategy {
+    /** Single value pasted to multiple selected cells */
+    SINGLE_VALUE_TO_SELECTION = "SINGLE_VALUE_TO_SELECTION",
+    /** Data repeated cyclically to fill larger selection */
+    CYCLIC_REPEAT = "CYCLIC_REPEAT",
+    /** Data overlaid on matrix (may expand) */
+    OVERLAY = "OVERLAY"
+}
+/**
+ * Configuration for copy operations
+ */
+export interface CopyOperationConfig {
+    /** The ranges to copy from */
+    sourceRanges: Matrix.PointRange[];
+    /** Current matrix state */
+    currentMatrix: Matrix.Matrix<unknown>;
+}
+/**
+ * Result of a copy operation
+ */
+export interface CopyOperationResult {
+    /** The formatted string ready for clipboard */
+    clipboardText: string;
+    /** Whether the operation was successful */
+    success: boolean;
+}
+/**
+ * Validation result for paste operations
+ */
+export interface PasteValidationResult {
+    /** Whether the paste operation is valid */
+    isValid: boolean;
+    /** Reason for validation failure (if any) */
+    reason?: string;
+    /** Which cells would be affected */
+    affectedCells?: Matrix.Point[];
+}

package/dist/features/spreadsheet/core/formatters/date-formatter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Date formatter module
+ * Converts various date formats to ISO date strings (YYYY-MM-DD)
+ * Handles DD/MM/YYYY, MM/DD/YYYY, ISO formats, and Excel serial numbers
+ *
+ * Supported formats:
+ * - DD/MM/YYYY or MM/DD/YYYY (based on locale)
+ * - DD.MM.YYYY (German, Russian, Polish, etc.)
+ * - DD/MM/YY or DD.MM.YY (two-digit years)
+ * - Excel serial numbers (both 1900 and 1904 date systems)
+ * - ISO format (YYYY-MM-DD)
+ *
+ * Excel Date Systems:
+ * - 1900 system (default, Windows): Serial 1 = 1900-01-01
+ * - 1904 system (Mac): Serial 0 = 1904-01-01
+ */
+/**
+ * Excel date system type
+ * - '1900': Windows default (Serial 1 = 1900-01-01)
+ * - '1904': Mac OS (Serial 0 = 1904-01-01)
+ * - 'auto': Auto-detect based on serial value (default)
+ */
+export type ExcelDateSystem = '1900' | '1904' | 'auto';
+/**
+ * Options for formatDate function
+ */
+export interface FormatDateOptions {
+    /**
+     * Excel date system to use for serial number conversion
+     * @default 'auto'
+     */
+    dateSystem?: ExcelDateSystem;
+}
+/**
+ * Formats a date value into ISO format (YYYY-MM-DD)
+ * Supports multiple input formats:
+ * - DD/MM/YYYY or MM/DD/YYYY (based on locale)
+ * - DD.MM.YYYY (German, Russian, Polish, etc.)
+ * - DD/MM/YY or DD.MM.YY (two-digit years)
+ * - Excel serial numbers (both 1900 and 1904 systems)
+ * - ISO format (YYYY-MM-DD)
+ *
+ * @param value - Date value as string
+ * @param options - Optional configuration
+ * @param options.dateSystem - Excel date system: '1900' (Windows), '1904' (Mac), or 'auto' (default)
+ * @returns ISO date string (YYYY-MM-DD) or null if invalid
+ *
+ * @example
+ * formatDate('15/03/2024')                    // '2024-03-15'
+ * formatDate('15.03.2024')                    // '2024-03-15' (German format)
+ * formatDate('15/03/24')                      // '2024-03-15' (two-digit year)
+ * formatDate('45365')                         // '2024-03-15' (Excel serial 1900)
+ * formatDate('0', { dateSystem: '1904' })     // '1904-01-01' (Excel serial 1904)
+ * formatDate('2024-03-15')                    // '2024-03-15'
+ * formatDate('99/99/9999')                    // null
+ */
+export declare function formatDate(value: string, options?: FormatDateOptions): string | null;

package/dist/features/spreadsheet/core/formatters/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formatters module
+ * Exports all value formatters
+ */
+export { formatDate } from './date-formatter';
+export type { ExcelDateSystem, FormatDateOptions } from './date-formatter';

package/dist/features/spreadsheet/core/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core Module - Business logic and domain services
+ *
+ * This module contains the core business logic of the spreadsheet,
+ * separated from the presentation layer (UI components) and infrastructure
+ * (state management).
+ *
+ * Follows Clean Architecture principles:
+ * - Independent of frameworks
+ * - Testable
+ * - Independent of UI
+ * - Independent of Database/State management
+ *
+ * Structure:
+ * - clipboard/: Copy/paste operations
+ * - formatters/: Data formatting (dates, etc)
+ * - normalizers/: Value normalization by type
+ * - validators/: Input validation
+ * - normalize-value.ts: Main normalization orchestrator
+ */
+export * from './clipboard';
+export * from './formatters';
+export * from './normalizers';
+export * from './validators';
+export { normalizeValue } from './normalize-value';
+export { normalizationCache } from './normalize-value-cache';

package/dist/features/spreadsheet/core/normalize-value-cache.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cache for normalized values to avoid redundant processing
+ * Used during paste operations where the same value is normalized multiple times
+ */
+declare class NormalizationCache {
+    private cache;
+    private readonly maxSize;
+    private readonly ttl;
+    /**
+     * Generates a cache key from value and column type
+     */
+    private generateKey;
+    /**
+     * Gets a cached normalized value if available and not expired
+     */
+    get(value: unknown, columnType: string, settings?: unknown): unknown | undefined;
+    /**
+     * Stores a normalized value in cache
+     */
+    set(value: unknown, columnType: string, normalizedValue: unknown, settings?: unknown): void;
+    /**
+     * Clears the entire cache
+     */
+    clear(): void;
+    /**
+     * Gets cache statistics for monitoring
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+    };
+}
+export declare const normalizationCache: NormalizationCache;
+export {};

package/dist/features/spreadsheet/core/normalize-value.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Value normalization orchestrator
+ * Coordinates normalization based on column data type
+ */
+import type * as Spreadsheet from '../model/spreadsheet';
+/**
+ * Main normalization function
+ * Normalizes values based on column data type with optional caching
+ *
+ * @param params - Normalization parameters
+ * @param params.value - Value to normalize
+ * @param params.column - Column configuration with data type
+ * @param params.useCache - Whether to use normalization cache (default: true)
+ * @returns Normalized value appropriate for the column type
+ *
+ * @example
+ * normalizeValue({ value: '1.250,50', column: { dataEditorType: 'Numeric', ... } })
+ * normalizeValue({ value: '15/03/2024', column: { dataEditorType: 'Date', ... } })
+ */
+export declare function normalizeValue(params: {
+    value: unknown;
+    column: Spreadsheet.Column;
+    useCache?: boolean;
+}): unknown;

package/dist/features/spreadsheet/core/normalizers/boolean-normalizer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Boolean normalization module
+ * Converts various boolean representations to string 'true' or 'false'
+ */
+/**
+ * Normalizes a value to boolean string representation
+ * Accepts: true, false, 'true', 'false'
+ * @param value - Value to normalize
+ * @returns 'true' or 'false'
+ *
+ * @example
+ * normalizeBoolean('true')  // 'true'
+ * normalizeBoolean('false') // 'false'
+ * normalizeBoolean('yes')   // 'false'
+ * normalizeBoolean(true)    // 'true'
+ */
+export declare function normalizeBoolean(value: unknown): 'true' | 'false';

package/dist/features/spreadsheet/core/normalizers/date-normalizer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Date normalization module
+ * Converts date strings to ISO format using the date formatter
+ */
+/**
+ * Normalizes a date value to ISO format (YYYY-MM-DD)
+ * Returns empty string if date is invalid
+ * Logs a warning for invalid non-empty dates
+ *
+ * @param value - Date value as string
+ * @returns ISO date string or empty string
+ *
+ * @example
+ * normalizeDate('15/03/2024') // '2024-03-15'
+ * normalizeDate('99/99/9999') // '' (with console warning)
+ * normalizeDate('')           // ''
+ */
+export declare function normalizeDate(value: string): string;

package/dist/features/spreadsheet/core/normalizers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Normalizers module
+ * Exports all value normalizers for different data types
+ */
+export { normalizeString } from './string-normalizer';
+export { normalizeBoolean } from './boolean-normalizer';
+export { normalizeDate } from './date-normalizer';
+export { normalizeNumeric, parseNumericString, clampNumber } from './numeric-normalizer';

package/dist/features/spreadsheet/core/normalizers/numeric-formatter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Numeric formatting module
+ * Handles complex numeric string parsing with multiple separators
+ */
+/**
+ * Formats a numeric string by handling various separator combinations
+ * Handles European (1.250,50), US (1,250.50), and malformed formats
+ *
+ * @param value - Raw numeric string with potential separators
+ * @returns Formatted string with dot as decimal separator
+ *
+ * @example
+ * formatNumericString('1,25')       // '1.25'
+ * formatNumericString('1.250,50')   // '1250.50'
+ * formatNumericString('1,250.50')   // '1250.50'
+ * formatNumericString('1,,,,25')    // '125'
+ */
+export declare function formatNumericString(value: string): string;

package/dist/features/spreadsheet/core/normalizers/numeric-normalizer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Numeric normalization module
+ * Handles number parsing, separator removal, and range validation
+ */
+/**
+ * Parses a numeric string by removing thousand separators and normalizing decimal point
+ * Handles both European (1.000,50) and US (1,000.50) formats
+ *
+ * @param value - Numeric string to parse
+ * @returns Parsed number or NaN if invalid
+ *
+ * @example
+ * parseNumericString('1.234,56')  // 1234.56 (European)
+ * parseNumericString('1,234.56')  // 1234.56 (US)
+ * parseNumericString('1.234.567') // 1234567 (thousands only)
+ */
+export declare function parseNumericString(value: string): number;
+/**
+ * Clamps a number within a specified range
+ * @param value - Number to clamp
+ * @param min - Minimum value (optional)
+ * @param max - Maximum value (optional)
+ * @returns Clamped number
+ *
+ * @example
+ * clampNumber(150, 0, 100) // 100
+ * clampNumber(-50, 0, 100) // 0
+ * clampNumber(50, 0, 100)  // 50
+ */
+export declare function clampNumber(value: number, min?: number, max?: number): number;
+/**
+ * Normalizes a numeric value by parsing and applying range constraints
+ * @param value - Value to normalize
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @returns Normalized number or empty string if invalid
+ *
+ * @example
+ * normalizeNumeric('1.234,56', 0, 10000) // 1234.56
+ * normalizeNumeric('150', 0, 100)        // 100
+ * normalizeNumeric('abc', 0, 100)        // ''
+ */
+export declare function normalizeNumeric(value: string, min?: number, max?: number): number | '';

package/dist/features/spreadsheet/core/normalizers/string-normalizer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * String normalization module
+ * Handles string value normalization including truncation and mask validation
+ */
+/**
+ * Normalizes a string value by truncating it to the maximum allowed length
+ * @param value - The string to normalize
+ * @param maxLength - Maximum allowed length (defaults to COLUMN_STRING_LIMIT)
+ * @returns Normalized string
+ *
+ * @example
+ * normalizeString('Hello World', 1200) // 'Hello World'
+ * normalizeString('A'.repeat(1500), 1200) // Returns first 1200 characters
+ */
+export declare function normalizeString(value: string, maxLength?: number): string;

package/dist/features/spreadsheet/core/validators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validators module
+ * Exports all value validators
+ */
+export { validateMask } from './mask-validator';

package/dist/features/spreadsheet/core/validators/mask-validator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Mask validation module
+ * Validates string values against digit-based mask patterns
+ */
+/**
+ * Validates if a value matches a digit-based mask pattern
+ * Mask format: '0' represents a digit placeholder, '|' separates alternative masks
+ *
+ * @param value - Value to validate
+ * @param maskData - Mask pattern(s) separated by '|' for alternatives
+ * @returns True if value matches any of the masks
+ *
+ * @example
+ * validateMask('12345', '00000')           // true (5 digits)
+ * validateMask('123', '00000|000')         // true (matches second mask)
+ * validateMask('12-345', '00000')          // true (non-digits ignored)
+ * validateMask('12', '00000')              // false (not enough digits)
+ */
+export declare function validateMask(value: unknown, maskData: string): boolean;

package/dist/features/spreadsheet/model/context.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="react" />
 import * as Spreadsheet from './spreadsheet';
 export declare const SpreadsheetContext: import('react').Context<Spreadsheet.Context | null>;
-export declare function SpreadsheetContextProvider({ children, startingColumns, matrix: startingMatrix, staticRows, onMatrixChange, onExportData, onImportData, onOpenFullScreen, fullScreen, conditionalFormatting, }: Spreadsheet.ContextProvider): import("react/jsx-runtime").JSX.Element;
+export declare function SpreadsheetContextProvider({ children, startingColumns, matrix: startingMatrix, staticRows, onMatrixChange, onExportData, onImportData, onOpenFullScreen, fullScreen, conditionalFormatting, enableCyclicPasteRepeat, }: Spreadsheet.ContextProvider): import("react/jsx-runtime").JSX.Element;

package/dist/features/spreadsheet/model/spreadsheet.d.ts

@@ -1,6 +1,6 @@
-import { ClipboardEvent, CSSProperties, Dispatch, MouseEvent, PropsWithChildren, SetStateAction } from 'react';
-import { SpreadsheetProps } from '../ui/spreadsheet';
+import { CSSProperties, ClipboardEvent, Dispatch, MouseEvent, PropsWithChildren, SetStateAction } from 'react';
 import { ConditionalFormattingRule } from '../lib/conditional-formatting';
+import { SpreadsheetProps } from '../ui/spreadsheet';
 import { ColumnCounterEnum, CommonFiltersEnum, DateFiltersEnum, NumericFiltersEnum, TextFiltersEnum } from '../lib/spreadsheet-filters';
 import type * as Matrix from './matrix';
 export declare const COLUMN_STRING_LIMIT = 1200;
@@ -193,7 +193,7 @@ export type Context = {
     onDeleteSelectedCells: () => void;
     onSelectRow: (row: number, event?: MouseEvent) => void;
     onSelectColumn: (column: number, event?: MouseEvent) => void;
-    onChangeTemporaryValue: (point: Matrix.Point, value: unknown) => void;
+    onChangeTemporaryValue: (point: Matrix.Point, value: unknown, filteredMatrix: RowFiltered[]) => void;
     onSelectCell: (point: Matrix.Point) => void;
     isCellSelected: (point: Matrix.Point) => boolean;
     isCopied: boolean;

package/dist/features/spreadsheet/ui/spreadsheet.d.ts

@@ -1,5 +1,5 @@
-import { InitialColumn } from '../lib/setup-columns';
 import { ConditionalFormattingRule } from '../lib/conditional-formatting';
+import { InitialColumn } from '../lib/setup-columns';
 import type * as Matrix from '../model/matrix';
 export type SpreadsheetProps = {
     matrix: Matrix.Matrix<unknown>;
@@ -14,5 +14,12 @@ export type SpreadsheetProps = {
     onOpenFullScreen?: () => void;
     fullScreen?: boolean;
     conditionalFormatting?: ConditionalFormattingRule[];
+    /**
+     * Enable cyclic repetition when pasting data into a larger selection.
+     * When true: Pasting [A, B] into 5 cells results in [A, B, A, B, A]
+     * When false: Pasting [A, B] into 5 cells results in [A, B, _, _, _] (Excel behavior)
+     * @default true
+     */
+    enableCyclicPasteRepeat?: boolean;
 };
 export declare function Spreadsheet(props: SpreadsheetProps): import("react/jsx-runtime").JSX.Element;