@candidstartup/infinisheet-types 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -187,8 +187,15 @@ interface StorageError extends InfinisheetError {
 /** Convenience method that creates a {@link StorageError} */
 declare function storageError(message: string, statusCode?: number): StorageError;
 
+/** Identifier for a blob of data in a blob store */
 type BlobId = string;
+/** Identifier for a workflow triggered writing to {@link LogMetadata.pending} */
 type WorkflowId = string;
+/**
+ * Identifier for an entry in an {@link EventLog}.
+ *
+ * Incrementing integer.
+*/
 type SequenceId = bigint;
 /**
  * Metadata stored in an {@link EventLog} entry
@@ -243,6 +250,13 @@ type QueryError = InfinisheetRangeError | StorageError;
 type TruncateError = InfinisheetRangeError | StorageError;
 /** Errors that can be returned by {@link EventLog} `setMetadata` method */
 type MetadataError = InfinisheetRangeError | StorageError;
+/** Value of a snapshot stored at a specific sequence id in the log */
+interface SnapshotValue {
+    /** Sequence id of log entry that stores this snapshot */
+    sequenceId: SequenceId;
+    /** Content of snapshot in the `BlobStore` */
+    blobId: BlobId;
+}
 /** A range of {@link LogEntry} values returned by querying an {@link EventLog} */
 interface QueryValue<T extends LogEntry> {
     /**  Sequence id corresponding to the first entry in `entries`
@@ -265,9 +279,24 @@ interface QueryValue<T extends LogEntry> {
      * from `nextSequenceId`.
      */
     isComplete: boolean;
+    /** Most recent snapshot
+     *
+     * Returned if query includes `snapshotId` argument and
+     * most recent snapshot is different.
+     */
+    lastSnapshot?: SnapshotValue | undefined;
     /** The {@link LogEntry} records returned by the query */
     entries: T[];
 }
+/** Result of calling {@link EventLog.addEntry} */
+interface AddEntryValue {
+    /** Most recent snapshot
+     *
+     * Returned if query includes `snapshotId` argument and
+     * most recent snapshot is different.
+     */
+    lastSnapshot?: SnapshotValue | undefined;
+}
 /** Abstract interface representing an event log
  *
  *
@@ -276,11 +305,16 @@ interface EventLog<T extends LogEntry> {
     /**
      * Add an entry to the log with the given sequence id
      *
-     * The `sequenceId` must be the next available sequence id in the log. This is returned as `endSequenceId` when
-     * making a query for the `last` entry in the log. Returns a {@link ConflictError} if not the next available id.
+     * @param sequenceId - The next available sequence id in the log.
+     * This is returned as `endSequenceId` when making a query for the `last` entry in the log.
+     * Returns a {@link ConflictError} if not the next available id.
+     *
+     * @param snapshotId - The sequence id for the most recent snapshot that the client is aware of.
+     * If there's a more recent snapshot, it's id will be returned in `AddEntryValue`.
+     *
      * Any other problem with serializing the entry will return a {@link StorageError}.
      */
-    addEntry(entry: T, sequenceId: SequenceId): ResultAsync<void, AddEntryError>;
+    addEntry(entry: T, sequenceId: SequenceId, snapshotId?: SequenceId): ResultAsync<AddEntryValue, AddEntryError>;
     /**
      * Set some or all of a log entry's metadata fields
      *
@@ -298,11 +332,141 @@ interface EventLog<T extends LogEntry> {
      * @param end - `SequenceId` one after the last entry to return.
      * Use `'end'` to query everything to the end of the log.
      */
-    query(start: SequenceId | 'snapshot' | 'start', end: SequenceId | 'end'): ResultAsync<QueryValue<T>, QueryError>;
+    query(start: SequenceId | 'snapshot' | 'start', end: SequenceId | 'end', snapshotId?: SequenceId): ResultAsync<QueryValue<T>, QueryError>;
     /** All entries prior to `start` are removed from the log. */
     truncate(start: SequenceId): ResultAsync<void, TruncateError>;
 }
 
+/**
+ * Name of a blob or directory within a {@link BlobDir}
+ *
+ * Names MUST NOT be longer than 100 characters
+ */
+type BlobName = string;
+/**
+ * Invalid {@link BlobName} error
+ *
+ * Occurs when trying to pass a `BlobName` that is too long or contains invalid characters
+ */
+interface InvalidBlobNameError extends InfinisheetError {
+    /** Discriminated union tag */
+    type: 'InvalidBlobNameError';
+}
+declare function invalidBlobNameError(message?: string): InvalidBlobNameError;
+/**
+ * Error when trying to access a blob as a directory or vice versa
+ *
+ * Occurs when trying to access a blob/directory with a
+ * {@link BlobName} that refers to a directory/blob
+ */
+interface BlobWrongKindError extends InfinisheetError {
+    /** Discriminated union tag */
+    type: 'BlobWrongKindError';
+}
+declare function notBlobError(): BlobWrongKindError;
+declare function notBlobDirError(): BlobWrongKindError;
+/**
+ * Invalid {@link BlobName} error
+ *
+ * Occurs when trying to pass a `BlobName` that is too long or contains invalid characters
+ */
+interface NoContinuationError extends InfinisheetError {
+    /** Discriminated union tag */
+    type: 'NoContinuationError';
+}
+declare function noContinuationError(message?: string): NoContinuationError;
+/** Errors that can be returned by {@link BlobDir.readBlob}  */
+type ReadBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;
+/** Errors that can be returned by {@link BlobDir.writeBlob} */
+type WriteBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;
+/** Errors that can be returned by {@link BlobDir.removeBlob} */
+type RemoveBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;
+/** Errors that can be returned by {@link BlobDir.getDir} */
+type GetDirError = BlobWrongKindError | InvalidBlobNameError | StorageError;
+/** Errors that can be returned by {@link BlobDir.query} */
+type DirQueryError = StorageError | NoContinuationError;
+/** Errors that can be returned by {@link BlobDir.removeAll} */
+type RemoveAllBlobDirError = StorageError;
+interface BlobDirEntries<ContinuationT> {
+    /** Names of blobs returned by {@link BlobDir.query} */
+    blobs: BlobName[];
+    /** Names of directories returned by {@link BlobDir.query} */
+    dirs: BlobName[];
+    /** Continuation token to pass to {@link BlobDir.query} if there are more entries to retrieve */
+    continuation?: ContinuationT | undefined;
+}
+/**
+ * Directory that contains blobs and other directories within a {@link BlobStore}
+ */
+interface BlobDir<ContinuationT> {
+    /** Read the content of a blob with the specified name.
+     *
+     * The returned content array is read only and immutable.
+     */
+    readBlob(name: BlobName): ResultAsync<Uint8Array, ReadBlobError>;
+    /** Write the specified content to a blob with the specified name.
+     *
+     * Any existing blob with that name is overwritten, otherwise a new blob is created.
+     * The content array is treated as read only and must be immutable until the operation completes.
+    */
+    writeBlob(name: BlobName, content: Uint8Array): ResultAsync<void, WriteBlobError>;
+    /** Remove blob with the specified name. */
+    removeBlob(name: BlobName): ResultAsync<void, RemoveBlobError>;
+    /** Get a {@link BlobDir} corresponding to the subdirectory with the specified name
+     *
+     * Subdirectories are "created" on demand
+    */
+    getDir(name: BlobName): ResultAsync<BlobDir<ContinuationT>, GetDirError>;
+    /** Query for blobs and sub-directories within this directory
+     *
+     * The order of entries returned is undefined.
+     *
+     * Can optionally pass a continuation token returned by the previous call to retrieve additional entries.
+    */
+    query(continuation?: ContinuationT): ResultAsync<BlobDirEntries<ContinuationT>, DirQueryError>;
+    /** Remove this directory and it's contents, recursively */
+    removeAll(): ResultAsync<void, RemoveAllBlobDirError>;
+}
+/** Errors that can be returned by {@link BlobStore.getRootDir} */
+type GetRootDirError = StorageError;
+/** Abstract interface representing a Blob store
+ *
+ * Modeled as a hierarchy of directories and blobs
+ */
+interface BlobStore<ContinuationT> {
+    /** Returns the root {@link BlobDir} for the store*/
+    getRootDir(): ResultAsync<BlobDir<ContinuationT>, GetRootDirError>;
+}
+
+interface WorkerMessage {
+    /** Used as a discriminated union tag by implementations */
+    type: string;
+}
+interface PendingWorkflowMessage extends WorkerMessage {
+    type: "PendingWorkflowMessage";
+    /** Workflow requested */
+    workflow: WorkflowId;
+    /** Sequence id of log entry that requested workflow */
+    sequenceId: SequenceId;
+}
+/** Type of handler function for {@link InfiniSheetWorker.onReceiveMessage} */
+type MessageHandler<MessageT extends WorkerMessage> = (message: MessageT) => ResultAsync<void, InfinisheetError>;
+interface WorkerHost<MessageT extends WorkerMessage> {
+    /**
+     * Place holder until we have some real implementation. Need something concrete
+     * to stop TypeScript moaning about the unused generic parameter and implementations
+     * without any properties in common with the interface they're implementing.
+     * @internal
+     */
+    isHost(): this is WorkerHost<MessageT>;
+}
+interface PostMessageWorkerHost<MessageT extends WorkerMessage> extends WorkerHost<MessageT> {
+    postMessage(message: MessageT): void;
+}
+interface InfiniSheetWorker<MessageT extends WorkerMessage> {
+    onReceiveMessage: MessageHandler<MessageT> | undefined;
+}
+
 /**
  * Interface used to determine the size and positioning offset for items in a single dimension.
  */
@@ -324,7 +488,6 @@ interface ItemOffsetMapping {
  * Implementation of {@link ItemOffsetMapping} for use when all items have a fixed size
  */
 declare class FixedSizeItemOffsetMapping implements ItemOffsetMapping {
-    #private;
     /**
      * @param itemSize - Size to use for all items
      */
@@ -332,13 +495,13 @@ declare class FixedSizeItemOffsetMapping implements ItemOffsetMapping {
     itemSize(_itemIndex: number): number;
     itemOffset(itemIndex: number): number;
     offsetToItem(offset: number): [itemIndex: number, startOffset: number];
+    private fixedItemSize;
 }
 
 /**
  * Implementation of {@link ItemOffsetMapping} for use when initial items have variable sizes.
  */
 declare class VariableSizeItemOffsetMapping implements ItemOffsetMapping {
-    #private;
     /**
      * @param defaultItemSize - Size to use for all other items
      * @param sizes - Array of sizes to use for the initial items, one size per item
@@ -347,6 +510,8 @@ declare class VariableSizeItemOffsetMapping implements ItemOffsetMapping {
     itemSize(itemIndex: number): number;
     itemOffset(itemIndex: number): number;
     offsetToItem(offset: number): [itemIndex: number, startOffset: number];
+    private defaultItemSize;
+    private sizes;
 }
 
 /** Possible spreadsheet error values
@@ -375,6 +540,30 @@ interface CellError {
  * explicitly marked as empty.
 */
 type CellValue = string | number | boolean | null | undefined | CellError;
+/** Format of cell typically used when displaying numbers */
+type CellFormat = string | undefined;
+/** Data stored in a spreadsheet cell */
+interface CellData {
+    /** Value of cell */
+    value: CellValue;
+    /** Format of cell */
+    format?: CellFormat;
+}
+/** A viewport onto the spreadsheet. Usually the portion of the spreadsheet visible on-screen. */
+interface SpreadsheetViewport {
+    /** Offset down the rows to the start of the viewport (using {@link ItemOffsetMapping} offsets) */
+    rowMinOffset: number;
+    /** Offset along the columns to the start of the viewport (using {@link ItemOffsetMapping} offsets) */
+    columnMinOffset: number;
+    /** Viewport width */
+    width: number;
+    /** Viewport height */
+    height: number;
+}
+/** Are two viewports equal by value? */
+declare function equalViewports(a: SpreadsheetViewport | undefined, b: SpreadsheetViewport | undefined): boolean;
+/** Creates an empty viewport */
+declare function emptyViewport(): SpreadsheetViewport;
 /** Types of error that can be returned by {@link SpreadsheetData} methods */
 type SpreadsheetDataError = ValidationError | StorageError;
 /**
@@ -392,6 +581,13 @@ interface SpreadsheetData<Snapshot> {
     subscribe(onDataChange: () => void): () => void;
     /** Return a snapshot to use when accessing values at a consistent point in time */
     getSnapshot(): Snapshot;
+    /**
+     * Return load status at the time the snapshot was created
+     *
+     * On Success returns true if load has completed, false if still in progress
+     * On Err returns most recent error reported by the storage system
+     */
+    getLoadStatus(snapshot: Snapshot): Result<boolean, StorageError>;
     /** Number of rows in the spreadsheet */
     getRowCount(snapshot: Snapshot): number;
     /** {@link ItemOffsetMapping} which describes sizes and offsets to start of rows */
@@ -403,29 +599,45 @@ interface SpreadsheetData<Snapshot> {
     /** Value of specified cell using 0-based row and column indexes */
     getCellValue(snapshot: Snapshot, row: number, column: number): CellValue;
     /** Format of specified cell using 0-based row and column indexes */
-    getCellFormat(snapshot: Snapshot, row: number, column: number): string | undefined;
+    getCellFormat(snapshot: Snapshot, row: number, column: number): CellFormat;
     /** Set value and format of specified cell
      *
      * @returns `Ok` if the change was successfully applied
      */
-    setCellValueAndFormat(row: number, column: number, value: CellValue, format: string | undefined): Result<void, SpreadsheetDataError>;
+    setCellValueAndFormat(row: number, column: number, value: CellValue, format: CellFormat): ResultAsync<void, SpreadsheetDataError>;
     /** Check whether value and format are valid to set for specified cell
      *
      * @returns `Ok` if the value and format are valid
      */
-    isValidCellValueAndFormat(row: number, column: number, value: CellValue, format: string | undefined): Result<void, ValidationError>;
+    isValidCellValueAndFormat(row: number, column: number, value: CellValue, format: CellFormat): Result<void, ValidationError>;
+    /** Set viewport of interest
+     *
+     * Can be used by `SpreadsheetData` implementations to optimize data retrieval and memory usage.
+     * Queries for cells outside the viewport *may* return `undefined`. Clients should not rely on any particular behavior
+     * for queries outside the viewport.
+     *
+     * Set to undefined (the default) if the client needs access to the entire spreadsheet
+     */
+    setViewport(viewport: SpreadsheetViewport | undefined): void;
+    /** Return the viewport in force (if any) */
+    getViewport(snapshot: Snapshot): SpreadsheetViewport | undefined;
 }
 declare class EmptySpreadsheetData implements SpreadsheetData<number> {
+    constructor();
     subscribe(_onDataChange: () => void): () => void;
     getSnapshot(): number;
+    getLoadStatus(_snapshot: number): Result<boolean, StorageError>;
     getRowCount(_snapshot: number): number;
     getRowItemOffsetMapping(_snapshot: number): ItemOffsetMapping;
     getColumnCount(_snapshot: number): number;
     getColumnItemOffsetMapping(_snapshot: number): ItemOffsetMapping;
     getCellValue(_snapshot: number, _row: number, _column: number): CellValue;
     getCellFormat(_snapshot: number, _row: number, _column: number): string | undefined;
-    setCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: string | undefined): Result<void, SpreadsheetDataError>;
-    isValidCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: string | undefined): Result<void, ValidationError>;
+    setCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: CellFormat): ResultAsync<void, SpreadsheetDataError>;
+    isValidCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: CellFormat): Result<void, ValidationError>;
+    setViewport(viewport: SpreadsheetViewport | undefined): void;
+    getViewport(_snapshot: number): SpreadsheetViewport | undefined;
+    private viewport;
 }
 
 /**  Classic Spreadsheet reference to Column (e.g "A") */
@@ -445,4 +657,5 @@ declare function rowColRefToCoords(ref: RowColRef): RowColCoords;
 /**  Converts {@link RowColCoords} to a {@link RowColRef} */
 declare function rowColCoordsToRef(row: number | undefined, col: number | undefined): RowColRef;
 
-export { type AddEntryError, type BlobId, type CellError, type CellErrorValue, type CellValue, type ColRef, type ConflictError, EmptySpreadsheetData, type Err, type EventLog, FixedSizeItemOffsetMapping, type InfinisheetError, type InfinisheetRangeError, type ItemOffsetMapping, type LogEntry, type LogMetadata, type MetadataError, type Ok, type QueryError, type QueryValue, type Result, ResultAsync, type RowColCoords, type RowColRef, type SequenceId, type SpreadsheetData, type SpreadsheetDataError, type StorageError, type TruncateError, type ValidationError, VariableSizeItemOffsetMapping, type WorkflowId, colRefToIndex, conflictError, err, errAsync, indexToColRef, infinisheetRangeError, ok, okAsync, rowColCoordsToRef, rowColRefToCoords, splitRowColRef, storageError, validationError };
+export { EmptySpreadsheetData, FixedSizeItemOffsetMapping, ResultAsync, VariableSizeItemOffsetMapping, colRefToIndex, conflictError, emptyViewport, equalViewports, err, errAsync, indexToColRef, infinisheetRangeError, invalidBlobNameError, noContinuationError, notBlobDirError, notBlobError, ok, okAsync, rowColCoordsToRef, rowColRefToCoords, splitRowColRef, storageError, validationError };
+export type { AddEntryError, AddEntryValue, BlobDir, BlobDirEntries, BlobId, BlobName, BlobStore, BlobWrongKindError, CellData, CellError, CellErrorValue, CellFormat, CellValue, ColRef, ConflictError, DirQueryError, Err, EventLog, GetDirError, GetRootDirError, InfiniSheetWorker, InfinisheetError, InfinisheetRangeError, InvalidBlobNameError, ItemOffsetMapping, LogEntry, LogMetadata, MessageHandler, MetadataError, NoContinuationError, Ok, PendingWorkflowMessage, PostMessageWorkerHost, QueryError, QueryValue, ReadBlobError, RemoveAllBlobDirError, RemoveBlobError, Result, RowColCoords, RowColRef, SequenceId, SnapshotValue, SpreadsheetData, SpreadsheetDataError, SpreadsheetViewport, StorageError, TruncateError, ValidationError, WorkerHost, WorkerMessage, WorkflowId, WriteBlobError };

package/dist/index.js

@@ -48,6 +48,15 @@ function conflictError(message, nextSequenceId) {
     return { type: 'ConflictError', message, nextSequenceId };
 }
 
+function invalidBlobNameError(message) {
+    return { type: 'InvalidBlobNameError', message: message ? message : "Invalid Blob Name" };
+}
+function notBlobError() { return { type: 'BlobWrongKindError', message: "Not a blob" }; }
+function notBlobDirError() { return { type: 'BlobWrongKindError', message: "Not a blob dir" }; }
+function noContinuationError(message) {
+    return { type: 'NoContinuationError', message: message ? message : "Can't continue query, start again" };
+}
+
 /**
  * Implementation of {@link ItemOffsetMapping} for use when all items have a fixed size
  */
@@ -56,20 +65,20 @@ class FixedSizeItemOffsetMapping {
      * @param itemSize - Size to use for all items
      */
     constructor(itemSize) {
-        this.#fixedItemSize = itemSize;
+        this.fixedItemSize = itemSize;
     }
     itemSize(_itemIndex) {
-        return this.#fixedItemSize;
+        return this.fixedItemSize;
     }
     itemOffset(itemIndex) {
-        return itemIndex * this.#fixedItemSize;
+        return itemIndex * this.fixedItemSize;
     }
     offsetToItem(offset) {
-        const itemIndex = Math.floor(offset / this.#fixedItemSize);
-        const startOffset = itemIndex * this.#fixedItemSize;
+        const itemIndex = Math.floor(offset / this.fixedItemSize);
+        const startOffset = itemIndex * this.fixedItemSize;
         return [itemIndex, startOffset];
     }
-    #fixedItemSize;
+    fixedItemSize;
 }
 
 /**
@@ -81,57 +90,79 @@ class VariableSizeItemOffsetMapping {
      * @param sizes - Array of sizes to use for the initial items, one size per item
      */
     constructor(defaultItemSize, sizes) {
-        this.#defaultItemSize = defaultItemSize;
-        this.#sizes = sizes;
+        this.defaultItemSize = defaultItemSize;
+        this.sizes = sizes;
     }
     itemSize(itemIndex) {
-        return (itemIndex < this.#sizes.length) ? this.#sizes[itemIndex] : this.#defaultItemSize;
+        return (itemIndex < this.sizes.length) ? this.sizes[itemIndex] : this.defaultItemSize;
     }
     itemOffset(itemIndex) {
         let offset = 0;
-        let length = this.#sizes.length;
+        let length = this.sizes.length;
         if (itemIndex > length) {
             const numDefaultSize = itemIndex - length;
-            offset = numDefaultSize * this.#defaultItemSize;
+            offset = numDefaultSize * this.defaultItemSize;
         }
         else {
             length = itemIndex;
         }
         for (let i = 0; i < length; i++) {
-            offset += this.#sizes[i];
+            offset += this.sizes[i];
         }
         return offset;
     }
     offsetToItem(offset) {
         let startOffset = 0;
-        for (const [i, size] of this.#sizes.entries()) {
+        for (const [i, size] of this.sizes.entries()) {
             if (startOffset + size > offset) {
                 return [i, startOffset];
             }
             startOffset += size;
         }
-        const itemIndex = Math.floor((offset - startOffset) / this.#defaultItemSize);
-        startOffset += itemIndex * this.#defaultItemSize;
-        const length = this.#sizes.length;
+        const itemIndex = Math.floor((offset - startOffset) / this.defaultItemSize);
+        startOffset += itemIndex * this.defaultItemSize;
+        const length = this.sizes.length;
         return [itemIndex + length, startOffset];
     }
-    #defaultItemSize;
-    #sizes;
+    defaultItemSize;
+    sizes;
 }
 
+/** Are two viewports equal by value? */
+function equalViewports(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return a.rowMinOffset === b.rowMinOffset &&
+        a.columnMinOffset === b.columnMinOffset &&
+        a.width === b.width &&
+        a.height === b.height;
+}
+/** Creates an empty viewport */
+function emptyViewport() {
+    return { rowMinOffset: 0, columnMinOffset: 0, width: 0, height: 0 };
+}
 const rowItemOffsetMapping = new FixedSizeItemOffsetMapping(30);
 const columnItemOffsetMapping = new FixedSizeItemOffsetMapping(100);
 class EmptySpreadsheetData {
+    constructor() {
+        this.viewport = undefined;
+    }
     subscribe(_onDataChange) { return () => { }; }
     getSnapshot() { return 0; }
+    getLoadStatus(_snapshot) { return ok(true); }
     getRowCount(_snapshot) { return 0; }
     getRowItemOffsetMapping(_snapshot) { return rowItemOffsetMapping; }
     getColumnCount(_snapshot) { return 0; }
     getColumnItemOffsetMapping(_snapshot) { return columnItemOffsetMapping; }
     getCellValue(_snapshot, _row, _column) { return null; }
     getCellFormat(_snapshot, _row, _column) { return undefined; }
-    setCellValueAndFormat(_row, _column, _value, _format) { return err(storageError("Not implemented", 501)); }
+    setCellValueAndFormat(_row, _column, _value, _format) { return errAsync(storageError("Not implemented", 501)); }
     isValidCellValueAndFormat(_row, _column, _value, _format) { return ok(); }
+    setViewport(viewport) { this.viewport = viewport; }
+    getViewport(_snapshot) { return this.viewport; }
+    viewport;
 }
 
 /** Converts a {@link ColRef} to the 0-based index of the column */
@@ -189,5 +220,5 @@ function rowColCoordsToRef(row, col) {
     }
 }
 
-export { EmptySpreadsheetData, FixedSizeItemOffsetMapping, ResultAsync, VariableSizeItemOffsetMapping, colRefToIndex, conflictError, err, errAsync, indexToColRef, infinisheetRangeError, ok, okAsync, rowColCoordsToRef, rowColRefToCoords, splitRowColRef, storageError, validationError };
+export { EmptySpreadsheetData, FixedSizeItemOffsetMapping, ResultAsync, VariableSizeItemOffsetMapping, colRefToIndex, conflictError, emptyViewport, equalViewports, err, errAsync, indexToColRef, infinisheetRangeError, invalidBlobNameError, noContinuationError, notBlobDirError, notBlobError, ok, okAsync, rowColCoordsToRef, rowColRefToCoords, splitRowColRef, storageError, validationError };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/Result.ts","../src/ResultAsync.ts","../src/Error.ts","../src/EventLog.ts","../src/FixedSizeItemOffsetMapping.ts","../src/VariableSizeItemOffsetMapping.ts","../src/SpreadsheetData.ts","../src/RowColRef.ts"],"sourcesContent":["import type { Ok as neverthrow_Ok, Err as neverthrow_Err } from \"neverthrow\";\nimport { err as neverthrow_err, ok as neverthrow_ok } from \"neverthrow\";\n\n/**\n * An `Ok` instance is the *successful* variant of the {@link Result} type, \n * representing a successful outcome from an operation which may fail.\n * \n * Implemented using [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport interface Ok<T,E> extends neverthrow_Ok<T,E> {}\n\n/**\n * An `Err` instance is the failure variant of the {@link Result} type, \n * representing a failure outcome from an operation which may fail.\n * \n * Implemented using [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport interface Err<T,E> extends neverthrow_Err<T,E> {}\n\n/**\n * A `Result` represents success ({@link Ok}) or failure ({@link Err}).\n * \n * Compatible with [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport type Result<T,E> = Ok<T,E> | Err<T,E>;\n\n/**\n * Create an instance of {@link Ok}.\n *\n * If you need to create an instance with a specific type (as you do whenever you\n * are not constructing immediately for a function return or as an argument to a\n * function), you can use a type parameter:\n *\n * ```ts\n * const yayNumber = ok<number, string>(12);\n * ```\n *\n * Note: passing nothing will produce a `Result<void, E>`, passing `undefined` will\n * produce a `Result<undefined, E>` which is compatible with `Result<void, E>`.\n *\n * ```ts\n * const normalResult = ok<number, string>(42);\n * const explicitUndefined = ok<undefined, string>(undefined);\n * const implicitVoid = ok<void, string>();\n * ```\n *\n * In the context of an immediate function return, or an arrow function with a\n * single expression value, you do not have to specify the types, so this can be\n * quite convenient.\n *\n * ```ts\n * const arrowValidate = (data: SomeData): Result<void, string> =>\n *   isValid(data) ? ok() : err('something was wrong!');\n *\n * function fnValidate(data: someData): Result<void, string> {\n *   return isValid(data) ? ok() : err('something was wrong');\n * }\n * ```\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param value - The value to wrap in a `Result.Ok`.\n */\nexport function ok<T, E = never>(value: T): Ok<T, E>\nexport function ok<_T extends void = void, E = never>(value: void): Ok<void, E>\nexport function ok<T, E = never>(value: T): Ok<T, E> {\n  return neverthrow_ok<T,E>(value); \n}\n\n/**\n * Create an instance of {@link Err}.\n *\n * If you need to create an instance with a specific type (as you do whenever you\n * are not constructing immediately for a function return or as an argument to a\n * function), you can use a type parameter:\n *\n * ```ts\n * const notString = err<number, string>('something went wrong');\n * ```\n *\n * Note: passing nothing will produce a `Result<T, void>`, passing `undefined` will\n * produce a `Result<T, undefined>` which is compatible with `Result<T, void>`.\n *\n * ```ts\n * const normalResult = err<number, string>('oh no');\n * const explicitUndefined = err<number, undefined>(undefined);\n * const implicitVoid = err<number, void>();\n * ```\n *\n * In the context of an immediate function return, or an arrow function with a\n * single expression value, you do not have to specify the types, so this can be\n * quite convenient.\n *\n * ```ts\n * const arrowValidate = (data: SomeData): Result<number, string> =>\n *   isValid(data) ? ok(42) : err('something went wrong');\n *\n * function fnValidate(data: someData): Result<number, string> {\n *   return isValid(data) ? ok(42) : err('something went wrong');\n * }\n * ```\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param err - The value to wrap in a `Result.Err`.\n */\nexport function err<T = never, E extends string = string>(err: E): Err<T, E>\nexport function err<T = never, E = unknown>(err: E): Err<T, E>\nexport function err<T = never, _E extends void = void>(err: void): Err<T, void>\nexport function err<T = never, E = unknown>(err: E): Err<T, E> {\n  return neverthrow_err<T,E>(err)\n}\n","import { errAsync as neverthrow_errAsync, okAsync as neverthrow_okAsync, ResultAsync as neverthrow_ResultAsync } from \"neverthrow\";\n\n// Needed for Intellisense links\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Result, Ok, Err } from \"./Result\"\n\n/**\n * `ResultAsync` allows you to work with asynchronous Results in a type safe way\n * \n * `ResultAsync<T,E>` is a wrapper around `Promise<Result<T,E>>` which provides the same methods for chaining different\n * `Result` and `ResultAsync` together as {@link Result}, while also chaining the asynchronous operations together using\n * `Promise.then`.\n * \n * `ResultAsync` is *thenable* (implements `PromiseLike<T>`) so can be used in most places that a `Promise` can, including with `await`.\n * \n * Compatible with [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `ResultAsync` for the success case\n * @typeParam E - The type of the error contained in the `ResultAsync` for the failure case\n */\nexport class ResultAsync<T,E> extends neverthrow_ResultAsync<T,E> {}\n\n/**\n * Create an instance of `ResultAsync` containing an {@link Ok} variant of {@link Result}\n *\n * Equivalent to `new ResultAsync(Promise.resolve(new Ok(value)))`\n *\n * @typeParam T - The type of the value contained in the `ResultAsync` for the success case\n * @typeParam E - The type of the error contained in the `ResultAsync` for the failure case\n * @param value - The value to wrap in a `Result.Ok`.\n */\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E>\nexport function okAsync<_T extends void = void, E = never>(value: void): ResultAsync<void, E>\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n  return neverthrow_okAsync(value);\n}\n\n/**\n * Create an instance of `ResultAsync` containing an {@link Err} variant of {@link Result}\n *\n * Equivalent to `new ResultAsync(Promise.resolve(new Err(err)))`\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param err - The value to wrap in a `Result.Err`.\n */\nexport function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E>\nexport function errAsync<T = never, _E extends void = void>(err: void): ResultAsync<T, void>\nexport function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E> {\n  return neverthrow_errAsync<T,E>(err)\n}\n","/** Common properties for Infinisheet errors */\nexport interface InfinisheetError {\n    /** Discriminated union tag */\n    type: string,\n\n    /** End user message describing the problem */\n    message: string,\n}\n\n/** \n * Attempt to access data that is outside the available range\n * \n */\nexport interface InfinisheetRangeError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'InfinisheetRangeError',\n\n};\n\n/** Convenience method that creates an {@link InfinisheetRangeError} */\nexport function infinisheetRangeError(message: string): InfinisheetRangeError {\n  return { type: 'InfinisheetRangeError', message };\n}\n\n/** Type that represents an error when validating data passed to an API */\nexport interface ValidationError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'ValidationError'\n};\n\n/** Convenience method that creates a {@link ValidationError} */\nexport function validationError(message: string): ValidationError {\n  return { type: 'ValidationError', message };\n}\n\n/** Type that represents an error when accessing data in persistent storage */\nexport interface StorageError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'StorageError',\n\n  /** HTTP style status code\n   * \n   * Describes the type of problem encountered. Expected to be a 4XX or 5XX code.\n   */\n  statusCode?: number | undefined,\n};\n\n/** Convenience method that creates a {@link StorageError} */\nexport function storageError(message: string, statusCode?: number): StorageError {\n  return { type: 'StorageError', message, statusCode };\n}","import { ResultAsync } from \"./ResultAsync\";\nimport { StorageError, InfinisheetError, InfinisheetRangeError } from \"./Error\"\n\nexport type BlobId = string;\nexport type WorkflowId = string;\nexport type SequenceId = bigint;\n\n/**\n * Metadata stored in an {@link EventLog} entry\n */\nexport interface LogMetadata {\n  /** Stores a reference to a snapshot of the complete log up to and including this entry */\n  snapshot?: BlobId | undefined;\n\n  /** Stores a reference to an external history of the event log up to and including the previous entry */\n  history?: BlobId | undefined;\n\n  /** Indicates that a background workflow is pending */\n  pending?: WorkflowId | undefined;\n}\n\n/** \n * Type that represents an entry in an {@link EventLog}\n * \n * Base interface that clients will typically implement multiple times.\n * Each concrete implementation will define its own data properties that\n * need to be serialized into the event log.\n * \n * Properties defined here are common metadata which require special handling\n * by any `EventLog` implementation.\n * \n * All data properties are immutable once an entry has been added to the log. Metadata\n * properties (apart from `type`) may change over time.\n */\nexport interface LogEntry extends LogMetadata {\n  /** Used as a discriminated union tag by implementations */\n  type: string;\n};\n\n/** \n * Type that represents a consistency conflict when adding a {@link LogEntry} to an {@link EventLog}\n * \n * Occurs when an attempt is made to add an entry with a sequence id that is not\n * the next available in the log.\n * \n * Typically happens when another client makes a change since you last read the log.\n * Sync with the additional log entries and then try again.\n */\nexport interface ConflictError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'ConflictError',\n\n  /** Next available sequence id */\n  nextSequenceId: SequenceId;\n};\n\n/** Convenience method that creates a {@link ConflictError} */\nexport function conflictError(message: string, nextSequenceId: SequenceId): ConflictError {\n  return { type: 'ConflictError', message, nextSequenceId };\n}\n\n/** Errors that can be returned by {@link EventLog} `addEntry` method */\nexport type AddEntryError = ConflictError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `query` method */\nexport type QueryError = InfinisheetRangeError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `truncate` method */\nexport type TruncateError = InfinisheetRangeError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `setMetadata` method */\nexport type MetadataError = InfinisheetRangeError | StorageError;\n\n/** A range of {@link LogEntry} values returned by querying an {@link EventLog} */\nexport interface QueryValue<T extends LogEntry> {\n  /**  Sequence id corresponding to the first entry in `entries`\n   * \n   * All other entries have consecutive ascending sequence ids\n   */\n  startSequenceId: SequenceId;\n\n  /** \n   * Sequence id after the final entry in `entries`\n   * \n   * If query was up to the `end` sequence id AND\n   * `isComplete` is true, this is the next available\n   * sequence id for `addEntry`. \n   */\n  endSequenceId: SequenceId;\n\n  /** True if all the requested entries have been returned\n   * \n   * Queries may return fewer entries than requested. If \n   * `isComplete` is `false`, repeat the query starting\n   * from `nextSequenceId`.\n   */\n  isComplete: boolean;\n\n  /** The {@link LogEntry} records returned by the query */\n  entries: T[];\n}\n\n/** Abstract interface representing an event log\n * \n * \n */\nexport interface EventLog<T extends LogEntry> {\n  /** \n   * Add an entry to the log with the given sequence id\n   * \n   * The `sequenceId` must be the next available sequence id in the log. This is returned as `endSequenceId` when\n   * making a query for the `last` entry in the log. Returns a {@link ConflictError} if not the next available id.\n   * Any other problem with serializing the entry will return a {@link StorageError}.\n   */\n  addEntry(entry: T, sequenceId: SequenceId): ResultAsync<void,AddEntryError>;\n\n  /**\n   * Set some or all of a log entry's metadata fields\n   *\n   * Changes are atomic. Either all of the specified fields are updated or none are.\n   */\n  setMetadata(sequenceId: SequenceId, metaData: LogMetadata): ResultAsync<void,MetadataError>;\n\n  /** Return a range of entries from `first` to `last` inclusive \n   * \n   * The event log may return fewer entries than requested. If so, repeat the query starting from `nextSequenceId`.\n   * \n   * @param start - `SequenceId` of first entry to return. \n   * Use `'start'` to query from the first entry in the log. \n   * Use `'snapshot'` to query from the most recent entry with a snapshot, or the first if no snapshot is defined.\n   * \n   * @param end - `SequenceId` one after the last entry to return.\n   * Use `'end'` to query everything to the end of the log.\n   */\n  query(start: SequenceId | 'snapshot' | 'start', end: SequenceId | 'end'): ResultAsync<QueryValue<T>,QueryError>;\n\n  /** All entries prior to `start` are removed from the log. */\n  truncate(start: SequenceId): ResultAsync<void,TruncateError>\n}","import type { ItemOffsetMapping } from './ItemOffsetMapping';\n\n/**\n * Implementation of {@link ItemOffsetMapping} for use when all items have a fixed size\n */\nexport class FixedSizeItemOffsetMapping implements ItemOffsetMapping {\n  /**\n   * @param itemSize - Size to use for all items\n   */\n  constructor (itemSize: number) {\n    this.#fixedItemSize = itemSize;\n  }\n\n  itemSize(_itemIndex: number): number {\n    return this.#fixedItemSize;\n  }\n\n  itemOffset(itemIndex: number): number {\n    return itemIndex * this.#fixedItemSize;\n  }\n\n  offsetToItem(offset: number): [itemIndex: number, startOffset: number] {\n    const itemIndex = Math.floor(offset / this.#fixedItemSize);\n    const startOffset = itemIndex * this.#fixedItemSize;\n\n    return [itemIndex, startOffset];\n  }\n\n  #fixedItemSize: number;\n}\n\n","import type { ItemOffsetMapping } from './ItemOffsetMapping';\n\n/**\n * Implementation of {@link ItemOffsetMapping} for use when initial items have variable sizes.\n */\nexport class VariableSizeItemOffsetMapping implements ItemOffsetMapping {\n  /**\n   * @param defaultItemSize - Size to use for all other items\n   * @param sizes - Array of sizes to use for the initial items, one size per item\n   */\n  constructor (defaultItemSize: number, sizes: number[]) {\n    this.#defaultItemSize = defaultItemSize;\n    this.#sizes = sizes;\n  }\n\n  itemSize(itemIndex: number): number {\n    return (itemIndex < this.#sizes.length) ? this.#sizes[itemIndex]! : this.#defaultItemSize;\n  }\n\n  itemOffset(itemIndex: number): number {\n    let offset = 0;\n    let length = this.#sizes.length;\n    if (itemIndex > length) {\n      const numDefaultSize = itemIndex - length;\n      offset = numDefaultSize * this.#defaultItemSize;\n    } else {\n      length = itemIndex;\n    }\n    \n    for (let i = 0; i < length; i ++)\n    {\n      offset += this.#sizes[i]!;\n    }\n\n    return offset;\n  }\n\n  offsetToItem(offset: number): [itemIndex: number, startOffset: number] {\n    let startOffset = 0;\n    for (const [i,size] of this.#sizes.entries()) {\n      if (startOffset + size > offset) {\n        return [i, startOffset];\n      }\n      startOffset += size;\n    }\n\n    const itemIndex = Math.floor((offset - startOffset) / this.#defaultItemSize);\n    startOffset += itemIndex * this.#defaultItemSize;\n\n    const length = this.#sizes.length;\n    return [itemIndex+length, startOffset];\n  }\n\n  #defaultItemSize: number;\n  #sizes: number[];\n}\n","import type { ItemOffsetMapping } from \"./ItemOffsetMapping\";\nimport { FixedSizeItemOffsetMapping } from \"./FixedSizeItemOffsetMapping\";\nimport { Result, err, ok } from \"./Result\";\nimport { ValidationError, StorageError, storageError } from \"./Error\";\n\n/** Possible spreadsheet error values\n * \n * Includes those that can be returned by `ERROR.TYPE` and additional values\n * introduced by more recent versions of Excel.\n*/\nexport type CellErrorValue = '#NULL!' | \n  '#DIV/0!' |\n  '#VALUE!' |\n  '#REF!' |\n  '#NAME?' |\n  '#NUM!' |\n  '#N/A' |\n  '#GETTING_DATA' |\n  '#SPILL!' |\n  '#UNKNOWN!' |\n  '#FIELD!' |\n  '#CALC!';\n\n/** Type that represents an error value stored in a cell\n * \n * Defined as a discriminated union so that additional cell value types\n * can be added in future.\n */\nexport interface CellError {\n  /** Discriminated union tag */\n  type: 'CellError',\n\n  /** {@link CellErrorValue | Error Value} */\n  value: CellErrorValue;\n};\n\n/** Possible types for a cell value \n * \n * The native JavaScript types string, number and boolean represent the *Text*, *Number* and *Logical*\n * spreadsheet data types. {@link CellError} represents an *Error Value*.\n * \n * Undefined is used to represent a cell with no defined value. Null represents a cell that has been\n * explicitly marked as empty. \n*/\nexport type CellValue = string | number | boolean | null | undefined | CellError\n\n/** Types of error that can be returned by {@link SpreadsheetData} methods */\nexport type SpreadsheetDataError = ValidationError | StorageError;\n\n/**\n * Interface used to access the data in a spreadsheet\n * \n * The data exposed through the interface may change over time outside of any changes made through the interface. The caller\n * can use the {@link subscribe} method to be notified when the data changes. When reading data, the caller must first request\n * a snapshot using {@link getSnapshot}. All values returned by gettors are relative to a specified snapshot. The values will be\n * consistent with each other as long as the same snapshot is used.\n * \n * @typeParam Snapshot - Type of snapshot. Implementations are free to use whatever type makes sense for them.\n */\nexport interface SpreadsheetData<Snapshot> {\n  /** Subscribe to data changes */\n  subscribe(onDataChange: () => void): () => void,\n\n  /** Return a snapshot to use when accessing values at a consistent point in time */\n  getSnapshot(): Snapshot,\n\n  /** Number of rows in the spreadsheet */\n  getRowCount(snapshot: Snapshot): number,\n\n  /** {@link ItemOffsetMapping} which describes sizes and offsets to start of rows */\n  getRowItemOffsetMapping(snapshot: Snapshot): ItemOffsetMapping,\n\n    /** Number of columns in the spreadsheet */\n  getColumnCount(snapshot: Snapshot): number,\n\n  /** {@link ItemOffsetMapping} which describes sizes and offsets to start of columns */\n  getColumnItemOffsetMapping(snapshot: Snapshot): ItemOffsetMapping,\n\n  /** Value of specified cell using 0-based row and column indexes */\n  getCellValue(snapshot: Snapshot, row: number, column: number): CellValue;\n\n  /** Format of specified cell using 0-based row and column indexes */\n  getCellFormat(snapshot: Snapshot, row: number, column: number): string | undefined;\n\n  /** Set value and format of specified cell\n   * \n   * @returns `Ok` if the change was successfully applied\n   */\n  setCellValueAndFormat(row: number, column: number, value: CellValue, format: string | undefined): Result<void,SpreadsheetDataError>\n\n  /** Check whether value and format are valid to set for specified cell\n   * \n   * @returns `Ok` if the value and format are valid\n   */\n  isValidCellValueAndFormat(row: number, column: number, value: CellValue, format: string | undefined): Result<void,ValidationError>\n}\n\nconst rowItemOffsetMapping = new FixedSizeItemOffsetMapping(30);\nconst columnItemOffsetMapping = new FixedSizeItemOffsetMapping(100);\n\nexport class EmptySpreadsheetData implements SpreadsheetData<number> {\n  subscribe(_onDataChange: () => void) { return () => {}; }\n  getSnapshot() { return 0; }\n  \n  getRowCount(_snapshot: number) { return 0; }\n  getRowItemOffsetMapping(_snapshot: number): ItemOffsetMapping { return rowItemOffsetMapping; }\n  getColumnCount(_snapshot: number) { return 0; }\n  getColumnItemOffsetMapping(_snapshot: number): ItemOffsetMapping { return columnItemOffsetMapping; }\n  getCellValue(_snapshot: number, _row: number, _column: number): CellValue { return null; }\n  getCellFormat(_snapshot: number, _row: number, _column: number): string|undefined { return undefined; }\n  setCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: string | undefined): Result<void,SpreadsheetDataError> \n  { return err(storageError(\"Not implemented\", 501)); }\n  isValidCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: string | undefined): Result<void,ValidationError> \n  { return ok(); }\n}\n\n","/**  Classic Spreadsheet reference to Column (e.g \"A\") */\nexport type ColRef = string;\n\n/**  Classic Spreadsheet reference to Cell (e.g. \"A1\"), Row (e.g. \"1\") or Column (e.g \"A\") */\nexport type RowColRef = string;\n\n/** Equivalent to {@link RowColRef} as coordinate pair. \"A1\" has coords [0,0], \"1\" is [0,undefined] and \"A\" is [undefined,0] */\nexport type RowColCoords = [row: number|undefined, col: number|undefined];\n\n/** Converts a {@link ColRef} to the 0-based index of the column */\nexport function colRefToIndex(col: ColRef): number {\n  let n = 0;\n  for (let i = 0; i < col.length; i ++) {\n    n = col.charCodeAt(i) - 64 + n * 26;\n  }\n  return n-1;\n}\n\n/** Converts a 0-based column index to a {@link ColRef} */\nexport function indexToColRef(index: number): ColRef {\n  let ret = \"\";\n  index ++;\n  while (index > 0) {\n    index --;\n    const remainder = index % 26;\n    index = Math.floor(index / 26);\n    ret = String.fromCharCode(65+remainder) + ret;\n  }\n  return ret;\n}\n\n/** Splits a RowColRef into a 0-based row index and a {@link ColRef} */\nexport function splitRowColRef(ref: RowColRef): [row: number|undefined, col: ColRef|undefined] {\n  const re = /^([A-Z]*)(\\d*)$/;\n  const found = ref.match(re);\n  if (!found)\n    return [undefined,undefined];\n\n  const col = found[1];\n  const row = found[2] ? parseInt(found[2]) : 0;\n  return [(row>0) ? row-1 : undefined, col ? col : undefined];\n}\n\n/**  Converts a {@link RowColRef} to {@link RowColCoords} */\nexport function rowColRefToCoords(ref: RowColRef): RowColCoords {\n  const [row,col] = splitRowColRef(ref);\n  return [row, col ? colRefToIndex(col) : undefined];\n}\n\n/**  Converts {@link RowColCoords} to a {@link RowColRef} */\nexport function rowColCoordsToRef(row: number|undefined, col: number|undefined): RowColRef {\n  if (row !== undefined) {\n    if (col !== undefined) {\n      return indexToColRef(col) + (row+1);\n    } else {\n      return (row+1).toString();\n    }\n  } else {\n    if (col !== undefined) {\n      return indexToColRef(col);\n    } else {\n      return \"\";\n    }\n  }\n}"],"names":["neverthrow_ok","neverthrow_err","neverthrow_ResultAsync","neverthrow_okAsync","neverthrow_errAsync"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/Result.ts","../src/ResultAsync.ts","../src/Error.ts","../src/EventLog.ts","../src/BlobStore.ts","../src/FixedSizeItemOffsetMapping.ts","../src/VariableSizeItemOffsetMapping.ts","../src/SpreadsheetData.ts","../src/RowColRef.ts"],"sourcesContent":["import type { Ok as neverthrow_Ok, Err as neverthrow_Err } from \"neverthrow\";\nimport { err as neverthrow_err, ok as neverthrow_ok } from \"neverthrow\";\n\n/**\n * An `Ok` instance is the *successful* variant of the {@link Result} type, \n * representing a successful outcome from an operation which may fail.\n * \n * Implemented using [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport interface Ok<T,E> extends neverthrow_Ok<T,E> {}\n\n/**\n * An `Err` instance is the failure variant of the {@link Result} type, \n * representing a failure outcome from an operation which may fail.\n * \n * Implemented using [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport interface Err<T,E> extends neverthrow_Err<T,E> {}\n\n/**\n * A `Result` represents success ({@link Ok}) or failure ({@link Err}).\n * \n * Compatible with [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n */\nexport type Result<T,E> = Ok<T,E> | Err<T,E>;\n\n/**\n * Create an instance of {@link Ok}.\n *\n * If you need to create an instance with a specific type (as you do whenever you\n * are not constructing immediately for a function return or as an argument to a\n * function), you can use a type parameter:\n *\n * ```ts\n * const yayNumber = ok<number, string>(12);\n * ```\n *\n * Note: passing nothing will produce a `Result<void, E>`, passing `undefined` will\n * produce a `Result<undefined, E>` which is compatible with `Result<void, E>`.\n *\n * ```ts\n * const normalResult = ok<number, string>(42);\n * const explicitUndefined = ok<undefined, string>(undefined);\n * const implicitVoid = ok<void, string>();\n * ```\n *\n * In the context of an immediate function return, or an arrow function with a\n * single expression value, you do not have to specify the types, so this can be\n * quite convenient.\n *\n * ```ts\n * const arrowValidate = (data: SomeData): Result<void, string> =>\n *   isValid(data) ? ok() : err('something was wrong!');\n *\n * function fnValidate(data: someData): Result<void, string> {\n *   return isValid(data) ? ok() : err('something was wrong');\n * }\n * ```\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param value - The value to wrap in a `Result.Ok`.\n */\nexport function ok<T, E = never>(value: T): Ok<T, E>\nexport function ok<_T extends void = void, E = never>(value: void): Ok<void, E>\nexport function ok<T, E = never>(value: T): Ok<T, E> {\n  return neverthrow_ok<T,E>(value); \n}\n\n/**\n * Create an instance of {@link Err}.\n *\n * If you need to create an instance with a specific type (as you do whenever you\n * are not constructing immediately for a function return or as an argument to a\n * function), you can use a type parameter:\n *\n * ```ts\n * const notString = err<number, string>('something went wrong');\n * ```\n *\n * Note: passing nothing will produce a `Result<T, void>`, passing `undefined` will\n * produce a `Result<T, undefined>` which is compatible with `Result<T, void>`.\n *\n * ```ts\n * const normalResult = err<number, string>('oh no');\n * const explicitUndefined = err<number, undefined>(undefined);\n * const implicitVoid = err<number, void>();\n * ```\n *\n * In the context of an immediate function return, or an arrow function with a\n * single expression value, you do not have to specify the types, so this can be\n * quite convenient.\n *\n * ```ts\n * const arrowValidate = (data: SomeData): Result<number, string> =>\n *   isValid(data) ? ok(42) : err('something went wrong');\n *\n * function fnValidate(data: someData): Result<number, string> {\n *   return isValid(data) ? ok(42) : err('something went wrong');\n * }\n * ```\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param err - The value to wrap in a `Result.Err`.\n */\nexport function err<T = never, E extends string = string>(err: E): Err<T, E>\nexport function err<T = never, E = unknown>(err: E): Err<T, E>\nexport function err<T = never, _E extends void = void>(err: void): Err<T, void>\nexport function err<T = never, E = unknown>(err: E): Err<T, E> {\n  return neverthrow_err<T,E>(err)\n}\n","import { errAsync as neverthrow_errAsync, okAsync as neverthrow_okAsync, ResultAsync as neverthrow_ResultAsync } from \"neverthrow\";\n\n// Needed for Intellisense links\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { Result, Ok, Err } from \"./Result\"\n\n/**\n * `ResultAsync` allows you to work with asynchronous Results in a type safe way\n * \n * `ResultAsync<T,E>` is a wrapper around `Promise<Result<T,E>>` which provides the same methods for chaining different\n * `Result` and `ResultAsync` together as {@link Result}, while also chaining the asynchronous operations together using\n * `Promise.then`.\n * \n * `ResultAsync` is *thenable* (implements `PromiseLike<T>`) so can be used in most places that a `Promise` can, including with `await`.\n * \n * Compatible with [`neverthrow`](https://github.com/supermacro/neverthrow)\n * \n * @typeParam T - The type of the value contained in the `ResultAsync` for the success case\n * @typeParam E - The type of the error contained in the `ResultAsync` for the failure case\n */\nexport class ResultAsync<T,E> extends neverthrow_ResultAsync<T,E> {}\n\n/**\n * Create an instance of `ResultAsync` containing an {@link Ok} variant of {@link Result}\n *\n * Equivalent to `new ResultAsync(Promise.resolve(new Ok(value)))`\n *\n * @typeParam T - The type of the value contained in the `ResultAsync` for the success case\n * @typeParam E - The type of the error contained in the `ResultAsync` for the failure case\n * @param value - The value to wrap in a `Result.Ok`.\n */\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E>\nexport function okAsync<_T extends void = void, E = never>(value: void): ResultAsync<void, E>\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n  return neverthrow_okAsync(value);\n}\n\n/**\n * Create an instance of `ResultAsync` containing an {@link Err} variant of {@link Result}\n *\n * Equivalent to `new ResultAsync(Promise.resolve(new Err(err)))`\n *\n * @typeParam T - The type of the value contained in the `Result` for the success case\n * @typeParam E - The type of the error contained in the `Result` for the failure case\n * @param err - The value to wrap in a `Result.Err`.\n */\nexport function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E>\nexport function errAsync<T = never, _E extends void = void>(err: void): ResultAsync<T, void>\nexport function errAsync<T = never, E = unknown>(err: E): ResultAsync<T, E> {\n  return neverthrow_errAsync<T,E>(err)\n}\n","/** Common properties for Infinisheet errors */\nexport interface InfinisheetError {\n    /** Discriminated union tag */\n    type: string,\n\n    /** End user message describing the problem */\n    message: string,\n}\n\n/** \n * Attempt to access data that is outside the available range\n * \n */\nexport interface InfinisheetRangeError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'InfinisheetRangeError',\n\n};\n\n/** Convenience method that creates an {@link InfinisheetRangeError} */\nexport function infinisheetRangeError(message: string): InfinisheetRangeError {\n  return { type: 'InfinisheetRangeError', message };\n}\n\n/** Type that represents an error when validating data passed to an API */\nexport interface ValidationError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'ValidationError'\n};\n\n/** Convenience method that creates a {@link ValidationError} */\nexport function validationError(message: string): ValidationError {\n  return { type: 'ValidationError', message };\n}\n\n/** Type that represents an error when accessing data in persistent storage */\nexport interface StorageError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'StorageError',\n\n  /** HTTP style status code\n   * \n   * Describes the type of problem encountered. Expected to be a 4XX or 5XX code.\n   */\n  statusCode?: number | undefined,\n};\n\n/** Convenience method that creates a {@link StorageError} */\nexport function storageError(message: string, statusCode?: number): StorageError {\n  return { type: 'StorageError', message, statusCode };\n}","import { ResultAsync } from \"./ResultAsync\";\nimport { StorageError, InfinisheetError, InfinisheetRangeError } from \"./Error\"\n\n/** Identifier for a blob of data in a blob store */\nexport type BlobId = string;\n\n/** Identifier for a workflow triggered writing to {@link LogMetadata.pending} */\nexport type WorkflowId = string;\n\n/** \n * Identifier for an entry in an {@link EventLog}.\n * \n * Incrementing integer.\n*/\nexport type SequenceId = bigint;\n\n/**\n * Metadata stored in an {@link EventLog} entry\n */\nexport interface LogMetadata {\n  /** Stores a reference to a snapshot of the complete log up to and including this entry */\n  snapshot?: BlobId | undefined;\n\n  /** Stores a reference to an external history of the event log up to and including the previous entry */\n  history?: BlobId | undefined;\n\n  /** Indicates that a background workflow is pending */\n  pending?: WorkflowId | undefined;\n}\n\n/** \n * Type that represents an entry in an {@link EventLog}\n * \n * Base interface that clients will typically implement multiple times.\n * Each concrete implementation will define its own data properties that\n * need to be serialized into the event log.\n * \n * Properties defined here are common metadata which require special handling\n * by any `EventLog` implementation.\n * \n * All data properties are immutable once an entry has been added to the log. Metadata\n * properties (apart from `type`) may change over time.\n */\nexport interface LogEntry extends LogMetadata {\n  /** Used as a discriminated union tag by implementations */\n  type: string;\n};\n\n/** \n * Type that represents a consistency conflict when adding a {@link LogEntry} to an {@link EventLog}\n * \n * Occurs when an attempt is made to add an entry with a sequence id that is not\n * the next available in the log.\n * \n * Typically happens when another client makes a change since you last read the log.\n * Sync with the additional log entries and then try again.\n */\nexport interface ConflictError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'ConflictError',\n\n  /** Next available sequence id */\n  nextSequenceId: SequenceId;\n};\n\n/** Convenience method that creates a {@link ConflictError} */\nexport function conflictError(message: string, nextSequenceId: SequenceId): ConflictError {\n  return { type: 'ConflictError', message, nextSequenceId };\n}\n\n/** Errors that can be returned by {@link EventLog} `addEntry` method */\nexport type AddEntryError = ConflictError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `query` method */\nexport type QueryError = InfinisheetRangeError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `truncate` method */\nexport type TruncateError = InfinisheetRangeError | StorageError;\n\n/** Errors that can be returned by {@link EventLog} `setMetadata` method */\nexport type MetadataError = InfinisheetRangeError | StorageError;\n\n/** Value of a snapshot stored at a specific sequence id in the log */\nexport interface SnapshotValue {\n  /** Sequence id of log entry that stores this snapshot */\n  sequenceId: SequenceId;\n\n  /** Content of snapshot in the `BlobStore` */\n  blobId: BlobId;\n}\n\n/** A range of {@link LogEntry} values returned by querying an {@link EventLog} */\nexport interface QueryValue<T extends LogEntry> {\n  /**  Sequence id corresponding to the first entry in `entries`\n   * \n   * All other entries have consecutive ascending sequence ids\n   */\n  startSequenceId: SequenceId;\n\n  /** \n   * Sequence id after the final entry in `entries`\n   * \n   * If query was up to the `end` sequence id AND\n   * `isComplete` is true, this is the next available\n   * sequence id for `addEntry`. \n   */\n  endSequenceId: SequenceId;\n\n  /** True if all the requested entries have been returned\n   * \n   * Queries may return fewer entries than requested. If \n   * `isComplete` is `false`, repeat the query starting\n   * from `nextSequenceId`.\n   */\n  isComplete: boolean;\n\n  /** Most recent snapshot\n   * \n   * Returned if query includes `snapshotId` argument and\n   * most recent snapshot is different. \n   */\n  lastSnapshot?: SnapshotValue | undefined;\n\n  /** The {@link LogEntry} records returned by the query */\n  entries: T[];\n}\n\n/** Result of calling {@link EventLog.addEntry} */\nexport interface AddEntryValue {\n  /** Most recent snapshot\n   * \n   * Returned if query includes `snapshotId` argument and\n   * most recent snapshot is different. \n   */\n  lastSnapshot?: SnapshotValue | undefined;\n}\n\n/** Abstract interface representing an event log\n * \n * \n */\nexport interface EventLog<T extends LogEntry> {\n  /** \n   * Add an entry to the log with the given sequence id\n   * \n   * @param sequenceId - The next available sequence id in the log. \n   * This is returned as `endSequenceId` when making a query for the `last` entry in the log. \n   * Returns a {@link ConflictError} if not the next available id.\n   * \n   * @param snapshotId - The sequence id for the most recent snapshot that the client is aware of.\n   * If there's a more recent snapshot, it's id will be returned in `AddEntryValue`. \n   * \n   * Any other problem with serializing the entry will return a {@link StorageError}.\n   */\n  addEntry(entry: T, sequenceId: SequenceId, snapshotId?: SequenceId): ResultAsync<AddEntryValue,AddEntryError>;\n\n  /**\n   * Set some or all of a log entry's metadata fields\n   *\n   * Changes are atomic. Either all of the specified fields are updated or none are.\n   */\n  setMetadata(sequenceId: SequenceId, metaData: LogMetadata): ResultAsync<void,MetadataError>;\n\n  /** Return a range of entries from `first` to `last` inclusive \n   * \n   * The event log may return fewer entries than requested. If so, repeat the query starting from `nextSequenceId`.\n   * \n   * @param start - `SequenceId` of first entry to return. \n   * Use `'start'` to query from the first entry in the log. \n   * Use `'snapshot'` to query from the most recent entry with a snapshot, or the first if no snapshot is defined.\n   * \n   * @param end - `SequenceId` one after the last entry to return.\n   * Use `'end'` to query everything to the end of the log.\n   */\n  query(start: SequenceId | 'snapshot' | 'start', end: SequenceId | 'end', snapshotId?: SequenceId): ResultAsync<QueryValue<T>,QueryError>;\n\n  /** All entries prior to `start` are removed from the log. */\n  truncate(start: SequenceId): ResultAsync<void,TruncateError>\n}","import { ResultAsync } from \"./ResultAsync\";\nimport { StorageError, InfinisheetError } from \"./Error\"\n\n/** \n * Name of a blob or directory within a {@link BlobDir}\n * \n * Names MUST NOT be longer than 100 characters\n */\nexport type BlobName = string;\n\n/** \n * Invalid {@link BlobName} error\n * \n * Occurs when trying to pass a `BlobName` that is too long or contains invalid characters\n */\nexport interface InvalidBlobNameError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'InvalidBlobNameError',\n};\n\nexport function invalidBlobNameError(message?: string): InvalidBlobNameError { \n  return { type: 'InvalidBlobNameError', message: message ? message : \"Invalid Blob Name\" }; \n}\n\n/** \n * Error when trying to access a blob as a directory or vice versa\n * \n * Occurs when trying to access a blob/directory with a\n * {@link BlobName} that refers to a directory/blob\n */\nexport interface BlobWrongKindError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'BlobWrongKindError',\n};\n\nexport function notBlobError(): BlobWrongKindError { return { type: 'BlobWrongKindError', message: \"Not a blob\"} }\nexport function notBlobDirError(): BlobWrongKindError { return { type: 'BlobWrongKindError', message: \"Not a blob dir\"} }\n\n/** \n * Invalid {@link BlobName} error\n * \n * Occurs when trying to pass a `BlobName` that is too long or contains invalid characters\n */\nexport interface NoContinuationError extends InfinisheetError {\n  /** Discriminated union tag */\n  type: 'NoContinuationError',\n};\n\nexport function noContinuationError(message?: string): NoContinuationError { \n  return { type: 'NoContinuationError', message: message ? message : \"Can't continue query, start again\" }; \n}\n\n/** Errors that can be returned by {@link BlobDir.readBlob}  */\nexport type ReadBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;\n\n/** Errors that can be returned by {@link BlobDir.writeBlob} */\nexport type WriteBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;\n\n/** Errors that can be returned by {@link BlobDir.removeBlob} */\nexport type RemoveBlobError = BlobWrongKindError | InvalidBlobNameError | StorageError;\n\n/** Errors that can be returned by {@link BlobDir.getDir} */\nexport type GetDirError = BlobWrongKindError | InvalidBlobNameError | StorageError;\n\n/** Errors that can be returned by {@link BlobDir.query} */\nexport type DirQueryError = StorageError | NoContinuationError;\n\n/** Errors that can be returned by {@link BlobDir.removeAll} */\nexport type RemoveAllBlobDirError = StorageError;\n\nexport interface BlobDirEntries<ContinuationT> {\n  /** Names of blobs returned by {@link BlobDir.query} */\n  blobs: BlobName[];\n\n  /** Names of directories returned by {@link BlobDir.query} */\n  dirs: BlobName[];\n\n  /** Continuation token to pass to {@link BlobDir.query} if there are more entries to retrieve */\n  continuation?: ContinuationT | undefined;\n}\n\n/**\n * Directory that contains blobs and other directories within a {@link BlobStore}\n */\nexport interface BlobDir<ContinuationT> {\n  /** Read the content of a blob with the specified name. \n   * \n   * The returned content array is read only and immutable. \n   */\n  readBlob(name: BlobName): ResultAsync<Uint8Array,ReadBlobError>;\n\n  /** Write the specified content to a blob with the specified name. \n   * \n   * Any existing blob with that name is overwritten, otherwise a new blob is created.\n   * The content array is treated as read only and must be immutable until the operation completes.\n  */\n  writeBlob(name: BlobName, content: Uint8Array): ResultAsync<void,WriteBlobError>;\n\n  /** Remove blob with the specified name. */\n  removeBlob(name: BlobName): ResultAsync<void,RemoveBlobError>;\n\n  /** Get a {@link BlobDir} corresponding to the subdirectory with the specified name \n   * \n   * Subdirectories are \"created\" on demand\n  */\n  getDir(name: BlobName): ResultAsync<BlobDir<ContinuationT>,GetDirError>;\n\n  /** Query for blobs and sub-directories within this directory \n   * \n   * The order of entries returned is undefined. \n   * \n   * Can optionally pass a continuation token returned by the previous call to retrieve additional entries.\n  */\n  query(continuation?: ContinuationT): ResultAsync<BlobDirEntries<ContinuationT>,DirQueryError>;\n\n  /** Remove this directory and it's contents, recursively */\n  removeAll(): ResultAsync<void,RemoveAllBlobDirError>;\n}\n\n/** Errors that can be returned by {@link BlobStore.getRootDir} */\nexport type GetRootDirError = StorageError;\n\n/** Abstract interface representing a Blob store\n * \n * Modeled as a hierarchy of directories and blobs\n */\nexport interface BlobStore<ContinuationT> {\n  /** Returns the root {@link BlobDir} for the store*/\n  getRootDir(): ResultAsync<BlobDir<ContinuationT>,GetRootDirError>;\n}\n","import type { ItemOffsetMapping } from './ItemOffsetMapping';\n\n/**\n * Implementation of {@link ItemOffsetMapping} for use when all items have a fixed size\n */\nexport class FixedSizeItemOffsetMapping implements ItemOffsetMapping {\n  /**\n   * @param itemSize - Size to use for all items\n   */\n  constructor (itemSize: number) {\n    this.fixedItemSize = itemSize;\n  }\n\n  itemSize(_itemIndex: number): number {\n    return this.fixedItemSize;\n  }\n\n  itemOffset(itemIndex: number): number {\n    return itemIndex * this.fixedItemSize;\n  }\n\n  offsetToItem(offset: number): [itemIndex: number, startOffset: number] {\n    const itemIndex = Math.floor(offset / this.fixedItemSize);\n    const startOffset = itemIndex * this.fixedItemSize;\n\n    return [itemIndex, startOffset];\n  }\n\n  private fixedItemSize: number;\n}\n\n","import type { ItemOffsetMapping } from './ItemOffsetMapping';\n\n/**\n * Implementation of {@link ItemOffsetMapping} for use when initial items have variable sizes.\n */\nexport class VariableSizeItemOffsetMapping implements ItemOffsetMapping {\n  /**\n   * @param defaultItemSize - Size to use for all other items\n   * @param sizes - Array of sizes to use for the initial items, one size per item\n   */\n  constructor (defaultItemSize: number, sizes: number[]) {\n    this.defaultItemSize = defaultItemSize;\n    this.sizes = sizes;\n  }\n\n  itemSize(itemIndex: number): number {\n    return (itemIndex < this.sizes.length) ? this.sizes[itemIndex]! : this.defaultItemSize;\n  }\n\n  itemOffset(itemIndex: number): number {\n    let offset = 0;\n    let length = this.sizes.length;\n    if (itemIndex > length) {\n      const numDefaultSize = itemIndex - length;\n      offset = numDefaultSize * this.defaultItemSize;\n    } else {\n      length = itemIndex;\n    }\n    \n    for (let i = 0; i < length; i ++)\n    {\n      offset += this.sizes[i]!;\n    }\n\n    return offset;\n  }\n\n  offsetToItem(offset: number): [itemIndex: number, startOffset: number] {\n    let startOffset = 0;\n    for (const [i,size] of this.sizes.entries()) {\n      if (startOffset + size > offset) {\n        return [i, startOffset];\n      }\n      startOffset += size;\n    }\n\n    const itemIndex = Math.floor((offset - startOffset) / this.defaultItemSize);\n    startOffset += itemIndex * this.defaultItemSize;\n\n    const length = this.sizes.length;\n    return [itemIndex+length, startOffset];\n  }\n\n  private defaultItemSize: number;\n  private sizes: number[];\n}\n","import type { ItemOffsetMapping } from \"./ItemOffsetMapping\";\nimport { FixedSizeItemOffsetMapping } from \"./FixedSizeItemOffsetMapping\";\nimport { Result, ok } from \"./Result\";\nimport { ResultAsync, errAsync } from \"./ResultAsync\";\nimport { ValidationError, StorageError, storageError } from \"./Error\";\n\n/** Possible spreadsheet error values\n * \n * Includes those that can be returned by `ERROR.TYPE` and additional values\n * introduced by more recent versions of Excel.\n*/\nexport type CellErrorValue = '#NULL!' | \n  '#DIV/0!' |\n  '#VALUE!' |\n  '#REF!' |\n  '#NAME?' |\n  '#NUM!' |\n  '#N/A' |\n  '#GETTING_DATA' |\n  '#SPILL!' |\n  '#UNKNOWN!' |\n  '#FIELD!' |\n  '#CALC!';\n\n/** Type that represents an error value stored in a cell\n * \n * Defined as a discriminated union so that additional cell value types\n * can be added in future.\n */\nexport interface CellError {\n  /** Discriminated union tag */\n  type: 'CellError',\n\n  /** {@link CellErrorValue | Error Value} */\n  value: CellErrorValue;\n};\n\n/** Possible types for a cell value \n * \n * The native JavaScript types string, number and boolean represent the *Text*, *Number* and *Logical*\n * spreadsheet data types. {@link CellError} represents an *Error Value*.\n * \n * Undefined is used to represent a cell with no defined value. Null represents a cell that has been\n * explicitly marked as empty. \n*/\nexport type CellValue = string | number | boolean | null | undefined | CellError\n\n/** Format of cell typically used when displaying numbers */\nexport type CellFormat = string | undefined;\n\n/** Data stored in a spreadsheet cell */\nexport interface CellData {\n  /** Value of cell */\n  value: CellValue;\n\n  /** Format of cell */\n  format?: CellFormat;\n}\n\n/** A viewport onto the spreadsheet. Usually the portion of the spreadsheet visible on-screen. */\nexport interface SpreadsheetViewport {\n  /** Offset down the rows to the start of the viewport (using {@link ItemOffsetMapping} offsets) */\n  rowMinOffset: number,\n\n  /** Offset along the columns to the start of the viewport (using {@link ItemOffsetMapping} offsets) */\n  columnMinOffset: number,\n\n  /** Viewport width */\n  width: number,\n\n  /** Viewport height */\n  height: number\n}\n\n/** Are two viewports equal by value? */\nexport function equalViewports(a: SpreadsheetViewport | undefined, b: SpreadsheetViewport | undefined): boolean {\n  if (a === b)\n    return true;\n\n  if (!a || !b)\n    return false;\n\n  return a.rowMinOffset === b.rowMinOffset &&\n    a.columnMinOffset === b.columnMinOffset &&\n    a.width === b.width &&\n    a.height === b.height;\n}\n\n/** Creates an empty viewport */\nexport function emptyViewport(): SpreadsheetViewport {\n  return { rowMinOffset: 0, columnMinOffset: 0, width: 0, height: 0 }\n}\n\n/** Types of error that can be returned by {@link SpreadsheetData} methods */\nexport type SpreadsheetDataError = ValidationError | StorageError;\n\n/**\n * Interface used to access the data in a spreadsheet\n * \n * The data exposed through the interface may change over time outside of any changes made through the interface. The caller\n * can use the {@link subscribe} method to be notified when the data changes. When reading data, the caller must first request\n * a snapshot using {@link getSnapshot}. All values returned by gettors are relative to a specified snapshot. The values will be\n * consistent with each other as long as the same snapshot is used.\n * \n * @typeParam Snapshot - Type of snapshot. Implementations are free to use whatever type makes sense for them.\n */\nexport interface SpreadsheetData<Snapshot> {\n  /** Subscribe to data changes */\n  subscribe(onDataChange: () => void): () => void\n\n  /** Return a snapshot to use when accessing values at a consistent point in time */\n  getSnapshot(): Snapshot\n\n  /** \n   * Return load status at the time the snapshot was created \n   * \n   * On Success returns true if load has completed, false if still in progress\n   * On Err returns most recent error reported by the storage system\n   */\n  getLoadStatus(snapshot: Snapshot): Result<boolean,StorageError>\n\n  /** Number of rows in the spreadsheet */\n  getRowCount(snapshot: Snapshot): number\n\n  /** {@link ItemOffsetMapping} which describes sizes and offsets to start of rows */\n  getRowItemOffsetMapping(snapshot: Snapshot): ItemOffsetMapping\n\n    /** Number of columns in the spreadsheet */\n  getColumnCount(snapshot: Snapshot): number\n\n  /** {@link ItemOffsetMapping} which describes sizes and offsets to start of columns */\n  getColumnItemOffsetMapping(snapshot: Snapshot): ItemOffsetMapping\n\n  /** Value of specified cell using 0-based row and column indexes */\n  getCellValue(snapshot: Snapshot, row: number, column: number): CellValue\n\n  /** Format of specified cell using 0-based row and column indexes */\n  getCellFormat(snapshot: Snapshot, row: number, column: number): CellFormat\n\n  /** Set value and format of specified cell\n   * \n   * @returns `Ok` if the change was successfully applied\n   */\n  setCellValueAndFormat(row: number, column: number, value: CellValue, format: CellFormat): ResultAsync<void,SpreadsheetDataError>\n\n  /** Check whether value and format are valid to set for specified cell\n   * \n   * @returns `Ok` if the value and format are valid\n   */\n  isValidCellValueAndFormat(row: number, column: number, value: CellValue, format: CellFormat): Result<void,ValidationError>\n\n  /** Set viewport of interest\n   * \n   * Can be used by `SpreadsheetData` implementations to optimize data retrieval and memory usage.\n   * Queries for cells outside the viewport *may* return `undefined`. Clients should not rely on any particular behavior\n   * for queries outside the viewport.\n   * \n   * Set to undefined (the default) if the client needs access to the entire spreadsheet\n   */\n  setViewport(viewport: SpreadsheetViewport | undefined): void\n\n  /** Return the viewport in force (if any) */\n  getViewport(snapshot: Snapshot): SpreadsheetViewport | undefined\n}\n\nconst rowItemOffsetMapping = new FixedSizeItemOffsetMapping(30);\nconst columnItemOffsetMapping = new FixedSizeItemOffsetMapping(100);\n\nexport class EmptySpreadsheetData implements SpreadsheetData<number> {\n  constructor() {\n    this.viewport = undefined;\n  }\n\n  subscribe(_onDataChange: () => void) { return () => {}; }\n  getSnapshot() { return 0; }\n  \n  getLoadStatus(_snapshot: number): Result<boolean,StorageError> { return ok(true); }\n  getRowCount(_snapshot: number) { return 0; }\n  getRowItemOffsetMapping(_snapshot: number): ItemOffsetMapping { return rowItemOffsetMapping; }\n  getColumnCount(_snapshot: number) { return 0; }\n  getColumnItemOffsetMapping(_snapshot: number): ItemOffsetMapping { return columnItemOffsetMapping; }\n  getCellValue(_snapshot: number, _row: number, _column: number): CellValue { return null; }\n  getCellFormat(_snapshot: number, _row: number, _column: number): string|undefined { return undefined; }\n  setCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: CellFormat): ResultAsync<void,SpreadsheetDataError> \n  { return errAsync(storageError(\"Not implemented\", 501)); }\n  isValidCellValueAndFormat(_row: number, _column: number, _value: CellValue, _format: CellFormat): Result<void,ValidationError> \n  { return ok(); }\n\n  setViewport(viewport: SpreadsheetViewport | undefined): void { this.viewport = viewport; }\n  getViewport(_snapshot: number): SpreadsheetViewport | undefined { return this.viewport }\n\n  private viewport: SpreadsheetViewport | undefined;\n}\n\n","/**  Classic Spreadsheet reference to Column (e.g \"A\") */\nexport type ColRef = string;\n\n/**  Classic Spreadsheet reference to Cell (e.g. \"A1\"), Row (e.g. \"1\") or Column (e.g \"A\") */\nexport type RowColRef = string;\n\n/** Equivalent to {@link RowColRef} as coordinate pair. \"A1\" has coords [0,0], \"1\" is [0,undefined] and \"A\" is [undefined,0] */\nexport type RowColCoords = [row: number|undefined, col: number|undefined];\n\n/** Converts a {@link ColRef} to the 0-based index of the column */\nexport function colRefToIndex(col: ColRef): number {\n  let n = 0;\n  for (let i = 0; i < col.length; i ++) {\n    n = col.charCodeAt(i) - 64 + n * 26;\n  }\n  return n-1;\n}\n\n/** Converts a 0-based column index to a {@link ColRef} */\nexport function indexToColRef(index: number): ColRef {\n  let ret = \"\";\n  index ++;\n  while (index > 0) {\n    index --;\n    const remainder = index % 26;\n    index = Math.floor(index / 26);\n    ret = String.fromCharCode(65+remainder) + ret;\n  }\n  return ret;\n}\n\n/** Splits a RowColRef into a 0-based row index and a {@link ColRef} */\nexport function splitRowColRef(ref: RowColRef): [row: number|undefined, col: ColRef|undefined] {\n  const re = /^([A-Z]*)(\\d*)$/;\n  const found = ref.match(re);\n  if (!found)\n    return [undefined,undefined];\n\n  const col = found[1];\n  const row = found[2] ? parseInt(found[2]) : 0;\n  return [(row>0) ? row-1 : undefined, col ? col : undefined];\n}\n\n/**  Converts a {@link RowColRef} to {@link RowColCoords} */\nexport function rowColRefToCoords(ref: RowColRef): RowColCoords {\n  const [row,col] = splitRowColRef(ref);\n  return [row, col ? colRefToIndex(col) : undefined];\n}\n\n/**  Converts {@link RowColCoords} to a {@link RowColRef} */\nexport function rowColCoordsToRef(row: number|undefined, col: number|undefined): RowColRef {\n  if (row !== undefined) {\n    if (col !== undefined) {\n      return indexToColRef(col) + (row+1);\n    } else {\n      return (row+1).toString();\n    }\n  } else {\n    if (col !== undefined) {\n      return indexToColRef(col);\n    } else {\n      return \"\";\n    }\n  }\n}"],"names":["neverthrow_ok","neverthrow_err","neverthrow_ResultAsync","neverthrow_okAsync","neverthrow_errAsync"],"mappings":";;AA0EM,SAAU,EAAE,CAAe,KAAQ,EAAA;AACvC,IAAA,OAAOA,IAAa,CAAM,KAAK,CAAC;AAClC;AA0CM,SAAU,GAAG,CAAyB,GAAM,EAAA;AAChD,IAAA,OAAOC,KAAc,CAAM,GAAG,CAAC;AACjC;;AClHA;;;;;;;;;;;;;AAaG;AACG,MAAO,WAAiB,SAAQC,aAA2B,CAAA;AAAG;AAa9D,SAAU,OAAO,CAAe,KAAQ,EAAA;AAC5C,IAAA,OAAOC,SAAkB,CAAC,KAAK,CAAC;AAClC;AAaM,SAAU,QAAQ,CAAyB,GAAM,EAAA;AACrD,IAAA,OAAOC,UAAmB,CAAM,GAAG,CAAC;AACtC;;AC/BA;AACM,SAAU,qBAAqB,CAAC,OAAe,EAAA;AACnD,IAAA,OAAO,EAAE,IAAI,EAAE,uBAAuB,EAAE,OAAO,EAAE;AACnD;AAQA;AACM,SAAU,eAAe,CAAC,OAAe,EAAA;AAC7C,IAAA,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE;AAC7C;AAcA;AACM,SAAU,YAAY,CAAC,OAAe,EAAE,UAAmB,EAAA;IAC/D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,UAAU,EAAE;AACtD;;ACeA;AACM,SAAU,aAAa,CAAC,OAAe,EAAE,cAA0B,EAAA;IACvE,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,cAAc,EAAE;AAC3D;;AChDM,SAAU,oBAAoB,CAAC,OAAgB,EAAA;AACnD,IAAA,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,mBAAmB,EAAE;AAC3F;AAaM,SAAU,YAAY,GAAA,EAAyB,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,YAAY,EAAC,CAAA,CAAC;AAC3G,SAAU,eAAe,GAAA,EAAyB,OAAO,EAAE,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,gBAAgB,EAAC,CAAA,CAAC;AAYlH,SAAU,mBAAmB,CAAC,OAAgB,EAAA;AAClD,IAAA,OAAO,EAAE,IAAI,EAAE,qBAAqB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,mCAAmC,EAAE;AAC1G;;AChDA;;AAEG;MACU,0BAA0B,CAAA;AACrC;;AAEG;AACH,IAAA,WAAA,CAAa,QAAgB,EAAA;AAC3B,QAAA,IAAI,CAAC,aAAa,GAAG,QAAQ;IAC/B;AAEA,IAAA,QAAQ,CAAC,UAAkB,EAAA;QACzB,OAAO,IAAI,CAAC,aAAa;IAC3B;AAEA,IAAA,UAAU,CAAC,SAAiB,EAAA;AAC1B,QAAA,OAAO,SAAS,GAAG,IAAI,CAAC,aAAa;IACvC;AAEA,IAAA,YAAY,CAAC,MAAc,EAAA;AACzB,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC;AACzD,QAAA,MAAM,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC,aAAa;AAElD,QAAA,OAAO,CAAC,SAAS,EAAE,WAAW,CAAC;IACjC;AAEQ,IAAA,aAAa;AACtB;;AC3BD;;AAEG;MACU,6BAA6B,CAAA;AACxC;;;AAGG;IACH,WAAA,CAAa,eAAuB,EAAE,KAAe,EAAA;AACnD,QAAA,IAAI,CAAC,eAAe,GAAG,eAAe;AACtC,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;IACpB;AAEA,IAAA,QAAQ,CAAC,SAAiB,EAAA;QACxB,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAE,GAAG,IAAI,CAAC,eAAe;IACxF;AAEA,IAAA,UAAU,CAAC,SAAiB,EAAA;QAC1B,IAAI,MAAM,GAAG,CAAC;AACd,QAAA,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;AAC9B,QAAA,IAAI,SAAS,GAAG,MAAM,EAAE;AACtB,YAAA,MAAM,cAAc,GAAG,SAAS,GAAG,MAAM;AACzC,YAAA,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC,eAAe;QAChD;aAAO;YACL,MAAM,GAAG,SAAS;QACpB;AAEA,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAG,EAChC;AACE,YAAA,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAE;QAC1B;AAEA,QAAA,OAAO,MAAM;IACf;AAEA,IAAA,YAAY,CAAC,MAAc,EAAA;QACzB,IAAI,WAAW,GAAG,CAAC;AACnB,QAAA,KAAK,MAAM,CAAC,CAAC,EAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE;AAC3C,YAAA,IAAI,WAAW,GAAG,IAAI,GAAG,MAAM,EAAE;AAC/B,gBAAA,OAAO,CAAC,CAAC,EAAE,WAAW,CAAC;YACzB;YACA,WAAW,IAAI,IAAI;QACrB;AAEA,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,WAAW,IAAI,IAAI,CAAC,eAAe,CAAC;AAC3E,QAAA,WAAW,IAAI,SAAS,GAAG,IAAI,CAAC,eAAe;AAE/C,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM;AAChC,QAAA,OAAO,CAAC,SAAS,GAAC,MAAM,EAAE,WAAW,CAAC;IACxC;AAEQ,IAAA,eAAe;AACf,IAAA,KAAK;AACd;;ACmBD;AACM,SAAU,cAAc,CAAC,CAAkC,EAAE,CAAkC,EAAA;IACnG,IAAI,CAAC,KAAK,CAAC;AACT,QAAA,OAAO,IAAI;AAEb,IAAA,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;AACV,QAAA,OAAO,KAAK;AAEd,IAAA,OAAO,CAAC,CAAC,YAAY,KAAK,CAAC,CAAC,YAAY;AACtC,QAAA,CAAC,CAAC,eAAe,KAAK,CAAC,CAAC,eAAe;AACvC,QAAA,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK;AACnB,QAAA,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;AACzB;AAEA;SACgB,aAAa,GAAA;AAC3B,IAAA,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;AACrE;AA0EA,MAAM,oBAAoB,GAAG,IAAI,0BAA0B,CAAC,EAAE,CAAC;AAC/D,MAAM,uBAAuB,GAAG,IAAI,0BAA0B,CAAC,GAAG,CAAC;MAEtD,oBAAoB,CAAA;AAC/B,IAAA,WAAA,GAAA;AACE,QAAA,IAAI,CAAC,QAAQ,GAAG,SAAS;IAC3B;IAEA,SAAS,CAAC,aAAyB,EAAA,EAAI,OAAO,MAAK,EAAE,CAAC,CAAC,CAAC;AACxD,IAAA,WAAW,GAAA,EAAK,OAAO,CAAC,CAAC,CAAC;IAE1B,aAAa,CAAC,SAAiB,EAAA,EAAkC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAClF,IAAA,WAAW,CAAC,SAAiB,EAAA,EAAI,OAAO,CAAC,CAAC,CAAC;AAC3C,IAAA,uBAAuB,CAAC,SAAiB,EAAA,EAAuB,OAAO,oBAAoB,CAAC,CAAC;AAC7F,IAAA,cAAc,CAAC,SAAiB,EAAA,EAAI,OAAO,CAAC,CAAC,CAAC;AAC9C,IAAA,0BAA0B,CAAC,SAAiB,EAAA,EAAuB,OAAO,uBAAuB,CAAC,CAAC;IACnG,YAAY,CAAC,SAAiB,EAAE,IAAY,EAAE,OAAe,EAAA,EAAe,OAAO,IAAI,CAAC,CAAC;IACzF,aAAa,CAAC,SAAiB,EAAE,IAAY,EAAE,OAAe,EAAA,EAAsB,OAAO,SAAS,CAAC,CAAC;IACtG,qBAAqB,CAAC,IAAY,EAAE,OAAe,EAAE,MAAiB,EAAE,OAAmB,EAAA,EACzF,OAAO,QAAQ,CAAC,YAAY,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AACzD,IAAA,yBAAyB,CAAC,IAAY,EAAE,OAAe,EAAE,MAAiB,EAAE,OAAmB,EAAA,EAC7F,OAAO,EAAE,EAAE,CAAC,CAAC;IAEf,WAAW,CAAC,QAAyC,EAAA,EAAU,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC;IACzF,WAAW,CAAC,SAAiB,EAAA,EAAqC,OAAO,IAAI,CAAC,QAAQ,CAAA,CAAC;AAE/E,IAAA,QAAQ;AACjB;;ACvLD;AACM,SAAU,aAAa,CAAC,GAAW,EAAA;IACvC,IAAI,CAAC,GAAG,CAAC;AACT,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAG,EAAE;AACpC,QAAA,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE;IACrC;IACA,OAAO,CAAC,GAAC,CAAC;AACZ;AAEA;AACM,SAAU,aAAa,CAAC,KAAa,EAAA;IACzC,IAAI,GAAG,GAAG,EAAE;AACZ,IAAA,KAAK,EAAG;AACR,IAAA,OAAO,KAAK,GAAG,CAAC,EAAE;AAChB,QAAA,KAAK,EAAG;AACR,QAAA,MAAM,SAAS,GAAG,KAAK,GAAG,EAAE;QAC5B,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QAC9B,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,EAAE,GAAC,SAAS,CAAC,GAAG,GAAG;IAC/C;AACA,IAAA,OAAO,GAAG;AACZ;AAEA;AACM,SAAU,cAAc,CAAC,GAAc,EAAA;IAC3C,MAAM,EAAE,GAAG,iBAAiB;IAC5B,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;AAC3B,IAAA,IAAI,CAAC,KAAK;AACR,QAAA,OAAO,CAAC,SAAS,EAAC,SAAS,CAAC;AAE9B,IAAA,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;IACpB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC7C,OAAO,CAAC,CAAC,GAAG,GAAC,CAAC,IAAI,GAAG,GAAC,CAAC,GAAG,SAAS,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;AAC7D;AAEA;AACM,SAAU,iBAAiB,CAAC,GAAc,EAAA;IAC9C,MAAM,CAAC,GAAG,EAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC;AACrC,IAAA,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;AACpD;AAEA;AACM,SAAU,iBAAiB,CAAC,GAAqB,EAAE,GAAqB,EAAA;AAC5E,IAAA,IAAI,GAAG,KAAK,SAAS,EAAE;AACrB,QAAA,IAAI,GAAG,KAAK,SAAS,EAAE;YACrB,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,GAAG,GAAC,CAAC,CAAC;QACrC;aAAO;YACL,OAAO,CAAC,GAAG,GAAC,CAAC,EAAE,QAAQ,EAAE;QAC3B;IACF;SAAO;AACL,QAAA,IAAI,GAAG,KAAK,SAAS,EAAE;AACrB,YAAA,OAAO,aAAa,CAAC,GAAG,CAAC;QAC3B;aAAO;AACL,YAAA,OAAO,EAAE;QACX;IACF;AACF;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@candidstartup/infinisheet-types",
   "private": false,
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Common types for the InfiniSheet packages",
   "author": "Tim Wiegand <tim.wiegand@thecandidstartup.org>",
   "license": "BSD-3-Clause",
@@ -52,5 +52,5 @@
   "dependencies": {
     "neverthrow": "^8.2.0"
   },
-  "gitHead": "0c72d04996502cb84f8720972bfda453e4989106"
+  "gitHead": "ca46dae5575a3011416803e2b159457ecb59eaee"
 }