@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/types/src/transaction/TransactionUndoManager.d.ts

@@ -1,4 +1,4 @@
-import { UndoManager } from '@sheetxl/utils';
+import { UndoManager, UndoEntry } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 /**
  * An {@link UndoManager} that is a *view over the transaction store's commit log*, not a mirror
@@ -42,6 +42,9 @@ export declare class TransactionUndoManager extends UndoManager {
     getTopRedoDescription(): string | null;
     getUndoDescriptions(): readonly string[];
     getRedoDescriptions(): readonly string[];
+    /** Each undo point's commit: its author and the meta recorded with it (the command that made it). */
+    getUndoEntries(): readonly UndoEntry[];
+    getRedoEntries(): readonly UndoEntry[];
     /**
      * The commit log is the stack; arbitrary operations cannot be added.
      * Perform work through a described transaction instead.

package/types/src/transaction/_BatchHandle.d.ts

@@ -0,0 +1,118 @@
+import { ITransaction } from './ITransaction';
+/**
+ * The handle a batch hands its callback: the same SDK objects, reached through it, bound to the
+ * batch.
+ *
+ * @remarks
+ * A batch that awaits stays open while other code runs on the event loop: a React render, a hook
+ * subscribing. The store cannot tell the batch's next line from that code, so "is a transaction
+ * open" does not say whether a caller is part of the batch. Holding the batch does. Whatever is
+ * reached through the handle is wrapped by the same rule, so a script that only ever sees the
+ * handle never touches a plain object, and code that never sees it (the UI) is outside the batch
+ * however long it stays open.
+ *
+ * A call made through the handle runs with the handle current ({@link getCurrentBatchHandle}) for
+ * its synchronous extent. That is the only scope there is: nothing is inferred across an `await`,
+ * which is what makes it safe in the browser.
+ *
+ * Objects go back into the SDK unwrapped, so the SDK only ever sees its own objects. A wrapped
+ * object is a different identity from the plain one, but the same object is always wrapped the
+ * same way, so identities compare consistently on either side.
+ *
+ * @internal
+ */
+export declare class BatchHandle {
+    protected _store: ITransaction.IStore;
+    protected _closed: boolean;
+    protected _commitId: string | null;
+    protected _stepListeners: Set<BatchHandle.StepListener> | null;
+    protected _toWrapped: WeakMap<object, any>;
+    /** @param store The store the batch is open on. */
+    constructor(store: ITransaction.IStore);
+    /** The store the batch is open on. */
+    getStore(): ITransaction.IStore;
+    /**
+     * The id of the root commit the batch writes into, or `null` before its callback has started.
+     * A batch nested in another operation shares that operation's commit.
+     */
+    getCommitId(): string | null;
+    /** Whether the batch this handle is bound to has closed. */
+    isClosed(): boolean;
+    /**
+     * The batch has closed. What was reached through the handle keeps working, as the plain object
+     * does: it is no longer part of a batch.
+     */
+    close(): void;
+    /**
+     * Hear each step of the batch as it is made: a transaction begun directly inside the batch has
+     * committed. Dropped when the batch closes.
+     */
+    addStepListener(listener: BatchHandle.StepListener): () => void;
+    protected _onStep(commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>): void;
+    /** `value` as seen through this handle. */
+    wrap<T>(value: T): T;
+    /** `value` as the SDK sees it: what this handle wrapped, unwrapped. */
+    unwrap<T>(value: T): T;
+    protected _wrapModel<T extends object>(raw: T): T;
+    protected _wrapMethod(target: object, method: (...args: any[]) => any): (...args: any[]) => any;
+    protected _methods: WeakMap<object, Map<(...args: any[]) => any, (...args: any[]) => any>>;
+    protected _unwrapArg(arg: any): any;
+    protected _unwrapCallbacks(plain: Record<string, any>): Record<string, any>;
+    protected _callbacks: WeakMap<object, Record<string, any>>;
+    /**
+     * `outward`: a function handed out by the SDK (its arguments go in unwrapped, its result comes
+     * out wrapped). Otherwise one handed in (the SDK calls it: arguments wrapped, result unwrapped).
+     */
+    protected _wrapFunction(fn: (...args: any[]) => any, outward: boolean): (...args: any[]) => any;
+    protected _outward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _inward: WeakMap<(...args: any[]) => any, (...args: any[]) => any>;
+    protected _wrapArray(array: any[]): any[];
+    protected _wrapIterator(iterator: Iterator<any>): Iterator<any>;
+    protected _inScope<R>(callback: () => R): R;
+    /**
+     * A batch's callback, handed `self` bound to a new handle on `store`.
+     *
+     * @remarks
+     * What the callback answers is handed back plain: the handle is over once the batch is. `close`
+     * belongs in the batch's close callback, and `onChildCommit` in the options it is begun with.
+     */
+    static bind<T extends object, R>(store: ITransaction.IStore, self: T, callback: (commit: ITransaction.ICommit, bound: T) => R | Promise<R>): {
+        callback: (commit: ITransaction.ICommit) => R | Promise<R>;
+        close: () => void;
+        onChildCommit: NonNullable<ITransaction.Hooks['onChildCommit']>;
+    };
+    /**
+     * Whether a batch open on `store` is told of each of its steps. While one is, a write is to be
+     * made as it comes, never held for later: a step made later is heard later.
+     */
+    static isStepping(store: ITransaction.IStore): boolean;
+    /** The handle `value` was reached through, or `null` for a plain object. */
+    static of(value: unknown): BatchHandle | null;
+}
+/**
+ * The open batch handle the running code was called through, or `null`.
+ *
+ * @remarks
+ * Set only for the synchronous extent of a call made through a handle that is still open. Code
+ * reached any other way - the UI, a timer, a hook - sees `null` whatever batch is open.
+ *
+ * @internal
+ */
+export declare const getCurrentBatchHandle: () => BatchHandle | null;
+/**
+ * Whether a listener registered now, on `store`, with no `transactional` of its own, takes part in
+ * the operation: it is registered through an open batch's handle, on that batch's store.
+ *
+ * @internal
+ */
+export declare const isRegisteringInBatch: (store: ITransaction.IStore) => boolean;
+export declare namespace BatchHandle {
+    /**
+     * Told as a step of the batch is made.
+     *
+     * @param commit The root commit the batch writes into.
+     * @param intents What the step recorded ({@link ITransaction.Hooks.onChildCommit}).
+     */
+    type StepListener = (commit: ITransaction.ICommit, intents: Readonly<Record<string, any>>) => void;
+}
+//# sourceMappingURL=_BatchHandle.d.ts.map

package/types/src/type/AbstractCollection.d.ts

@@ -0,0 +1,92 @@
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { ICollection } from './ICollection';
+export declare abstract class AbstractCollection<T, O extends ICollection.GetItemsOptions = ICollection.GetItemsOptions> implements ICollection<T> {
+    /** Answered by the proxy the constructor returns; see {@link ICollection}. */
+    readonly [index: number]: T;
+    /**
+     * The store transactional listeners are versioned in; `undefined` gives the emitter a transient
+     * store of its own.
+     */
+    protected _transactions: ITransaction.IStore | undefined;
+    /** Created on first use — most collections are never listened to. */
+    private _collectionEmitter;
+    private _closed;
+    constructor(transactions?: ITransaction.IStore);
+    /** {@inheritDoc ICollection.length} */
+    get length(): number;
+    /** {@inheritDoc ICollection.isClosed} */
+    isClosed(): boolean;
+    /**
+     * Closes the collection: flips {@link isClosed} and announces
+     * {@link ICollection.Events.onClose} once.
+     *
+     * @remarks
+     * The base owns the fire so that the event can never be declared and not delivered. A
+     * subclass that is closable calls this from its public `close()` and does its own cleanup
+     * after; a second call is a no-op. The flag flips before the announcement, so a listener asking
+     * `isClosed()` while being told is told the truth.
+     */
+    protected _close(): void;
+    /**
+     * Returns the items, optionally filtered.
+     *
+     * @param options The subclass's own options; `undefined` is every item, in the collection's
+     * order.
+     *
+     * @remarks
+     * Return an array the caller may keep — a fresh one, or one the collection never mutates
+     * after handing it out — never the collection's own mutable storage. Every read on the base is
+     * over what this returns, and {@link toArray} returns it as-is.
+     */
+    protected abstract _getItems(options?: O): T[];
+    /** {@inheritDoc ICollection."[iterator]"} */
+    [Symbol.iterator](): IterableIterator<T>;
+    /** {@inheritDoc ICollection.getItems} */
+    getItems(options?: O): T[];
+    /** {@inheritDoc ICollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ICollection.at} */
+    at(index: number): T | undefined;
+    /** {@inheritDoc ICollection.indexOf} */
+    indexOf(item: T): number;
+    /** {@inheritDoc ICollection.find} */
+    find<S extends T>(predicate: (value: T, index: number, items: readonly T[]) => value is S): S | undefined;
+    find(predicate: (value: T, index: number, items: readonly T[]) => boolean): T | undefined;
+    /** {@inheritDoc ICollection.findIndex} */
+    findIndex(predicate: (value: T, index: number, items: readonly T[]) => boolean): number;
+    /** {@inheritDoc ICollection.filter} */
+    filter<S extends T>(predicate: (value: T, index: number, items: readonly T[]) => value is S): S[];
+    filter(predicate: (value: T, index: number, items: readonly T[]) => boolean): T[];
+    /** {@inheritDoc ICollection.map} */
+    map<U>(fn: (value: T, index: number, items: readonly T[]) => U): U[];
+    /** {@inheritDoc ICollection.forEach} */
+    forEach(fn: (value: T, index: number, items: readonly T[]) => void): void;
+    /** {@inheritDoc ICollection.some} */
+    some(predicate: (value: T, index: number, items: readonly T[]) => boolean): boolean;
+    /** {@inheritDoc ICollection.every} */
+    every(predicate: (value: T, index: number, items: readonly T[]) => boolean): boolean;
+    /** {@inheritDoc ICollection.toArray} */
+    toArray(): T[];
+    /** {@inheritDoc ICollection.addListeners} */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    protected _getCollectionEmitter(): ListenerEmitter<this, ICollection.Events>;
+    /**
+     * Announces {@link ICollection.Events.onCollectionChange}.
+     *
+     * @remarks
+     * Nothing is created for a collection nobody has listened to.
+     */
+    protected _notifyCollectionChange(): void;
+    /**
+     * Announces {@link ICollection.Events.onInvalidated}.
+     *
+     * @remarks
+     * Nothing is created for a collection nobody has listened to.
+     */
+    protected _notifyInvalidated(): void;
+    /** {@inheritDoc ICollection.isICollection} */
+    get isICollection(): true;
+}
+//# sourceMappingURL=AbstractCollection.d.ts.map

package/types/src/type/ICollection.d.ts

@@ -2,13 +2,36 @@ import { JSONSerializableAsync } from '@sheetxl/utils';
 import { IListener } from '../listener';
 /**
  * Interface used for all ICollections.
+ *
+ * @remarks
+ * A collection reads like a `ReadonlyArray`: it indexes (`[i]`), counts (`length`), iterates, and
+ * offers the familiar helpers (`at`, `find`, `filter`, `map`, ...). It is not an array —
+ * `Array.isArray` is `false` and it cannot be written through `[i]` — so call {@link toArray} when
+ * an array is really wanted.
+ *
+ * Iteration order is the collection's own order — insertion order for the ordered collections
+ * (sheets, tables, movables) and unspecified for the keyed ones (resources, functions). Every
+ * read is over a snapshot: neither {@link getItems} nor the helpers observe a change made while
+ * they run.
  */
 export interface ICollection<T> {
+    /**
+     * The item at the given index, or `undefined` if there is none — `wb.getWorksheets()[0]`.
+     *
+     * @remarks
+     * Read-only and live: each read is against the collection as it is now. Assigning through an
+     * index throws.
+     */
+    readonly [index: number]: T;
+    /**
+     * The number of items — the same as {@link getCount}.
+     */
+    readonly length: number;
     /**
      * Iterates the collection's items.
      *
      * @remarks
-     * The unfiltered walk — `for (const sheet of wb.getSheets())`. Every other iterable surface in
+     * The unfiltered walk — `for (const sheet of wb.getWorksheets())`. Every other iterable surface in
      * the SDK (`ICellRange`, `ICellRegions`, `ICellRanges`) reads this way, so a collection that did
      * not was a trap: `for…of` over one is the obvious line to write and it threw at runtime with
      * nothing in the types to warn first.
@@ -19,6 +42,11 @@ export interface ICollection<T> {
     [Symbol.iterator](): IterableIterator<T>;
     /**
      * Returns the items in the collection.
+     *
+     * @remarks
+     * The optioned call — filtering, ordering, anything parameterized — and a snapshot: the array
+     * returned does not follow later changes to the collection. For the unfiltered items as a plain
+     * array prefer {@link toArray}.
      */
     getItems(options?: ICollection.GetItemsOptions): T[];
     /**
@@ -28,6 +56,100 @@ export interface ICollection<T> {
      * returns the total number of items available.
      */
     getCount(): number;
+    /**
+     * Returns the item at the given index, or `undefined` if there is none.
+     *
+     * @param index The position in iteration order. A negative index counts back from the end, as
+     * `Array.prototype.at` does.
+     */
+    at(index: number): T | undefined;
+    /**
+     * Returns the index of the item in iteration order, or `-1` if it is not in the collection.
+     *
+     * @param item The item to find.
+     */
+    indexOf(item: T): number;
+    /**
+     * Returns the first item the predicate accepts, or `undefined` if it accepts none.
+     *
+     * @param predicate Called once per item in iteration order until it returns `true`.
+     */
+    find<S extends T>(predicate: (value: T, index: number, items: readonly T[]) => value is S): S | undefined;
+    /**
+     * Returns the first item the predicate accepts, or `undefined` if it accepts none.
+     *
+     * @param predicate Called once per item in iteration order until it returns `true`.
+     */
+    find(predicate: (value: T, index: number, items: readonly T[]) => boolean): T | undefined;
+    /**
+     * Returns the index of the first item the predicate accepts, or `-1` if it accepts none.
+     *
+     * @param predicate Called once per item in iteration order until it returns `true`.
+     */
+    findIndex(predicate: (value: T, index: number, items: readonly T[]) => boolean): number;
+    /**
+     * Returns the items the predicate accepts, in iteration order.
+     *
+     * @param predicate Called once per item.
+     */
+    filter<S extends T>(predicate: (value: T, index: number, items: readonly T[]) => value is S): S[];
+    /**
+     * Returns the items the predicate accepts, in iteration order.
+     *
+     * @param predicate Called once per item.
+     */
+    filter(predicate: (value: T, index: number, items: readonly T[]) => boolean): T[];
+    /**
+     * Returns the result of calling the function on every item, in iteration order.
+     *
+     * @param fn Called once per item.
+     */
+    map<U>(fn: (value: T, index: number, items: readonly T[]) => U): U[];
+    /**
+     * Calls the function once per item, in iteration order.
+     *
+     * @param fn Called once per item.
+     */
+    forEach(fn: (value: T, index: number, items: readonly T[]) => void): void;
+    /**
+     * Returns `true` if the predicate accepts at least one item.
+     *
+     * @param predicate Called once per item in iteration order until it returns `true`.
+     */
+    some(predicate: (value: T, index: number, items: readonly T[]) => boolean): boolean;
+    /**
+     * Returns `true` if the predicate accepts every item, including when there are none.
+     *
+     * @param predicate Called once per item in iteration order until it returns `false`.
+     */
+    every(predicate: (value: T, index: number, items: readonly T[]) => boolean): boolean;
+    /**
+     * Returns the items as a fresh array, in iteration order.
+     *
+     * @remarks
+     * The call to make when an array is really wanted. The array is the caller's: changing it does
+     * not change the collection, and it does not follow later changes to the collection.
+     */
+    toArray(): T[];
+    /**
+     * Returns `true` once the collection has been closed.
+     *
+     * @remarks
+     * A closed collection is empty and announces nothing further. Collections that are closed by
+     * their owner (the workbook's names, functions and modules, when the workbook closes) announce
+     * it once with {@link ICollection.Events.onClose}; the others are never closed and always
+     * return `false`.
+     */
+    isClosed(): boolean;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: ICollection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isICollection: true;
 }
 /**
  * {@inheritDoc ICollection}
@@ -103,6 +225,14 @@ export declare namespace ICollection {
          * Called when the collection has been updated due to a undo/redo and a rerender is required.
          */
         onInvalidated?(source: ICollection<any>): void;
+        /**
+         * Called once, when the collection is closed.
+         *
+         * @remarks
+         * {@link ICollection.isClosed} is already `true` when this is delivered, and nothing is
+         * announced after it. Only the collections an owner closes ever fire it.
+         */
+        onClose?(source: ICollection<any>): void;
     }
     interface IListeners extends IListener.Callbacks<ICollection<any>, ICollection.Events> {
     }

package/types/src/type/IProperties.d.ts

@@ -11,7 +11,7 @@ export declare namespace IProperties {
      * @typeParam P - The type representing the properties associated with the range.
      * @typeParam U - The type accepted by updates. This need not be `P` widened - a property bag may
      * accept convenience keys that are folded onto canonical ones and never appear in `P` (see
-     * `IStyledFont.Modifiers`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
+     * `IFontStyle.Update`). Defaults to {@link IProperties.ResolvableProperties} of `P`.
      * @typeParam J - The type representing the JSON-serializable representation of the range.
      */
     interface ICellRanged<P, U = IProperties.ResolvableProperties<P>> {

package/types/src/type/ITypes.d.ts

@@ -30,16 +30,18 @@ export declare namespace ITypes {
      *
      * * `dynamic` - the extent is *derived from* the result. It spills, and it resizes when the
      *   result shape changes.
-     * * `dynamicSpillError` - a `dynamic` formula whose spill is currently blocked. The recorded
+     * * `error` - a `dynamic` formula whose spill is currently blocked (`#SPILL!`). The recorded
      *   extent collapses to the anchor cell.
-     * * `static` - legacy array-entered (Ctrl+Shift+Enter). The extent is *authoritative* and the
-     *   result is fitted to it; it never spills and never resizes.
+     * * `fixed` - array-entered (Ctrl+Shift+Enter). The extent is *authoritative* and the result is
+     *   fitted to it (a dimension of 1 broadcasts, a longer one is clipped, a shorter one is padded
+     *   with `#N/A`); it never spills and never resizes. Written through
+     *   {@link ICellRange.SetValuesOptions.arrayFixed}.
      *
-     * `static + spillError` is not a state: a stored fixed block owns its cells, so a spill
-     * collision is rejected at entry rather than detected at calc. That is what lets these three be
-     * one enum rather than two booleans.
+     * `fixed + error` is not a state: a fixed block owns its cells, so a write into part of it is
+     * refused at the write site rather than detected at calc. That is what lets these three be one
+     * enum rather than two booleans.
      */
-    type FormulaArrayKind = 'dynamic' | 'dynamicSpillError' | 'static';
+    type FormulaArrayKind = 'dynamic' | 'fixed' | 'error';
     /**
      * Options for controlling selection behavior, including scrolling and focus.
      */

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

@@ -1,5 +1,6 @@
 export * from './ITypes';
 export * from './IProperties';
 export * from './ICollection';
+export * from './AbstractCollection';
 export * from './Registry';
 //# sourceMappingURL=index.d.ts.map

package/types/src/utils/_CSSUtils.d.ts

@@ -4,7 +4,7 @@ import { IColor } from '../color';
 import { IFill } from '../fill';
 import { IFont } from '../font';
 import { ITextFrame } from '../text';
-import { IBorder } from '../border';
+import { IBorders } from '../border';
 export interface ParsedFont {
     family: string | null;
     size?: string | null;
@@ -18,7 +18,7 @@ export declare function toHex(color: IColor, darkMode?: boolean): string;
 /** Baked modes keep the historical hex output; `'adaptive'` defers to `IColor.toCSS` (`light-dark()`). */
 export declare function toCSSColor(color: IColor, mode?: IColor.CSSMode): string;
 export declare function toCSSFontSize(size: number | null | undefined): string | null;
-export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strike: boolean): CSSTextDecoration;
+export declare function toCSSTextDecoration(underline: IFont.UnderlineStyle | boolean, strikeStyle: IFont.StrikeStyle | boolean): CSSTextDecoration;
 export declare function toCSSTextUnderlineStyle(underline: IFont.UnderlineStyle): string;
 export declare const noDecoration: Readonly<{
     underline: "none";
@@ -118,8 +118,8 @@ export declare function parsePattern(value: string): Partial<IFill.PatternProper
  */
 export declare const toCSSGradient: (gradientFill: IFill.IGradient, mode?: IColor.CSSMode, size?: Size | null) => string | null;
 export declare function toCSSPattern(patternType: IFill.BuiltInSheetPattern): string;
-export declare function toCSSBorderStroke(stroke: IBorder.IStroke): string | null;
-export declare function parseBorderStroke(value: string, parseColor?: (str: string) => string): IBorder.StrokeProperties | null;
+export declare function toCSSBorderStroke(stroke: IBorders.IStroke): string | null;
+export declare function parseBorderStroke(value: string, parseColor?: (str: string) => string): IBorders.StrokeProperties | null;
 /**
  * @see
  * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/text-align}

package/types/src/wasm/_fontsWasm.d.ts

@@ -0,0 +1,7 @@
+import { WasmBindgenExports } from '@sheetxl/utils';
+import * as glue from '../.generated/wasm/fonts.js';
+/** The binding's exports, once instantiated. */
+export type FontsWasmExports = WasmBindgenExports<typeof glue>;
+/** The binding's exports, instantiated and ready to call. */
+export declare const wasm: FontsWasmExports;
+//# sourceMappingURL=_fontsWasm.d.ts.map

package/types/src/wasm/_sdkWasm.d.ts

@@ -0,0 +1,7 @@
+import { WasmBindgenExports } from '@sheetxl/utils';
+import * as glue from '../.generated/wasm/sdk.js';
+/** The binding's exports, once instantiated. */
+export type SdkWasmExports = WasmBindgenExports<typeof glue>;
+/** The binding's exports, instantiated and ready to call. */
+export declare const wasm: SdkWasmExports;
+//# sourceMappingURL=_sdkWasm.d.ts.map

package/types/src/wasm/fontsWasm.d.ts

@@ -0,0 +1,32 @@
+import { FontsWasmExports } from './_fontsWasm';
+export type { FontsWasmExports } from './_fontsWasm';
+/**
+ * Reads font files: the Rust that opens a font's bytes and writes its measures tables, compiled to
+ * WebAssembly.
+ *
+ * @remarks
+ * Lazy on every platform, Node included, and never prefetched: only adding a font needs it
+ * (`sheetxl fonts add`, a font a user gives the browser), and its binary is ten times the sdk's
+ * own. Internal to the sdk.
+ *
+ * @example
+ * ```ts
+ * const { FontFile } = await FontsWasm.load();
+ * const file = new FontFile(bytes);
+ * const tables = file.capture(0, file.identity(0).family, 6, 120);
+ * file.free();
+ * ```
+ */
+export declare const FontsWasm: {
+    /**
+     * Loads and instantiates the WebAssembly, or returns it if it is already loaded.
+     *
+     * @remarks
+     * Concurrent calls share one attempt; a failed attempt is retried by the next call. Rejects with
+     * a `LazyLoadError`.
+     */
+    load: () => Promise<FontsWasmExports>;
+    /** The exports if the WebAssembly has loaded, otherwise `undefined`. */
+    peek: () => FontsWasmExports | undefined;
+};
+//# sourceMappingURL=fontsWasm.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './sdkWasm';
+export * from './fontsWasm';
+//# sourceMappingURL=index.d.ts.map

package/types/src/wasm/loader.browser.d.ts

@@ -0,0 +1,9 @@
+import { SdkWasmExports } from './_sdkWasm';
+/**
+ * Loads and instantiates the WebAssembly, or returns it if it is already loaded. Concurrent calls
+ * share one attempt; a failed attempt is retried by the next call. Rejects with a `LazyLoadError`.
+ */
+export declare const load: () => Promise<SdkWasmExports>;
+/** The exports if the WebAssembly has loaded, otherwise `undefined`. */
+export declare const peek: () => SdkWasmExports | undefined;
+//# sourceMappingURL=loader.browser.d.ts.map

package/types/src/wasm/loader.node.d.ts

@@ -0,0 +1,9 @@
+import { WasmBindgenExports } from '@sheetxl/utils';
+import * as glue from '../.generated/wasm/sdk.js';
+type SdkWasmExports = WasmBindgenExports<typeof glue>;
+/** The exports, ready: resolved at once. */
+export declare const load: () => Promise<SdkWasmExports>;
+/** The exports, always loaded here. */
+export declare const peek: () => SdkWasmExports | undefined;
+export {};
+//# sourceMappingURL=loader.node.d.ts.map

package/types/src/wasm/sdkWasm.d.ts

@@ -0,0 +1,32 @@
+import { SdkWasmExports } from './_sdkWasm';
+export type { SdkWasmExports } from './_sdkWasm';
+/**
+ * `@sheetxl/sdk`'s Rust code, compiled to WebAssembly.
+ *
+ * @remarks
+ * How it arrives is the platform's: in a browser a lazy chunk that nothing downloads until
+ * {@link SdkWasm.load} is called; in Node an instantiation as the sdk loads, so {@link SdkWasm.peek}
+ * answers before any synchronous code runs (the `@sheetxl/sdk/wasm/loader` conditional export,
+ * `loader.node.ts` for `node` and `default`, `loader.browser.ts` for `browser`, read only here,
+ * like `license/runtime`). Internal to the sdk: the text engine calls it; nothing outside the
+ * package does, so it is not exported from the index.
+ *
+ * @example
+ * ```ts
+ * const wasm = await SdkWasm.load();
+ * wasm.line_pitch(12, 3); // 17
+ * ```
+ */
+export declare const SdkWasm: {
+    /**
+     * Loads and instantiates the WebAssembly, or returns it if it is already loaded.
+     *
+     * @remarks
+     * Concurrent calls share one attempt; a failed attempt is retried by the next call. Rejects with
+     * a `LazyLoadError`.
+     */
+    load: () => Promise<SdkWasmExports>;
+    /** The exports if the WebAssembly has loaded, otherwise `undefined`. */
+    peek: () => SdkWasmExports | undefined;
+};
+//# sourceMappingURL=sdkWasm.d.ts.map