@legendapp/state 0.22.4 → 0.23.0

package/src/helpers.d.ts

@@ -6,3 +6,6 @@ export declare function getObservableIndex(obs: ObservableReadable): number;
 export declare function opaqueObject<T extends object>(value: T): OpaqueObject<T>;
 export declare function lockObservable(obs: ObservableReadable, value: boolean): void;
 export declare function mergeIntoObservable<T extends ObservableObject | object>(target: T, ...sources: any[]): T;
+export declare function constructObject(path: (string | number)[], value: any): object;
+export declare function deconstructObject(path: (string | number)[], value: any): object;
+export declare function clone(obj: any): any;

package/src/is.d.ts

@@ -1 +1,9 @@
+export declare function isArray(obj: unknown): obj is Array<any>;
+export declare function isString(obj: unknown): obj is string;
+export declare function isObject(obj: unknown): obj is Record<any, any>;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isPrimitive(arg: unknown): arg is string | number | bigint | boolean | symbol;
+export declare function isSymbol(obj: unknown): obj is symbol;
+export declare function isBoolean(obj: unknown): obj is boolean;
+export declare function isPromise<T>(obj: unknown): obj is Promise<T>;
 export declare function isEmpty(obj: object): boolean;

package/src/observableInterfaces.d.ts

@@ -102,9 +102,7 @@ export interface ObservableEvent {
     on(eventType: 'change', cb?: () => void): ObservableListenerDispose;
     get(): void;
 }
-export declare type QueryByModified<T> = boolean | '*' | {
-    '*': '*' | true;
-} | {
+export declare type QueryByModified<T> = boolean | {
     [K in keyof T]?: QueryByModified<T[K]>;
 };
 export interface Change {
@@ -112,29 +110,40 @@ export interface Change {
     valueAtPath: any;
     prevAtPath: any;
 }
-export interface PersistOptionsLocal {
+export interface PersistOptionsLocal<T = any> {
     name: string;
+    adjustData?: {
+        load?: (value: T) => T | Promise<T>;
+        save?: (value: T) => T | Promise<T>;
+    };
+    fieldTransforms?: FieldTransforms<T>;
     mmkv?: MMKVConfiguration;
+    indexedDB?: {
+        prefixID?: string;
+        itemID?: string;
+    };
 }
 export interface PersistOptionsRemote<T = any> {
     readonly?: boolean;
     once?: boolean;
     requireAuth?: boolean;
     saveTimeout?: number;
+    waitForLoad?: Promise<any>;
+    waitForSave?: Promise<any> | ((value: T) => Promise<any>);
     manual?: boolean;
     adjustData?: {
-        load: (value: any, basePath: string) => Promise<any>;
-        save: (value: any, basePath: string, path: string[]) => Promise<any>;
+        load?: (value: T, basePath: string) => T | Promise<T>;
+        save?: (value: T, basePath: string, path: string[]) => T | Promise<T>;
     };
     firebase?: {
         syncPath: (uid: string) => `/${string}/`;
-        fieldTransforms?: SameShapeWithStrings<T>;
+        fieldTransforms?: FieldTransforms<T>;
         queryByModified?: QueryByModified<T>;
-        ignoreKeys?: Record<string, true>;
+        ignoreKeys?: string[];
     };
 }
 export interface PersistOptions<T = any> {
-    local?: string | PersistOptionsLocal;
+    local?: string | PersistOptionsLocal<T>;
     remote?: PersistOptionsRemote<T>;
     persistLocal?: ClassConstructor<ObservablePersistLocal>;
     persistRemote?: ClassConstructor<ObservablePersistRemote>;
@@ -144,16 +153,16 @@ export interface PersistMetadata {
     id?: '__legend_metadata';
     modified?: number;
     pending?: any;
-    array?: boolean;
 }
 export interface ObservablePersistLocal {
     initialize?(config: ObservablePersistenceConfig['persistLocalOptions']): Promise<void>;
-    getTable<T = any>(table: string, config: PersistOptionsLocal | undefined): T;
-    getMetadata(table: string, config: PersistOptionsLocal | undefined): PersistMetadata;
+    getTable<T = any>(table: string, config: PersistOptionsLocal): T;
+    getTableTransformed?<T = any>(table: string, config: PersistOptionsLocal): T;
+    getMetadata(table: string, config: PersistOptionsLocal): PersistMetadata;
     set(table: string, value: any, changes: Change[], config: PersistOptionsLocal): Promise<void>;
-    updateMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal | undefined): Promise<void>;
-    deleteTable(table: string, config: PersistOptionsLocal | undefined): Promise<void>;
-    loadTable?(table: string, config: PersistOptionsLocal | undefined): Promise<void>;
+    updateMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<void>;
+    deleteTable(table: string, config: PersistOptionsLocal): Promise<void>;
+    loadTable?(table: string, config: PersistOptionsLocal): void | Promise<void>;
 }
 export interface ObservablePersistLocalAsync extends ObservablePersistLocal {
     preload(path: string): Promise<void>;
@@ -172,36 +181,27 @@ export interface ObservablePersistState {
 }
 export declare type RecordValue<T> = T extends Record<string, infer t> ? t : never;
 export declare type ArrayValue<T> = T extends Array<infer t> ? t : never;
-export declare type SameShapeWithStringsRecord<T> = {
-    [K in keyof T]-?: string | T[K] extends Record<string, Record<string, any>> ? {
-        _: string;
-        __obj: SameShapeWithStrings<RecordValue<T[K]>> | SameShapeWithStrings<T[K]>;
-    } | {
-        _: string;
-        __dict: SameShapeWithStrings<RecordValue<T[K]>>;
-    } | SameShapeWithStrings<T[K]> : T[K] extends Array<infer t> ? {
-        _: string;
-        __arr: SameShapeWithStrings<t> | Record<string, string>;
-    } | string : T[K] extends Record<string, object> ? ({
-        _: string;
-        __obj: SameShapeWithStrings<RecordValue<T[K]>> | SameShapeWithStrings<T[K]>;
-    } | {
-        _: string;
-        __dict: SameShapeWithStrings<RecordValue<T[K]>>;
-    }) | string : T[K] extends Record<string, any> ? ({
-        _: string;
-        __obj: SameShapeWithStrings<T[K]>;
-    } | {
-        _: string;
-        __dict: SameShapeWithStrings<T[K]>;
-    }) | string : string | {
-        _: string;
-        __val: Record<string, string>;
-    };
+declare type ObjectKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string ? T[K] extends Record<string, any> ? T[K] extends any[] ? never : K : never : never;
+}[keyof T]>;
+declare type DictKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string ? (T[K] extends Record<string, Record<string, any>> ? K : never) : never;
+}[keyof T]>;
+declare type ArrayKeys<T> = Pick<T, {
+    [K in keyof T]-?: K extends string | number ? (T[K] extends any[] ? K : never) : never;
+}[keyof T]>;
+export declare type FieldTransforms<T> = (T extends Record<string, Record<string, any>> ? {
+    _dict: FieldTransformsInner<RecordValue<T>>;
+} : never) | FieldTransformsInner<T>;
+export declare type FieldTransformsInner<T> = {
+    [K in keyof T]: string;
+} & ({
+    [K in keyof ObjectKeys<T> as `${K}_obj`]?: FieldTransforms<T[K]>;
+} | {
+    [K in keyof DictKeys<T> as `${K}_dict`]?: FieldTransforms<RecordValue<T[K]>>;
+}) & {
+    [K in keyof ArrayKeys<T> as `${K}_arr`]?: FieldTransforms<ArrayValue<T[K]>>;
 };
-export declare type SameShapeWithStrings<T> = T extends Record<string, Record<string, any>> ? {
-    __dict: SameShapeWithStrings<RecordValue<T>>;
-} | SameShapeWithStringsRecord<T> : SameShapeWithStringsRecord<T>;
 export declare type Selector<T> = ObservableReadable<T> | (() => T) | T;
 export declare type ClassConstructor<I, Args extends any[] = any[]> = new (...args: Args) => I;
 export declare type ObservableListenerDispose = () => void;

package/src/persist/fieldTransformer.d.ts

@@ -0,0 +1,3 @@
+export declare function transformPath(path: string[], map: Record<string, any>, passThroughKeys: string[], ignoreKeys?: string[]): string[];
+export declare function transformObject(dataIn: Record<string, any>, map: Record<string, any>, passThroughKeys: string[], ignoreKeys?: string[]): Record<string, any>;
+export declare function invertMap(obj: Record<string, any>): any;

package/src/persist-plugins/indexeddb-preloader.d.ts

@@ -1,6 +1,9 @@
-export declare function preloadIndexedDB({ databaseName, tableNames, version, loadTables, }: {
+import type { FieldTransforms } from '../observableInterfaces';
+export declare function preloadIndexedDB({ databaseName, tableNames, version, loadTables, processTables, fieldTransforms, }: {
     databaseName: string;
     tableNames: string[];
     version: number;
     loadTables?: string[];
+    processTables?: (tableData: Record<string, any>) => void;
+    fieldTransforms?: Record<string, FieldTransforms<any>>;
 }): void;

package/src/persist-plugins/indexeddb.d.ts

@@ -1,13 +1,16 @@
-import type { Change, ObservablePersistenceConfig, ObservablePersistLocal, PersistMetadata } from '../observableInterfaces';
+import type { Change, ObservablePersistenceConfig, ObservablePersistLocal, PersistMetadata, PersistOptionsLocal } from '../observableInterfaces';
 export declare class ObservablePersistIndexedDB implements ObservablePersistLocal {
     private tableData;
     private tableMetadata;
+    private tablesAdjusted;
     private db;
     initialize(config: ObservablePersistenceConfig['persistLocalOptions']): Promise<void>;
-    getTable(table: string): any;
-    getMetadata(table: string): any;
-    updateMetadata(table: string, metadata: PersistMetadata): Promise<void>;
-    set(table: string, tableValue: Record<string, any>, changes: Change[]): Promise<void>;
+    loadTable(table: string, config: PersistOptionsLocal): void | Promise<void>;
+    getTable(table: string, config: PersistOptionsLocal): any;
+    getTableTransformed<T = any>(table: string, config: PersistOptionsLocal<any>): T;
+    getMetadata(table: string, config: PersistOptionsLocal): any;
+    updateMetadata(table: string, metadata: PersistMetadata, config: PersistOptionsLocal): Promise<void>;
+    set(table: string, tableValue: Record<string, any>, changes: Change[], config: PersistOptionsLocal): Promise<void>;
     deleteTable(table: string): Promise<void>;
     private initTable;
     private transactionStore;