@sheetxl/sdk 0.7.22 → 0.7.23-beta.2

package/types/src/i18n/LanguagePack.d.ts

@@ -0,0 +1,97 @@
+import { FormulaError } from '@sheetxl/primitives';
+import { MinifiedDescriptor } from '@sheetxl/scripting';
+import { LanguagePack as BaseLanguagePack, LanguageTag } from '@sheetxl/utils';
+/**
+ * The **spreadsheet-language plane** of a language pack (I18N-DESIGN.md Plane 3): function names,
+ * error values, boolean literals, and function help.
+ *
+ * Plain interface extension, NOT module augmentation. The previous version declared these fields
+ * onto `@sheetxl/utils`'s `LanguagePack`, which was wrong in four ways: it gave a utils type
+ * knowledge of spreadsheets (an inverted dependency), applied ambiently to anyone who merely
+ * compiled the SDK anywhere in their program, made the fields look supported by the base type when
+ * no SDK is present, and gave no ownership boundary if a second package ever wanted its own plane.
+ *
+ * The runtime is unchanged — still ONE plain pack object, no shape copies — because a pack carrying
+ * these fields is structurally a valid {@link BaseLanguagePack} and registers as one.
+ *
+ * `@sheetxl/sdk` re-exports `@sheetxl/utils`, and an explicit local export takes precedence over a
+ * star re-export, so `import { LanguagePack } from '@sheetxl/sdk'` yields THIS one while
+ * `from '@sheetxl/utils'` still yields the generic base. Consumers inside the spreadsheet SDK get
+ * the spreadsheet flavour without asking.
+ */
+/**
+ * Localized structured-reference specifier words, keyed by canonical section. German Excel writes
+ * `[#All]`→`[#Alle]`, `[#Data]`→`[#Daten]`, `[#Headers]`→`[#Kopfzeilen]`, `[#Totals]`→`[#Ergebnisse]`,
+ * `[#This Row]`→`[#Diese Zeile]`. Consumed by the SR lexer (builds its specifier regex alternates) and
+ * the parse/emit path (localized ⇄ canonical); canonical English is always accepted. Storage stays
+ * canonical (`[#All]`).
+ */
+export interface SRSpecifiers {
+    all: string;
+    data: string;
+    headers: string;
+    totals: string;
+    thisRow: string;
+}
+export interface LanguagePack extends BaseLanguagePack {
+    /**
+     * Localized spreadsheet function names by canonical name (`SUM` → `SUMME`).
+     * Consumed by `FunctionSymbolProvider`: bind accepts localized AND canonical
+     * (round-trip never breaks); resolve displays localized. Identity entries are
+     * unnecessary (canonical is the fallback). Custom/UDF names are never localized.
+     */
+    functions?: Record<string, string>;
+    /** Localized formula error values by canonical id (`Value` → `#WERT!`). */
+    errors?: Record<string, string>;
+    /** Localized boolean literals (`WAHR`/`FALSCH`). */
+    booleans?: {
+        true: string;
+        false: string;
+    };
+    /** Localized structured-reference specifier words (`[#All]` → `[#Alle]`). */
+    specifiers?: SRSpecifiers;
+    /**
+     * Function help (summaries/parameter copy, ~2k strings) — a nested lazy chunk keyed by
+     * canonical function name, loaded only when a tooltip/insert-function dialog resolves a
+     * descriptor. Values are {@link MinifiedDescriptor}s — the SAME shape the built-in
+     * descriptor modules compile to, so a generated per-locale module IS a pack chunk with
+     * no reshaping; `initializeFunctions` overlays it per-field over the built-in English.
+     */
+    functionHelp?: () => Promise<Record<string, MinifiedDescriptor> | {
+        default: Record<string, MinifiedDescriptor>;
+    }>;
+}
+/**
+ * The active (or `tag`'s) spreadsheet-language pack — the MERGE of every contributor's plane: the
+ * function-owning packages (`@sheetxl/formulas`, `@sheetxl/formulas-extended`) supply function names
+ * and help via {@link DefaultLanguagePackService.registerPack}; the SDK supplies error/boolean literals;
+ * the host app's pack overrides any of them. utils returns the packs opaquely ({@link getPacks}); the
+ * merge semantics (which fields deep-merge, how `functionHelp` loaders compose) live HERE, the one
+ * layer that knows what these fields mean.
+ *
+ * The merged pack is cached per tag and invalidated on language change, so it is a STABLE object for a
+ * given (tag, contributor-set) — `FunctionSymbolProvider` and the function-help overlay both key their
+ * caches on the pack identity, which requires that stability.
+ */
+export declare function getLanguagePack(tag?: LanguageTag): LanguagePack | undefined;
+/**
+ * The boolean literal in the active spreadsheet language (`WAHR`/`FALSCH`), for DISPLAY and text
+ * coercion (`=TRUE&""`). Falls back to canonical English. Storage/APIs stay canonical.
+ */
+export declare function localizeBoolean(value: boolean, tag?: LanguageTag): string;
+/**
+ * A formula error's label in the active spreadsheet language (`#WERT!`), for DISPLAY. Falls back to
+ * the canonical label when the language does not translate that error. Files/APIs stay canonical.
+ */
+export declare function localizeErrorLabel(error: FormulaError.Known, tag?: LanguageTag): string;
+/**
+ * Parse a typed boolean literal in the active spreadsheet language. English `TRUE`/`FALSE` are ALWAYS
+ * accepted; the pack's words (`WAHR`/`FALSCH`) are accepted too. Returns `undefined` for anything else.
+ */
+export declare function parseBooleanLocal(str: string, tag?: LanguageTag): boolean | undefined;
+/**
+ * Parse a typed error literal in the active spreadsheet language. Canonical labels (`#VALUE!`) are
+ * ALWAYS accepted; the pack's localized labels (`#WERT!`) are accepted too. `undefined` otherwise.
+ */
+export declare function parseErrorLocal(str: string, tag?: LanguageTag): FormulaError.Known | undefined;
+//# sourceMappingURL=LanguagePack.d.ts.map

package/types/src/i18n/LanguagePack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguagePack.d.ts","sourceRoot":"","sources":["../../../../src/i18n/LanguagePack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,KAAK,YAAY,IAAI,gBAAgB,EAAE,KAAK,WAAW,EACxD,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;GAiBG;AACH;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAa,SAAQ,gBAAgB;IACpD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,oDAAoD;IACpD,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG;QAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;KAAE,CAAC,CAAC;CACpH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,GAAG,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,CAgB3E;AAMD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,WAAW,GAAG,MAAM,CAGzE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,WAAW,GAAG,MAAM,CAKvF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,GAAG,OAAO,GAAG,SAAS,CAUrF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC,KAAK,GAAG,SAAS,CAgB9F"}

package/types/src/i18n/LocaleProfile.d.ts

@@ -0,0 +1,15 @@
+import { LocaleProfile, LocaleProfileOverrides } from '@sheetxl/primitives';
+export type { LocaleProfile };
+/** --- Public factory ----------------------------------------------------- */
+export declare function makeLocaleProfile(tag: string, overrides?: LocaleProfileOverrides | null): LocaleProfile;
+/**
+ * Memoized {@link makeLocaleProfile}.
+ *
+ * @remarks
+ * Building a profile probes `Intl` a dozen times, which is measurably expensive.
+ * Callers on hot paths (input parsing, formatting) should use this rather than
+ * constructing a profile per call. `overrides` participate in the cache key, so a
+ * workbook's customized profile is memoized just like a plain-tag one.
+ */
+export declare function getLocaleProfile(tag: string, overrides?: LocaleProfileOverrides | null): LocaleProfile;
+//# sourceMappingURL=LocaleProfile.d.ts.map

package/types/src/i18n/LocaleProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocaleProfile.d.ts","sourceRoot":"","sources":["../../../../src/i18n/LocaleProfile.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAAE,KAAK,sBAAsB,EAChD,MAAM,qBAAqB,CAAC;AAM7B,YAAY,EAAE,aAAa,EAAE,CAAC;AA+M9B,+EAA+E;AAE/E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,sBAAsB,GAAG,IAAI,GAAG,aAAa,CAkFvG;AA6BD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,sBAAsB,GAAG,IAAI,GAAG,aAAa,CAQtG"}

package/types/src/i18n/_CurrencyData.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Region -> ISO 4217 currency.
+ *
+ * @remarks
+ * Neither `Intl` nor `numfmt` exposes a region's currency: `Intl.Locale` has no
+ * currency accessor at all, and `Intl.NumberFormat` requires the code to be
+ * supplied before it will render a symbol. Excel reads this from the OS
+ * (`LOCALE_SCURRENCY` on Windows), which the browser cannot see -- hence this
+ * table, distilled from CLDR `supplementalData/currencyData`.
+ *
+ * Current tender only; historical currencies are deliberately omitted. Regions
+ * not listed fall back to {@link DEFAULT_CURRENCY}, and a workbook can always
+ * override the symbol.
+ *
+ * @internal
+ */
+export declare const DEFAULT_CURRENCY = "USD";
+/** @internal */
+export declare const REGION_CURRENCY: Record<string, string>;
+//# sourceMappingURL=_CurrencyData.d.ts.map

package/types/src/i18n/_CurrencyData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_CurrencyData.d.ts","sourceRoot":"","sources":["../../../../src/i18n/_CurrencyData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AAEtC,gBAAgB;AAChB,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiDlD,CAAC"}

package/types/src/i18n/functionLocales.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wire spreadsheet-language data loading to the active language: register the current language's packs
+ * now, and any language switched to later. Idempotent — safe to call from every `initializeFunctions`.
+ */
+export declare function registerFunctionLocales(): void;
+//# sourceMappingURL=functionLocales.d.ts.map

package/types/src/i18n/functionLocales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionLocales.d.ts","sourceRoot":"","sources":["../../../../src/i18n/functionLocales.ts"],"names":[],"mappings":"AA2EA;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAO9C"}

package/types/src/i18n/index.d.ts

@@ -0,0 +1,4 @@
+export * from './LocaleProfile';
+export * from './LanguagePack';
+export * from './locales';
+//# sourceMappingURL=index.d.ts.map

package/types/src/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/i18n/index.ts"],"names":[],"mappings":"AAIA,cAAc,iBAAiB,CAAC;AAIhC,cAAc,gBAAgB,CAAC;AAI/B,cAAc,WAAW,CAAC"}

package/types/src/i18n/locales.d.ts

@@ -0,0 +1,3 @@
+/** Register this package's locale resources: the bundled `en` floor + all fetched locales. Idempotent. */
+export declare function registerSdkLocales(): Promise<void>;
+//# sourceMappingURL=locales.d.ts.map

package/types/src/i18n/locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../../src/i18n/locales.ts"],"names":[],"mappings":"AAwBA,0GAA0G;AAC1G,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAGlD"}

package/types/src/index.d.ts

@@ -0,0 +1,71 @@
+export * from '@sheetxl/primitives';
+export * from '@sheetxl/utils';
+export * from './type';
+export * from './io';
+export * from './transaction';
+export * from './history';
+export * from './license';
+export * from './utils';
+export * from './listener';
+export * from './i18n';
+export * from './resource/resourceKinds';
+export type { LanguagePack } from './i18n/LanguagePack';
+export * from './collections/Tuple';
+export * from './protection';
+export * from './autoFill';
+export * from './print';
+export * from './font';
+export * from './fill';
+export * from './color';
+export * from './border';
+export * from './text';
+export * from './condition';
+export * from './sort';
+export * from './filter';
+export * from './comment';
+export * from './hyperlink';
+export * from './numFmt';
+export * from './style';
+export * from './resource';
+export * from './string';
+export * from './anchored';
+export * from './chart';
+export * from './picture';
+export * from './scripting';
+export * from './calculation';
+export * from './address';
+export * from './cell';
+export * from './cellRange';
+export * from './date';
+export * from './font';
+export * from './movable';
+export * from './selection';
+export * from './named';
+export * from './externalBook';
+export * from './dataValidation';
+export * from './conditionalFormat';
+export * from './protectedRange';
+export * from './slicer';
+export * from './table';
+export { Table } from './table/Table';
+export * from './theme';
+export * from './sheet';
+export * from './sheetHeader';
+export * from './sheetProtection';
+export * from './sheetView';
+export * from './workbook';
+export * from './workbookProtection';
+export * from './workbookView';
+/**
+ * The current version of the SDK.
+ * @hidden
+ * @internal
+ */
+export declare const VERSION: string;
+/**
+ * The build date of the SDK.
+ * @hidden
+ * @internal
+ */
+export declare const BUILD_DATE: string;
+//# sourceMappingURL=index.d.ts.map

package/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAE/B,cAAc,QAAQ,CAAC;AACvB,cAAc,MAAM,CAAC;AACrB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAE1B,cAAc,WAAW,CAAC;AAE1B,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,0BAA0B,CAAC;AAMzC,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD,cAAc,qBAAqB,CAAC;AAEpC,cAAc,cAAc,CAAC;AAE7B,cAAc,YAAY,CAAC;AAE3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AAEvB,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AAEzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAExB,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAE1B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAE1B,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAE5B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAE5B,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AAEzB,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC,cAAc,SAAS,CAAC;AAExB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAA;AAE3B,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAE/B;;;;GAIG;AACH,eAAO,MAAM,OAAO,QAAsE,CAAC;AAC3F;;;;GAIG;AACH,eAAO,MAAM,UAAU,QAAgE,CAAC"}

package/types/src/io/AbstractBackingStore.d.ts

@@ -0,0 +1,53 @@
+import { IWorkbook } from '../workbook';
+import { IWorkbookIO } from './IWorkbookIO';
+type SourceType = 'base64' | 'fetch' | 'buffer' | 'file' | 'blob' | 'stream' | 'filepath';
+/**
+ * Base class for the built-in platform backing stores ({@link IWorkbookIO.IBackingStore}).
+ *
+ * @remarks
+ * Implements the platform-agnostic **read** path — source-type detection and byte acquisition
+ * (File/Blob/URL/ArrayBuffer/base64/stream) — and delegates the two platform-specific pieces to
+ * subclasses: reading a local path ({@link AbstractBackingStore.filePathToFile}) and writing
+ * ({@link AbstractBackingStore.write}). Format detection and workbook construction are not done
+ * here; they are handled by {@link IWorkbookIO.ReadRequest.decode}.
+ */
+export declare abstract class AbstractBackingStore implements IWorkbookIO.IBackingStore {
+    /** @inheritdoc IWorkbookIO.IBackingStore.write */
+    abstract write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin | null>;
+    /** @inheritdoc IWorkbookIO.IBackingStore.read */
+    read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
+    /**
+     * Resolves a source when {@link AbstractBackingStore.read} is called without one — for example
+     * a browser open picker. The base implementation resolves nothing.
+     */
+    protected resolveSource(_request: IWorkbookIO.ReadRequest): Promise<any>;
+    /**
+     * Hook invoked after a workbook has been read, so a subclass can associate session state with
+     * it (e.g. cache an opened file handle for silent save-back). The base implementation is a no-op.
+     */
+    protected onWorkbookRead(_workbook: IWorkbook, _source: any): Promise<void>;
+    /**
+     * Reads a local file path into a `File`. Platform-specific: node reads from `fs`; the browser
+     * throws (use a file input or fetch instead).
+     */
+    protected abstract filePathToFile(filePath: string): Promise<File>;
+    /**
+     * Whether a source acquired from a local path can be written back to (a silent re-save).
+     * Node can; the browser cannot (paths are not writable without a handle).
+     */
+    protected _canWriteLocalPath(): boolean;
+    /**
+     * The source type to assume for an ambiguous string - a bare or relative path with no scheme.
+     * Node-like stores treat these as local file paths; the browser treats them as fetchable urls.
+     * Resolved by which store the environment selected, not by runtime detection.
+     */
+    protected _defaultStringSourceType: SourceType;
+    /**
+     * Detects the source type from the provided value, or `null` if it cannot be determined.
+     *
+     * @internal
+     */
+    protected _detectSourceType(source: any): SourceType | null;
+}
+export {};
+//# sourceMappingURL=AbstractBackingStore.d.ts.map

package/types/src/io/AbstractBackingStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractBackingStore.d.ts","sourceRoot":"","sources":["../../../../src/io/AbstractBackingStore.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,KAAK,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE1F;;;;;;;;;GASG;AACH,8BAAsB,oBAAqB,YAAW,WAAW,CAAC,aAAa;IAE7E,kDAAkD;IAClD,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC;IAErF,iDAAiD;IAC3C,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA0KvE;;;OAGG;cACa,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAI9E;;;OAGG;cACa,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjF;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAElE;;;OAGG;IACH,SAAS,CAAC,kBAAkB,IAAI,OAAO;IAIvC;;;;OAIG;IACH,SAAS,CAAC,wBAAwB,EAAE,UAAU,CAAc;IAE5D;;;;OAIG;IACH,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,GAAG,GAAG,UAAU,GAAG,IAAI;CAuD5D"}

package/types/src/io/ArrayBackingStore.d.ts

@@ -0,0 +1,34 @@
+import { IWorkbook } from '../workbook';
+import { IWorkbookIO } from './IWorkbookIO';
+/**
+ * An in-memory {@link IWorkbookIO.IBackingStore} that captures the encoded workbook bytes
+ * instead of persisting them anywhere.
+ *
+ * @remarks
+ * This is the minimal **reference implementation** of a backing store — a good starting point
+ * for writing your own (e.g. a VSCode host or a cloud upload). A store only has to encode the
+ * workbook and return the written {@link IWorkbookIO.Origin} handle; everything else (origin
+ * resolution, suggested name, format) is handled by {@link IWorkbookIO.write} before the store
+ * is called.
+ *
+ * @example
+ * ```typescript
+ * const store = new ArrayBackingStore();
+ * WorkbookIO.setBackingStore(store);
+ * await WorkbookIO.write(workbook, { format: 'xlsx' });
+ * const bytes = store.buffer; // the encoded workbook
+ * ```
+ */
+export declare class ArrayBackingStore implements IWorkbookIO.IBackingStore {
+    private _buffer;
+    private _formatKey;
+    /**
+     * The bytes captured by the most recent {@link ArrayBackingStore.write}, or `null` if none.
+     */
+    get buffer(): ArrayBufferLike | null;
+    /** @inheritdoc IWorkbookIO.IBackingStore.write */
+    write(request: IWorkbookIO.WriteRequest): Promise<IWorkbookIO.Origin>;
+    /** @inheritdoc IWorkbookIO.IBackingStore.read */
+    read(request: IWorkbookIO.ReadRequest): Promise<IWorkbook | null>;
+}
+//# sourceMappingURL=ArrayBackingStore.d.ts.map

package/types/src/io/ArrayBackingStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayBackingStore.d.ts","sourceRoot":"","sources":["../../../../src/io/ArrayBackingStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,iBAAkB,YAAW,WAAW,CAAC,aAAa;IACjE,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,UAAU,CAAuB;IAEzC;;OAEG;IACH,IAAI,MAAM,IAAI,eAAe,GAAG,IAAI,CAEnC;IAED,kDAAkD;IAC5C,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC;IAO3E,iDAAiD;IAC3C,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,WAAW,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;CAOxE"}