@gridsheet/preact-core 2.2.0 → 3.0.0-rc.0

package/dist/components/RowMenu.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+export declare const RowMenu: FC;
+//# sourceMappingURL=RowMenu.d.ts.map

package/dist/constants.d.ts

@@ -15,6 +15,15 @@ export declare class Special {
     name: string;
     constructor(name: string);
 }
+/**
+ * Sentinel value representing an in-flight async formula computation.
+ * Cells whose solved cache contains a Pending will render a loading indicator.
+ * Dependent cells that encounter a Pending value also become pending.
+ */
+export declare class Pending {
+    promise: Promise<any>;
+    constructor(promise: Promise<any>);
+}
 export declare const SECONDS_IN_DAY = 86400;
 export declare const FULLDATE_FORMAT_UTC = "YYYY-MM-DDTHH:mm:ss.SSSZ";
 export declare const RESET_ZONE: ZoneType;

package/dist/formula/evaluator.d.ts

@@ -22,7 +22,9 @@ export declare class FormulaError {
     code: string;
     message: string;
     error?: Error;
+    __isFormulaError: boolean;
     constructor(code: string, message: string, error?: Error);
+    static is(obj: any): boolean;
 }
 declare class Entity<T = any> {
     value: T;

package/dist/formula/functions/__async.d.ts

@@ -0,0 +1,59 @@
+import { Pending, Special } from '../../constants';
+import { Wire } from '../../lib/hub';
+import { PointType } from '../../types';
+/**
+ * Sentinel value to distinguish cache miss from user-returned undefined/null.
+ * Since user functions can return undefined or null, we need a special marker
+ * to indicate "no cache entry found" vs "cache entry is undefined".
+ */
+export declare const asyncCacheMiss: Special;
+/** Returns true if any element of `args` is a Pending sentinel. */
+export declare const hasPendingArg: (args: any[]) => boolean;
+/**
+ * Build a cache key from function name + hashed serialised arguments.
+ *
+ * Format: `funcName:length:hash1-hash2-...`
+ *   - length: byte length of the JSON-serialised args
+ *   - hash:   cyrb53 hash of the JSON string, repeated hashPrecision times with different seeds
+ *
+ * When a Table appears as an argument its trimmed area is converted to a
+ * value matrix (`any[][]`) via `getFieldMatrix()` so the key reflects the
+ * actual cell values the function will operate on.
+ */
+export declare const buildAsyncCacheKey: (funcName: string, bareArgs: any[], hashPrecision?: number) => string;
+/**
+ * Try to retrieve a cached or pending async result for the given cache key.
+ *
+ * Returns:
+ * - Cached value if present, valid, and not expired
+ * - Pending if there is an in-flight promise for this cell
+ * - asyncCacheMiss if no cache/pending exists (distinguishes from user-returned undefined/null)
+ */
+export declare const getAsyncCache: (table: {
+    wire: Wire;
+    getId: (p: PointType) => string;
+}, origin: PointType, key: string) => any;
+/**
+ * Handle an async (Promise) result returned by BaseFunction.main().
+ *
+ * Cache is stored per-cell in cell.asyncCache.
+ * In-flight tracking uses Wire.asyncPending (keyed by cell ID).
+ *
+ * Flow:
+ * 1. If cell has asyncCache and the key matches (inputs unchanged) and not expired → return cached value
+ * 2. If there is already an in-flight promise for this cell → return its Pending
+ * 3. Otherwise start the async work, return a new Pending, and on completion
+ *    write the result into cell.asyncCache and trigger a re-render.
+ *
+ * @param ttlMilliseconds - Cache time-to-live in **milliseconds**. undefined = never expires.
+ */
+export declare const getOrSaveAsyncCache: (promise: Promise<any>, table: {
+    wire: Wire;
+    getId: (p: PointType) => string;
+}, origin: PointType, key: string, ttlMilliseconds?: number) => any;
+/**
+ * Create a Pending sentinel that resolves immediately.
+ * Used when an argument is already pending — the result is propagated.
+ */
+export declare const createPropagatedPending: () => Pending;
+//# sourceMappingURL=__async.d.ts.map

package/dist/formula/functions/__base.d.ts

@@ -13,11 +13,16 @@ export declare class BaseFunction {
         name: string;
         description: string;
     }[];
+    /** Cache TTL in milliseconds. Override in subclass to set expiry. undefined = never expires. */
+    protected ttlMilliseconds?: number;
+    /** Hash precision for cache key generation. Higher values reduce collision risk. Default: 1 */
+    protected hashPrecision: number;
     protected bareArgs: any[];
     protected table: Table;
     protected origin?: PointType;
     constructor({ args, table, origin }: FunctionProps);
     protected validate(): void;
+    private get isMainAsync();
     call(): any;
 }
 export type FunctionMapping = {

package/dist/index.d.ts

@@ -3,12 +3,12 @@ export { Renderer } from './renderers/core';
 export type { RendererMixinType, RendererCallProps, RenderProps } from './renderers/core';
 export { Parser } from './parsers/core';
 export type { ParserMixinType } from './parsers/core';
-export { oa2aa, aa2oa, buildInitialCells, buildInitialCellsFromOrigin, zoneToArea, areaToZone, areaToRange, } from './lib/structs';
+export { oa2aa, aa2oa, buildInitialCells, buildInitialCellsFromOrigin, zoneToArea, areaToZone, areaToRange, addressesToAreas, addressesToCols, addressesToRows, } from './lib/spatial';
 export { TimeDelta } from './lib/time';
-export { x2c, c2x, y2r, r2y, p2a, a2p } from './lib/converters';
+export { x2c, c2x, y2r, r2y, p2a, a2p } from './lib/coords';
 export { updateTable } from './store/actions';
 export { PluginBase, useInitialPluginContext, usePluginContext } from './components/PluginBase';
-export type { MatrixType, CellType, FilterCondition, FilterConditionMethod, FilterConfig, FeedbackType, OptionsType, WriterType, CellsByAddressType, CellsByIdType, ModeType, HeadersType, HistoryType, HistorySortRowsType, StoreType, PointType, AreaType, ZoneType, Props, Connector, EditorEvent, CursorStateType, } from './types';
+export type { MatrixType, CellType, Address, AsyncCache, FilterCondition, FilterConditionMethod, FilterConfig, FeedbackType, OptionsType, WriterType, CellsByAddressType, CellsByIdType, ModeType, HeadersType, HistoryType, HistorySortRowsType, StoreType, PointType, AreaType, ZoneType, Props, Connector, EditorEvent, CursorStateType, } from './types';
 export type { HubType, HubProps, WireProps, TransmitProps } from './lib/hub';
 export { Wire, useHub, createHub } from './lib/hub';
 export type { Dispatcher } from './store';
@@ -20,13 +20,14 @@ export { Table, type UserTable } from './lib/table';
 export { Policy } from './policy/core';
 export type { PolicyType, PolicyOption, PolicyMixinType } from './policy/core';
 export * as operations from './lib/operation';
-export { DEFAULT_HISTORY_LIMIT } from './constants';
+export { DEFAULT_HISTORY_LIMIT, Pending } from './constants';
 export { userActions } from './store/actions';
 export { clip } from './lib/clipboard';
 export { makeBorder } from './styles/utils';
 export { syncers } from './store/dispatchers';
 export { ensureString, ensureNumber, ensureBoolean } from './formula/functions/__utils';
 export type { EnsureNumberOptions, EnsureBooleanOptions } from './formula/functions/__utils';
+export { solveTable } from './formula/solver';
 //# sourceMappingURL=index.d.ts.map
 export { h, render } from "preact";
 export {