@fileverse-dev/dsheet 2.1.5 → 3.0.1-formula-1

package/dist/editor/utils/api-keys-local-storage.d.ts

@@ -0,0 +1,19 @@
+export declare const INVALID_KEY_MARKER = "_invalid";
+export declare const RATE_LIMITED_KEYS = "RATE_LIMITED_KEYS";
+export declare const DATABLOCK_API_KEYS: string[];
+export declare class ApiKeyStorageHelper {
+    static getApiKey(keyName: string): string;
+    static clearApiKeys(): void;
+    static saveApiKey(keyName: string, key: string): void;
+    static removeApiKey(keyName: string): void;
+    static getAllSupportedApiKeys(): Record<string, string>;
+    static getListOfRateLimitedKeys(): any;
+    static markKeyAsRateLimited(key: string): void;
+}
+export declare const getApiKey: (keyName: string) => string;
+export declare const clearApiKeys: () => void;
+export declare const saveApiKey: (keyName: string, key: string) => void;
+export declare const removeApiKey: (keyName: string) => void;
+export declare const getListOfRateLimitedKeys: () => any;
+export declare const getAllSupportedApiKeysInLs: () => Record<string, string>;
+export declare const markKeyAsRateLimited: (key: string) => void;

package/dist/editor/utils/cell-comment-marker.d.ts

@@ -0,0 +1,30 @@
+type SheetEditorRefLike = {
+    current: {
+        getWorkbookSetContext?: () => unknown;
+    } | null;
+} | null | undefined;
+/**
+ * Clears the comment indicator from a cell.
+ *
+ * - Hides the package-rendered marker DOM node immediately so the user sees
+ *   the change without waiting for a re-render.
+ * - Sets `cell.ps = undefined` in the workbook model so the dsheet package
+ *   stops drawing the marker on subsequent renders / persists.
+ *
+ * Used on top-level comment delete and on top-level comment resolve.
+ */
+export declare const hideCellCommentMarker: (sheetEditorRef: SheetEditorRefLike, row: number, col: number) => void;
+export declare const closeCellCommentPopup: (sheetEditorRef: SheetEditorRefLike) => void;
+/**
+ * Restores the comment indicator on a cell.
+ *
+ * - Removes the inline `display: none` we set on hide so the package's marker
+ *   DOM node becomes visible again if it still exists.
+ * - Re-creates a minimal `cell.ps` stub in the workbook model so the package
+ *   redraws the marker on next render. Geometry fields are `null` so the
+ *   package recomputes them; the existing `ps` is preserved if already set.
+ *
+ * Used on top-level comment unresolve.
+ */
+export declare const showCellCommentMarker: (sheetEditorRef: SheetEditorRefLike, row: number, col: number, value?: string) => void;
+export {};

package/dist/editor/utils/comment-key-utils.d.ts

@@ -0,0 +1,7 @@
+import { CellPosition } from '../types/comments';
+
+export declare const parseCellKey: (key: string) => CellPosition | null;
+export declare const generateWithoutCellKey: (dataLength: number) => string;
+export declare const isCellComment: (key: string) => boolean;
+export declare const getCellReference: (row: number, col: number) => string;
+export declare const formatCommentDateTime: (dateString: string) => string;

package/dist/editor/utils/compact-committed-celldata.d.ts

@@ -0,0 +1,28 @@
+import { CellMatrix, CellWithRowAndCol, Sheet } from '../../sheet-engine/core/types';
+import { SheetChangePath } from './update-ydoc';
+import * as Y from 'yjs';
+export declare const CELLDATA_COMPACT_STORAGE_KEY_PREFIX = "dsheet-celldata-compact-v1:";
+export type CelldataCompactionResult = {
+    removedFromYdoc: number;
+    clearedInMemory: number;
+    changes: SheetChangePath[];
+};
+export declare function celldataCompactStorageKey(dsheetId: string): string;
+export declare function hasCelldataCompactionCompleted(dsheetId: string): boolean;
+export declare function markCelldataCompactionCompleted(dsheetId: string): void;
+/** Collect Yjs celldata keys that should not be persisted (format-only / empty ghosts). */
+export declare function collectStaleCelldataKeys(celldataMap: Y.Map<unknown> | Record<string, unknown> | null | undefined): string[];
+export declare function buildCelldataDeleteChanges(sheetId: string, keys: string[]): SheetChangePath[];
+/** Null out dense-grid cells that should not be persisted. */
+export declare function compactSheetDataMatrix(data: CellMatrix | null | undefined): number;
+/** Drop sparse celldata entries that should not be persisted. */
+export declare function compactSheetCelldataArray(celldata: CellWithRowAndCol[] | null | undefined): {
+    next: CellWithRowAndCol[];
+    removed: number;
+};
+export declare function compactInMemorySheets(sheets: Sheet[] | null | undefined): number;
+/**
+ * Scan Y.Doc for committed celldata ghosts. Does not mutate — caller applies
+ * `changes` via `updateYdocSheetData`.
+ */
+export declare function planYdocCelldataCompaction(ydoc: Y.Doc, dsheetId: string): CelldataCompactionResult;

package/dist/editor/utils/config-ydoc-update.d.ts

@@ -0,0 +1,20 @@
+import { WorkbookInstance } from '../../sheet-engine/react';
+import { SheetChangePath } from './update-ydoc';
+
+import * as Y from 'yjs';
+/** Diff top-level config sub-keys and emit granular Yjs updates. */
+export declare function buildConfigSubKeyChanges({ sheetId, oldConfig, newConfig, }: {
+    sheetId: string;
+    oldConfig: Record<string, any>;
+    newConfig: Record<string, any>;
+}): SheetChangePath[];
+/**
+ * Sync active sheet config sub-keys to Yjs (borderInfo, merge, rowlen, …).
+ * Replaces whole-config writes so only changed sub-keys are broadcast.
+ */
+export declare const configYdocUpdate: ({ sheetEditorRef, ydocRef, dsheetId, handleContentPortal, }: {
+    sheetEditorRef: React.RefObject<WorkbookInstance | null>;
+    ydocRef: React.RefObject<Y.Doc | null>;
+    dsheetId: string;
+    handleContentPortal?: any;
+}) => void;

package/dist/editor/utils/csv-import.d.ts

@@ -2,4 +2,6 @@ import { default as React } from 'react';
 import { WorkbookInstance } from '../../sheet-engine/react';
 
 import * as Y from 'yjs';
-export declare const handleCSVUpload: (event: React.ChangeEventHandler<HTMLInputElement> | undefined, ydoc: Y.Doc | null, setForceSheetRender: React.Dispatch<React.SetStateAction<number>>, dsheetId: string, currentDataRef: React.MutableRefObject<object | null>, sheetEditorRef: React.RefObject<WorkbookInstance | null>, updateDocumentTitle?: (title: string) => void, fileArg?: File, importType?: string, handleContentPortal?: any, separatorType?: string) => Promise<void>;
+export declare const handleCSVUpload: (event: React.ChangeEventHandler<HTMLInputElement> | undefined, ydoc: Y.Doc | null, setForceSheetRender: React.Dispatch<React.SetStateAction<number>>, dsheetId: string, currentDataRef: React.MutableRefObject<object | null>, sheetEditorRef: React.RefObject<WorkbookInstance | null>, updateDocumentTitle?: (title: string) => void, fileArg?: File, importType?: string, handleContentPortal?: any, separatorType?: string, options?: {
+    suppressUiWarnings?: boolean;
+}) => Promise<void>;

package/dist/editor/utils/data-block-error-handler.d.ts

@@ -0,0 +1,21 @@
+import { Cell, WorkbookInstance } from '../../sheet-engine/react';
+import { DataBlockEvent, ErrorMessageHandlerReturnType } from '../types';
+import { ApiKeyStorage } from './api-key-storage';
+import { SmartContractQueryHandler } from './after-update-cell';
+
+export type OpenApiKeyModalFn = (apiKeyName: string, callbacks: {
+    onSave: (key: string) => void;
+    onClose: () => void;
+}) => void;
+export interface DataBlockErrorHandlerParams {
+    data: ErrorMessageHandlerReturnType;
+    sheetEditorRef: React.RefObject<WorkbookInstance | null>;
+    row: number;
+    column: number;
+    newValue: Cell;
+    apiKeyStorage: ApiKeyStorage;
+    openApiKeyModal: OpenApiKeyModalFn;
+    onDataBlockEvent?: (event: DataBlockEvent) => void;
+    handleSmartContractQuery?: SmartContractQueryHandler;
+}
+export declare const handleDataBlockError: ({ data, sheetEditorRef, row, column, newValue, apiKeyStorage, openApiKeyModal, onDataBlockEvent, handleSmartContractQuery, }: DataBlockErrorHandlerParams) => Promise<void>;

package/dist/editor/utils/datablock-error-utils.d.ts

@@ -0,0 +1 @@
+export declare const isDatablockError: (value: unknown) => boolean;

package/dist/editor/utils/defined-names-ydoc.d.ts

@@ -0,0 +1,31 @@
+import { WorkbookInstance } from '../../sheet-engine/react';
+import { DefinedName } from '../../sheet-engine/core/types';
+import { RefObject } from 'react';
+
+import * as Y from 'yjs';
+/** Sibling share key on the same Y.Doc as the sheet array. */
+export declare function getDefinedNamesMapKey(dsheetId: string): string;
+export declare function getDefinedNamesYMap(ydoc: Y.Doc, dsheetId: string): Y.Map<DefinedName>;
+/** Read workbook-level named ranges from Yjs (stable name order). */
+export declare function readDefinedNamesFromYdoc(ydoc: Y.Doc, dsheetId: string): DefinedName[];
+/**
+ * Prefer the sheet `Y.Array` share key when a doc has sibling maps
+ * (e.g. `${dsheetId}:definedNames`).
+ */
+export declare function resolveSheetArrayShareKey(doc: Y.Doc, preferredKey?: string): string | null;
+/**
+ * Diff Context definedNames against the Y.Map and apply set/delete by id.
+ */
+export declare function syncDefinedNamesToYdoc({ ydoc, dsheetId, definedNames, handleContentPortal, }: {
+    ydoc: Y.Doc;
+    dsheetId: string;
+    definedNames: DefinedName[];
+    handleContentPortal?: () => void;
+}): void;
+/** Push current workbook definedNames into Yjs (editor hook target). */
+export declare const definedNamesYdocUpdate: ({ sheetEditorRef, ydocRef, dsheetId, handleContentPortal, }: {
+    sheetEditorRef: RefObject<WorkbookInstance | null>;
+    ydocRef: RefObject<Y.Doc | null>;
+    dsheetId: string;
+    handleContentPortal?: () => void;
+}) => void;

package/dist/editor/utils/sheet-editor-safe.d.ts

@@ -0,0 +1,26 @@
+import { RefObject } from 'react';
+import { SheetEditorRef } from '../types/comments';
+
+type SheetEditorRefLike = RefObject<SheetEditorRef | null> | null | undefined;
+type WorkbookSheetLike = {
+    id?: string;
+    order?: number;
+    name?: string;
+};
+export declare function isWorkbookReady(ref: SheetEditorRefLike): boolean;
+export declare function getCurrentSheetSafe(ref: SheetEditorRefLike): WorkbookSheetLike | null;
+export declare function getCurrentSheetOrderSafe(ref: SheetEditorRefLike): number;
+export declare function getCurrentSheetIdSafe(ref: SheetEditorRefLike): string;
+export declare function getAllSheetsSafe(ref: SheetEditorRefLike): WorkbookSheetLike[];
+export declare function buildSheetOrderNameMap(ref: SheetEditorRefLike): Map<number, string>;
+/**
+ * Returns a map keyed by BOTH the sheet's immutable id AND its numeric
+ * order-as-string so that both new (UUID) and legacy (order) comment keys
+ * resolve to the correct display name in a single lookup.
+ */
+export declare function buildSheetIdNameMap(ref: SheetEditorRefLike): Map<string, string>;
+export declare function findSheetById(ref: SheetEditorRefLike, id: string): WorkbookSheetLike | null;
+export declare function activateSheetById(ref: SheetEditorRefLike, id: string): boolean;
+export declare function findSheetByOrder(ref: SheetEditorRefLike, order: number): WorkbookSheetLike | null;
+export declare function activateSheetByOrder(ref: SheetEditorRefLike, order: number): boolean;
+export {};