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

package/dist/lib/cell.d.ts

@@ -1,3 +1,15 @@
-import { CellType } from '../types';
+import { AsyncCache, CellType, System } from '../types';
 export declare const filterCellFields: (cell: CellType, ignoreFields: (keyof CellType)[]) => CellType;
+/**
+ * Ensure that `cell._sys` exists, initialising it with sensible defaults
+ * when missing.  Any keys present in `defaults` that are absent on the
+ * existing `_sys` object are filled in.
+ * Returns the (possibly freshly-created) `System` object.
+ */
+export declare const ensureSys: (cell: CellType, defaults?: Partial<System>) => System;
+/**
+ * Write an `AsyncCache` entry into `cell.asyncCaches[key]`, creating the
+ * `asyncCaches` record if it does not yet exist.
+ */
+export declare const setAsyncCache: (cell: CellType, key: string, ac: AsyncCache) => void;
 //# sourceMappingURL=cell.d.ts.map

package/dist/lib/clipboard.d.ts

@@ -1,3 +1,18 @@
-import { StoreType, AreaType } from '../types';
+import { StoreType, AreaType, PointType } from '../types';
+import { UserTable } from './table';
 export declare const clip: (store: StoreType) => AreaType;
+export type TableCSVProps = {
+    getter?: (table: UserTable, point: PointType) => string;
+    filteredRowsIncluded?: boolean;
+    trailingEmptyRowsOmitted?: boolean;
+    separator?: string;
+    newline?: string;
+};
+export declare const table2csv: (table: UserTable, { getter, filteredRowsIncluded, trailingEmptyRowsOmitted, separator, newline, }?: TableCSVProps) => string;
+export type TableHTMLProps = {
+    getter?: (table: UserTable, point: PointType) => string;
+    filteredRowsIncluded?: boolean;
+    trailingEmptyRowsOmitted?: boolean;
+};
+export declare const table2html: (table: UserTable, { getter, filteredRowsIncluded, trailingEmptyRowsOmitted, }?: TableHTMLProps) => string;
 //# sourceMappingURL=clipboard.d.ts.map

package/dist/lib/coords.d.ts

@@ -5,6 +5,6 @@ export declare const y2r: (y: number) => string;
 export declare const r2y: (row: number | string, absolute?: boolean) => number;
 export declare const p2a: ({ y, x, absX, absY }: ExtraPointType) => string;
 export declare const a2p: (address: Address) => ExtraPointType;
-export declare const grantAddressAbsolute: (address: Address, absCol: boolean, absRow: boolean) => string | undefined;
+export declare const grantAddressAbsolute: (address: Address, absCol: boolean, absRow: boolean) => string;
 export declare const stripAddressAbsolute: (address: Address) => string;
 //# sourceMappingURL=coords.d.ts.map

package/dist/lib/dom.d.ts

@@ -0,0 +1,2 @@
+export declare const focus: (el: HTMLElement | null | undefined) => void;
+//# sourceMappingURL=dom.d.ts.map

package/dist/lib/hub.d.ts

@@ -1,22 +1,11 @@
-import { Pending } from '../constants';
-import { HistoryType, RefPaletteType, SheetIdsByName, ContextsBySheetId, ZoneType, CellsByIdType, Id, System, FeedbackType, EditorEvent, CursorStateType } from '../types';
-import { UserTable, Table } from './table';
+import { Pending } from '../sentinels';
+import { HistoryType, RefPaletteType, SheetIdsByName, ContextsBySheetId, ZoneType, CellsByIdType, Id, FeedbackType, EditorEvent, CursorStateType } from '../types';
+import { UserTable } from './table';
 import { FunctionMapping } from '../formula/functions/__base';
 import { PolicyType } from '../policy/core';
-import { RendererType } from '../renderers/core';
-import { ParserType } from '../parsers/core';
 export type WireProps = {
     historyLimit?: number;
     additionalFunctions?: FunctionMapping;
-    renderers?: {
-        [rendererName: string]: RendererType | null;
-    };
-    parsers?: {
-        [parserName: string]: ParserType | null;
-    };
-    labelers?: {
-        [labelerName: string]: ((n: number) => string) | null;
-    };
     policies?: {
         [policyName: string]: PolicyType | null;
     };
@@ -65,8 +54,17 @@ export declare class Wire {
     };
     lastFocused: HTMLTextAreaElement | null;
     solvedCaches: Map<Id, any>;
+    /** Maps each cell id to the set of cell ids whose formula depends on it. */
+    dependents: Map<Id, Set<Id>>;
+    /** IDs of non-origin cells that received spilled values (populated in spill(), cleared in clearSolvedCaches()). */
+    lastSpilledTargetIds: Set<Id>;
     /** Currently in-flight async formula Pending sentinels (keyed by cell ID). */
     asyncPending: Map<string, Pending>;
+    /** In-flight async formulas shared by cache key (for useInflight). */
+    asyncInflight?: Map<string, {
+        pending: Pending;
+        expireTime?: number;
+    }>;
     copyingSheetId: number;
     copyingZone: ZoneType;
     cutting: boolean;
@@ -77,15 +75,6 @@ export declare class Wire {
     currentHistory?: HistoryType;
     ready: boolean;
     functions: FunctionMapping;
-    renderers: {
-        [rendererName: string]: RendererType | null;
-    };
-    parsers: {
-        [parserName: string]: ParserType | null;
-    };
-    labelers: {
-        [labelerName: string]: ((n: number) => string) | null;
-    };
     policies: {
         [policyName: string]: PolicyType | null;
     };
@@ -119,8 +108,7 @@ export declare class Wire {
     }) => void;
     transmit: (newHub?: TransmitProps) => void;
     identifyFormula(): void;
-    getSystem(id: Id, table: Table): System;
-    constructor({ historyLimit, additionalFunctions, renderers, parsers, labelers, policies, onSave, onChange, onRemoveRows, onRemoveCols, onInsertRows, onInsertCols, onSelect, onKeyUp, onInit, }?: WireProps);
+    constructor({ historyLimit, additionalFunctions, policies, onSave, onChange, onRemoveRows, onRemoveCols, onInsertRows, onInsertCols, onSelect, onKeyUp, onInit, }?: WireProps);
 }
 export type TransmitProps = Partial<Wire>;
 export declare const createWire: (props?: WireProps) => Wire;

package/dist/lib/input.d.ts

@@ -11,5 +11,14 @@ export declare const isRefInsertable: (input: HTMLTextAreaElement | null) => boo
 export declare const expandInput: (input: HTMLTextAreaElement | null) => void;
 export declare const resetInput: (input: HTMLTextAreaElement | null, table: Table, point: PointType) => void;
 export declare const isFocus: (input: HTMLTextAreaElement | null) => boolean;
+/**
+ * Handles auto-close behavior for double quotes in formula editing.
+ * - Typing `"` inserts `""` and places cursor between them.
+ * - Typing `"` when cursor is right before an auto-closed `"` skips over it.
+ * - Backspace between empty `""` deletes both quotes.
+ *
+ * Returns true if the event was handled (caller should preventDefault), false otherwise.
+ */
+export declare const handleFormulaQuoteAutoClose: (e: React.KeyboardEvent<HTMLTextAreaElement>, inputting: string) => boolean;
 export {};
 //# sourceMappingURL=input.d.ts.map

package/dist/lib/operation.d.ts

@@ -11,13 +11,10 @@ export declare const Write: operations;
 export declare const Style: operations;
 export declare const Copy: operations;
 export declare const Resize: operations;
-export declare const SetRenderer: operations;
-export declare const SetParser: operations;
 export declare const SetPolicy: operations;
 export declare const Sort: operations;
 export declare const Filter: operations;
 export declare const SetLabel: operations;
-export declare const SetLabeler: operations;
 export declare const NoOperation: operations;
 export declare const Move: operations;
 export declare const Update: operations;

package/dist/lib/spatial.d.ts

@@ -88,5 +88,7 @@ export declare const addressesToCols: (addresses: Address[], asc?: boolean | nul
  * @param asc - true: ascending, false: descending, null: insertion order
  */
 export declare const addressesToRows: (addresses: Address[], asc?: boolean | null) => number[];
+export declare const isAreaNotSelected: (area: AreaType) => boolean;
+export declare const isZoneNotSelected: (zone: ZoneType) => boolean;
 export {};
 //# sourceMappingURL=spatial.d.ts.map

package/dist/lib/table.d.ts

@@ -1,8 +1,7 @@
-import { RendererCallProps } from '../renderers/core';
-import { Id, AreaType, CellsByIdType, CellsByAddressType, PointType, Address, CellFilter, MatrixType, CellType, FilterConfig, HistoryType, StorePatchType, ShapeType, OperatorType, OperationType, RawCellType, ExtraPointType, StoreType, RefEvaluation } from '../types';
+import { Id, AreaType, CellsByIdType, CellsByAddressType, PointType, Address, CellFilter, MatrixType, CellType, FilterConfig, HistoryType, StorePatchType, ShapeType, RectType, OperatorType, OperationType, RawCellType, ExtraPointType, StoreType, RefEvaluation } from '../types';
 import { FunctionMapping } from '../formula/functions/__base';
 import { Wire } from './hub';
-import { PolicyType } from '../policy/core';
+import { PolicyType, RenderProps } from '../policy/core';
 type Props = {
     minNumRows?: number;
     maxNumRows?: number;
@@ -16,6 +15,7 @@ type GetProps = {
     refEvaluation?: RefEvaluation;
     raise?: boolean;
     filter?: CellFilter;
+    asScalar?: boolean;
 };
 type MoveProps = {
     srcTable?: UserTable;
@@ -30,31 +30,28 @@ type CellField = keyof CellType;
 type GetCellProps = GetProps & {
     ignoreFields?: CellField[];
 };
-type GetFieldProps = GetProps & {
-    field?: keyof CellType;
-};
-type GetCellMatrixProps = GetCellProps & {
+type ToCellMatrixProps = GetCellProps & {
     area?: AreaType;
 };
-type GetFieldMatrixProps = GetFieldProps & {
+type ToValueMatrixProps = GetProps & {
     area?: AreaType;
 };
-type GetCellObjectProps = GetCellProps & {
+type ToCellObjectProps = GetCellProps & {
     addresses?: Address[];
 };
-type GetFieldObjectProps = GetFieldProps & {
+type ToValueObjectProps = GetProps & {
     addresses?: Address[];
 };
-type GetCellRowsProps = GetCellProps & {
+type ToCellRowsProps = GetCellProps & {
     rows?: number[];
 };
-type GetFieldRowsProps = GetFieldProps & {
+type ToValueRowsProps = GetProps & {
     rows?: number[];
 };
-type GetCellColsProps = GetCellProps & {
+type ToCellColsProps = GetCellProps & {
     cols?: (number | string)[];
 };
-type GetFieldColsProps = GetFieldProps & {
+type ToValueColsProps = GetProps & {
     cols?: (number | string)[];
 };
 export interface UserTable {
@@ -76,25 +73,26 @@ export interface UserTable {
      * This is not intended for public use and may change in future versions.
      */
     __raw__: Table;
-    getRectSize(area: AreaType): ShapeType;
+    getRectSize(area: AreaType): RectType;
     getCellByPoint(point: PointType, refEvaluation?: RefEvaluation, raise?: boolean): CellType | undefined;
     getCellByAddress(address: Address, refEvaluation?: RefEvaluation, raise?: boolean): CellType | undefined;
+    getPolicyByPoint(point: PointType): PolicyType;
     getNumRows(base?: number): number;
     getNumCols(base?: number): number;
-    getFieldMatrix(args?: GetFieldMatrixProps): any[][];
-    getFieldObject(args?: GetFieldObjectProps): {
+    toValueMatrix(args?: ToValueMatrixProps): any[][];
+    toValueObject(args?: ToValueObjectProps): {
         [address: Address]: any;
     };
-    getFieldRows(args?: GetFieldRowsProps): {
+    toValueRows(args?: ToValueRowsProps): {
         [address: Address]: any;
     }[];
-    getFieldCols(args?: GetFieldColsProps): {
+    toValueCols(args?: ToValueColsProps): {
         [address: Address]: any;
     }[];
-    getCellMatrix(args?: GetCellMatrixProps): (CellType | null)[][];
-    getCellObject(args?: GetCellObjectProps): CellsByAddressType;
-    getCellRows(args?: GetCellRowsProps): CellsByAddressType[];
-    getCellCols(args?: GetCellColsProps): CellsByAddressType[];
+    toCellMatrix(args?: ToCellMatrixProps): (CellType | null)[][];
+    toCellObject(args?: ToCellObjectProps): CellsByAddressType;
+    toCellRows(args?: ToCellRowsProps): CellsByAddressType[];
+    toCellCols(args?: ToCellColsProps): CellsByAddressType[];
     getHistories(): HistoryType[];
     move(args: MoveProps): UserTable;
     copy(args: MoveProps & {
@@ -176,8 +174,13 @@ export interface UserTable {
         cell?: CellType;
         refEvaluation?: RefEvaluation;
     }): string;
+    get shape(): {
+        rows: number;
+        cols: number;
+    };
 }
 export declare class Table implements UserTable {
+    __isTable: boolean;
     changedTime: number;
     lastChangedTime?: number;
     minNumRows: number;
@@ -199,6 +202,8 @@ export declare class Table implements UserTable {
     private addressCaches;
     private lastChangedAddresses;
     constructor({ minNumRows, maxNumRows, minNumCols, maxNumCols, sheetName, hub, }: Props);
+    static is(obj: any): obj is Table;
+    toString(): string;
     get headerHeight(): number;
     setHeaderHeight(height: number, historicize?: boolean): Table;
     get headerWidth(): number;
@@ -239,15 +244,6 @@ export declare class Table implements UserTable {
     private _sortRowMapping;
     get isInitialized(): boolean;
     get functions(): FunctionMapping;
-    get parsers(): {
-        [parserName: string]: import('../parsers/core').Parser | null;
-    };
-    get renderers(): {
-        [rendererName: string]: import('../renderers/core').Renderer | null;
-    };
-    get labelers(): {
-        [labelerName: string]: ((n: number) => string) | null;
-    };
     get policies(): {
         [policyName: string]: import('../policy/core').Policy | null;
     };
@@ -255,13 +251,12 @@ export declare class Table implements UserTable {
     getSheetId(): number;
     getTableBySheetName(sheetName: string): Table | null;
     getTableBySheetId(sheetId: number): Table | null;
+    private static _stack;
     initialize(cells: CellsByAddressType): void;
     incrementVersion(): void;
+    xsheetDispatch(otherTable: Table): void;
     private generateId;
-    getRectSize({ top, left, bottom, right }: AreaType): {
-        width: number;
-        height: number;
-    };
+    getRectSize({ top, left, bottom, right }: AreaType): RectType;
     setTotalSize(): void;
     refresh(relocate?: boolean, resize?: boolean): Table;
     clone(relocate?: boolean): Table;
@@ -287,21 +282,24 @@ export declare class Table implements UserTable {
     get bottom(): number;
     get right(): number;
     getFullRef(ref: Address): string;
-    getFieldMatrix({ area, field, refEvaluation, raise, filter, }?: GetFieldMatrixProps): any[][];
-    getFieldObject({ field, refEvaluation, raise, filter, addresses, }?: GetFieldObjectProps): {
+    _toValueMatrix({ area, at, refEvaluation, raise, filter, asScalar, }?: ToValueMatrixProps & {
+        at?: Id;
+    }): any[][];
+    toValueMatrix(props?: ToValueMatrixProps): any[][];
+    toValueObject({ refEvaluation, raise, filter, addresses, asScalar, }?: ToValueObjectProps): {
         [Address: string]: any;
     };
-    getFieldRows({ field, refEvaluation, raise, filter, rows, }?: GetFieldRowsProps): CellsByAddressType[];
-    getFieldCols({ field, refEvaluation, raise, filter, cols, }?: GetFieldColsProps): CellsByAddressType[];
-    getCellMatrix({ area, refEvaluation, raise, filter, ignoreFields, }?: GetCellMatrixProps): (CellType | null)[][];
-    getCellObject({ refEvaluation, raise, filter, addresses, ignoreFields, }?: GetCellObjectProps): CellsByAddressType;
-    getCellRows({ refEvaluation, raise, filter, rows, ignoreFields, }?: GetCellRowsProps): CellsByAddressType[];
-    getCellCols({ refEvaluation, raise, filter, cols, ignoreFields, }?: GetCellColsProps): CellsByAddressType[];
+    toValueRows({ refEvaluation, raise, filter, rows, asScalar, }?: ToValueRowsProps): CellsByAddressType[];
+    toValueCols({ refEvaluation, raise, filter, cols, asScalar, }?: ToValueColsProps): CellsByAddressType[];
+    toCellMatrix({ area, refEvaluation, raise, filter, ignoreFields, }?: ToCellMatrixProps): (CellType | null)[][];
+    toCellObject({ refEvaluation, raise, filter, addresses, ignoreFields, }?: ToCellObjectProps): CellsByAddressType;
+    toCellRows({ refEvaluation, raise, filter, rows, ignoreFields, }?: ToCellRowsProps): CellsByAddressType[];
+    toCellCols({ refEvaluation, raise, filter, cols, ignoreFields, }?: ToCellColsProps): CellsByAddressType[];
     private pushHistory;
     private cleanObsolete;
     private cleanStrayed;
-    private getNewIdMatrix;
-    private getIdMatrixFromArea;
+    /** Remove an id from wire.data and wire.dependents entirely. */
+    private deleteOrphanedId;
     private setChangedTime;
     private copyCellLayout;
     move({ srcTable, src, dst, historicize, operator, undoReflection, redoReflection, }: MoveProps): Table;
@@ -315,6 +313,7 @@ export declare class Table implements UserTable {
      *   is no longer addressable; on forward pass they are skipped; on reverse pass the ID is written back.
      */
     private _createMoveRelations;
+    get defaultPolicy(): PolicyType;
     /**
      * Apply (or reverse) a MoveRelations list.
      *
@@ -412,14 +411,25 @@ export declare class Table implements UserTable {
     getHistorySize(): number;
     getHistoryLimit(): number;
     getArea(): AreaType;
-    parse(point: PointType, value: string): CellType;
-    render(props: RendererCallProps): any;
+    parse(point: PointType, value: any): CellType;
+    render(props: RenderProps): any;
     stringify({ point, cell, refEvaluation, }: {
         point: PointType;
         cell?: CellType;
         refEvaluation?: RefEvaluation;
     }): string;
     trim(area: AreaType): Table;
+    /**
+     * Solve all formulas in this table and return a 2D matrix of resolved values.
+     */
+    solve({ raise, at }: {
+        raise?: boolean;
+        at: Id;
+    }): any[][];
+    /**
+     * Collapse this table to a scalar (top-left cell value).
+     */
+    strip(): any;
     private applyDiff;
     undo(): {
         history: null;
@@ -440,11 +450,24 @@ export declare class Table implements UserTable {
         newTable?: undefined;
     };
     getFunction(name: string): typeof import('../formula/functions/__base').BaseFunction;
-    getLabel(label: string | undefined, labelerKey: string | undefined, n: number): string | null;
+    getLabel(label: string | undefined, point: PointType, n: number): string | null;
     getBase(): this;
-    getSolvedCache(point: PointType): any;
-    setSolvedCache(point: PointType, value: any): void;
+    addDependents(id: Id, dependency: string): void;
+    getSolvedCache(point: PointType): [boolean, any];
+    setSolvingCache(point: PointType): void;
+    finishSolvedCache(point: PointType, value: any): void;
     clearSolvedCaches(): void;
+    /**
+     * Spill a 2D matrix of values starting from the origin cell.
+     * The origin cell receives matrix[0][0] and adjacent cells receive spill values in solvedCaches.
+     * For a 1×1 matrix, no spill occurs — the single value is cached directly.
+     * Throws FormulaError('#REF!') if the spill range is obstructed.
+     *
+     * @param origin  The anchor cell that produced the spill.
+     * @param matrix  The 2D array of resolved scalar values.
+     * @returns The top-left value (matrix[0][0]).
+     */
+    spill(origin: PointType, matrix: any[][]): any;
     sheetPrefix(omit?: boolean): string;
     rangeToArea(range: string): {
         top: number;
@@ -453,6 +476,9 @@ export declare class Table implements UserTable {
         right: number;
     };
     get __raw__(): Table;
+    get shape(): ShapeType;
+    get hasSingleCell(): boolean;
+    get currentVersion(): number;
 }
 export {};
 //# sourceMappingURL=table.d.ts.map

package/dist/lib/time.d.ts

@@ -1,25 +1,29 @@
-export declare const defaultTimeDeltaFormat = "HH:mm:ss";
-export declare const BASE_DATE: Date;
-type Diff = [number, number, number, number, number, number, number];
-export declare class TimeDelta {
-    gsType: string;
-    protected diff: Diff;
-    private date1;
-    private date2;
+export declare class Time {
+    readonly __gsType: "Time";
+    readonly days: number;
     format: string;
-    constructor(date1: Date, date2: Date, format?: string);
+    constructor(days: number, format?: string);
     add(date: Date): Date;
     sub(date: Date): Date;
     stringify(format?: string): string;
     toMilliseconds(): number;
-    toJSON(): string;
+    toDate(): Date;
+    toJSON(): {
+        __gsType: 'Time';
+        days: number;
+        format: string;
+    };
     toString(): string;
-    static create(hours?: number, minutes?: number, seconds?: number, milliseconds?: number): TimeDelta;
+    static create(hours?: number, minutes?: number, seconds?: number, milliseconds?: number): Time;
+    static fromDate(date: Date): Time;
+    static fromDates(date1: Date, date2: Date): Time;
+    static fromObject(obj: {
+        days: number;
+        format?: string;
+    }): Time;
     static is(obj: any): boolean;
-    static ensure(obj: any): TimeDelta;
-    static fromObject(obj: any): TimeDelta;
-    static parse(value: string, format?: string, strict?: boolean): TimeDelta | undefined;
+    static ensure(obj: any): Time;
+    static parse(value: string, format?: string, strict?: boolean): Time | undefined;
 }
 export declare const safeQueueMicrotask: typeof queueMicrotask;
-export {};
 //# sourceMappingURL=time.d.ts.map

package/dist/policy/checkbox.d.ts

@@ -0,0 +1,3 @@
+import { PolicyMixinType } from './core';
+export declare const CheckboxPolicyMixin: PolicyMixinType;
+//# sourceMappingURL=checkbox.d.ts.map

package/dist/policy/core.d.ts

@@ -1,47 +1,164 @@
-import { UserTable } from '../lib/table';
+import { FC, ReactNode } from 'react';
 import { CellPatchType, CellType, OperationType, PointType } from '../types';
-export type PolicyOption = {
+import { Table, UserTable } from '../lib/table';
+import { FormulaError } from '../formula/formula-error';
+import { Time } from '../lib/time';
+export type AutocompleteOption = {
     value: any;
     label?: any;
     keywords?: string[];
+    tooltip?: ReactNode | FC<{
+        value?: any;
+    }>;
 };
-export type RestrictProps = {
+export type SelectProps = {
     table: UserTable;
     point: PointType;
-    original?: CellType;
-    patch?: CellType;
+    current?: CellType;
+    next?: CellType;
     operation: OperationType;
 };
-export type OnClipProps = {
+export type SerializeForClipboardProps = {
     table: UserTable;
     point: PointType;
 };
-export type GetDefaultProps = {
+export type SelectFallbackProps = {
     table: UserTable;
     point: PointType;
     value: any;
 };
+export type Scalar = string | number | boolean | null | undefined;
+export type ScalarProps<T = any> = {
+    value?: T;
+    cell?: CellType<T>;
+    table: Table;
+    point: PointType;
+};
+export type RenderProps<T = any> = {
+    value?: T;
+    cell?: CellType<T>;
+    table: Table;
+    point: PointType;
+    sync?: (table: UserTable) => void;
+};
+export type SerializeProps<T = any> = {
+    value: T;
+    cell?: CellType<T>;
+    table: Table;
+    point: PointType;
+};
 export type PolicyMixinType = {
-    getDefault?: (props: GetDefaultProps) => CellType | undefined;
-    select?: (props: RestrictProps) => CellType | undefined;
-    validate?: (props: RestrictProps) => CellType | undefined;
-    onClip?: (props: OnClipProps) => string;
-    getOptions?: () => PolicyOption[];
+    datetimeFormat?: string;
+    dateFormat?: string;
+    timeFormat?: string;
+    decimalPrecision?: number;
+    render?: (props: RenderProps) => any;
+    renderCallback?: (rendered: any, props: RenderProps) => any;
+    renderString?: (props: RenderProps<string>) => any;
+    renderNumber?: (props: RenderProps<number>) => any;
+    renderBool?: (props: RenderProps<boolean>) => any;
+    renderDate?: (props: RenderProps<Date>) => any;
+    renderTime?: (props: RenderProps<Time>) => any;
+    renderArray?: (props: RenderProps<any[]>) => any;
+    renderObject?: (props: RenderProps<any>) => any;
+    renderNull?: (props: RenderProps<null | undefined>) => any;
+    renderTable?: (props: RenderProps<Table>) => any;
+    renderRowHeaderLabel?: (n: number) => string | null;
+    renderColHeaderLabel?: (n: number) => string | null;
+    serialize?: (props: SerializeProps) => string;
+    serializeString?: (props: SerializeProps<string>) => string;
+    serializeNumber?: (props: SerializeProps<number>) => string;
+    serializeBool?: (props: SerializeProps<boolean>) => string;
+    serializeDate?: (props: SerializeProps<Date>) => string;
+    serializeTime?: (props: SerializeProps<Time>) => string;
+    serializeArray?: (props: SerializeProps<any[]>) => string;
+    serializeNull?: (props: SerializeProps<null | undefined>) => string;
+    serializeFormulaError?: (props: SerializeProps<FormulaError>) => string;
+    serializeError?: (props: SerializeProps<Error>) => string;
+    deserialize?: (value: string, cell?: CellType) => CellType;
+    deserializeRaw?: (value: any, cell?: CellType) => CellType;
+    deserializeCallback?: (parsed: any, cell?: CellType) => CellType;
+    deserializeFirst?: (value: string, cell?: CellType) => CellPatchType<any>;
+    deserializeNumber?: (value: string, cell?: CellType) => CellPatchType<number | undefined>;
+    deserializeBool?: (value: string, cell?: CellType) => CellPatchType<boolean | undefined>;
+    deserializeDate?: (value: string, cell?: CellType) => CellPatchType<Date | undefined>;
+    deserializeTime?: (value: string, cell?: CellType) => CellPatchType<Time | undefined>;
+    deserializeAny?: (value: string, cell?: CellType) => CellPatchType<string | undefined>;
+    toScalar?: (props: ScalarProps) => Scalar;
+    toScalarString?: (props: ScalarProps<string>) => Scalar;
+    toScalarNumber?: (props: ScalarProps<number>) => Scalar;
+    toScalarBool?: (props: ScalarProps<boolean>) => Scalar;
+    toScalarDate?: (props: ScalarProps<Date>) => Scalar;
+    toScalarTime?: (props: ScalarProps<Time>) => Scalar;
+    toScalarArray?: (props: ScalarProps<any[]>) => Scalar;
+    toScalarNull?: (props: ScalarProps<null | undefined>) => Scalar;
+    getSelectOptions?: () => AutocompleteOption[];
+    getSelectFallback?: (props: SelectFallbackProps) => CellType | undefined;
+    select?: (props: SelectProps) => CellType | undefined;
+    serializeForClipboard?: (props: SerializeForClipboardProps) => string;
 };
 type PolicyProps = {
     mixins?: PolicyMixinType[];
+    priority?: number;
 };
 export declare class Policy implements PolicyMixinType {
+    priority: number;
+    datetimeFormat: string;
+    dateFormat: string;
+    timeFormat: string;
+    decimalPrecision: number;
+    deserializeFunctions: ((value: string, cell?: CellType) => CellPatchType<any>)[];
+    deserializeCallback?: (parsed: any, cell?: CellType) => CellType;
+    deserializeFirst?: (value: string, cell?: CellType) => CellPatchType<any>;
+    renderCallback?: (rendered: any, props: RenderProps) => any;
     constructor(props?: PolicyProps);
+    private registerDeserializeFunctions;
     private applyMixins;
-    getDefault(props: GetDefaultProps): any;
-    select(props: RestrictProps): any;
-    validate(props: RestrictProps): CellPatchType | undefined;
-    restrict(props: RestrictProps): CellPatchType | undefined;
-    onClip(props: OnClipProps): string;
-    getOptions(): PolicyOption[];
+    render(props: RenderProps): any;
+    renderString({ value }: RenderProps<string>): any;
+    renderBool({ value }: RenderProps<boolean>): any;
+    renderNumber({ value }: RenderProps<number>): any;
+    renderDate({ value }: RenderProps<Date>): any;
+    renderTime({ value }: RenderProps<Time>): any;
+    renderArray(props: RenderProps<any[]>): any;
+    renderObject({ value }: RenderProps<any>): any;
+    renderNull(_props: RenderProps<null | undefined>): any;
+    renderTable({ value }: RenderProps<Table>): any;
+    renderRowHeaderLabel(_n: number): string | null;
+    renderColHeaderLabel(_n: number): string | null;
+    toScalar(props: ScalarProps): Scalar;
+    toScalarString({ value }: ScalarProps<string>): Scalar;
+    toScalarNumber({ value }: ScalarProps<number>): Scalar;
+    toScalarBool({ value }: ScalarProps<boolean>): Scalar;
+    toScalarDate({ value }: ScalarProps<Date>): Scalar;
+    toScalarTime({ value }: ScalarProps<Time>): Scalar;
+    toScalarArray({ value, cell, table, point }: ScalarProps<any[]>): Scalar;
+    toScalarNull(_props: ScalarProps<null | undefined>): Scalar;
+    serialize({ value, cell, table, point }: SerializeProps): string;
+    serializeString({ value }: SerializeProps<string>): string;
+    serializeBool({ value }: SerializeProps<boolean>): string;
+    serializeNumber({ value }: SerializeProps<number>): string;
+    serializeDate({ value }: SerializeProps<Date>): string;
+    serializeTime({ value }: SerializeProps<Time>): string;
+    serializeArray(props: SerializeProps<any[]>): string;
+    serializeNull(_props: SerializeProps<null | undefined>): string;
+    serializeFormulaError({ value }: SerializeProps<FormulaError>): string;
+    serializeError(_props: SerializeProps<Error>): string;
+    serializeForClipboard(props: SerializeForClipboardProps): string;
+    deserializeValue(value: any, cell: CellType): CellType;
+    deserializeRaw(value: any, cell?: CellType): CellType;
+    deserialize(value: string, cell?: CellType): CellPatchType<any>;
+    deserializeAny(value: string, _cell?: CellType): CellPatchType<string | undefined>;
+    deserializeBool(value: string, _cell?: CellType): CellPatchType<boolean | undefined>;
+    deserializeNumber(value: string, _cell?: CellType): CellPatchType<number | undefined>;
+    deserializeTime(value: string, _cell?: CellType): CellPatchType<Time | undefined>;
+    deserializeDate(value: string, _cell?: CellType): CellPatchType<Date | undefined>;
+    getSelectFallback(_props: SelectFallbackProps): any;
+    getSelectOptions(): AutocompleteOption[];
+    select(props: SelectProps): CellType | undefined;
 }
 export type PolicyType = Policy;
-export declare const defaultPolicy: Policy;
+export declare const DEFAULT_POLICY_NAME = "default";
+export declare const nonePolicy: Policy;
 export {};
 //# sourceMappingURL=core.d.ts.map

package/dist/policy/thousand_separator.d.ts

@@ -0,0 +1,4 @@
+import { PolicyMixinType } from './core';
+export declare const ThousandSeparatorPolicyMixin: PolicyMixinType;
+export declare const ThousandSpaceSeparatorPolicyMixin: PolicyMixinType;
+//# sourceMappingURL=thousand_separator.d.ts.map