@epam/uui-db 4.4.0 → 4.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epam/uui-db",
-  "version": "4.4.0",
+  "version": "4.5.3",
   "description": "UUI - client-side relational state cache",
   "author": "EPAM",
   "license": "MIT",
@@ -13,7 +13,7 @@
     "prepublish": "yarn build"
   },
   "dependencies": {
-    "@epam/uui": "4.4.0",
+    "@epam/uui": "4.5.3",
     "@types/lodash.countby": "4.6.6",
     "@types/lodash.filter": "4.6.6",
     "@types/lodash.foreach": "4.5.6",
@@ -59,13 +59,13 @@
     "react-dom": ">=16.0.0"
   },
   "optionalDependencies": {
-    "@epam/uui-docs": "4.4.0"
+    "@epam/uui-docs": "4.5.3"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/epam/UUI"
   },
-  "gitHead": "4735c5ee35c7a922b33ca564e54f9e90620b18c8",
+  "gitHead": "eecf226b7bc65fe15f03c4b34a636426d4bcf897",
   "publishConfig": {
     "directory": "build"
   }

package/readme.md

@@ -1,17 +1,17 @@
-# UUI DB package
-
-This package is a part of [EPAM UUI](https://github.com/epam/UUI) library.
-
-@epam/uui-db is an experimental state-management solution. It maintains immutable relational database on client, provides means to load data from server, update it both from client, and save it to server asynchronously with UI operations.
-
-## Features
-
-- relation data model for state, providing a normalized storage for UI state
-- data loading from server, with automatic GraphQL response normalization into tables
-- synchronous and transactional updates of state from UI
-- asynchronous bi-directional state synchronization between UI and server. UI changes in terms of 'patches' are batched and sent to server. Server can also push updates to UI state
-- GIT-like branch-rebase approach to handle state concurrency
-- tables can be indexed to speed-up queries
-- Views to build arbitrary state projections
-- subscriptions to subscribe parts of UI to changes in Views
-
+# UUI DB package
+
+This package is a part of [EPAM UUI](https://github.com/epam/UUI) library.
+
+@epam/uui-db is an experimental state-management solution. It maintains immutable relational database on client, provides means to load data from server, update it both from client, and save it to server asynchronously with UI operations.
+
+## Features
+
+- relation data model for state, providing a normalized storage for UI state
+- data loading from server, with automatic GraphQL response normalization into tables
+- synchronous and transactional updates of state from UI
+- asynchronous bi-directional state synchronization between UI and server. UI changes in terms of 'patches' are batched and sent to server. Server can also push updates to UI state
+- GIT-like branch-rebase approach to handle state concurrency
+- tables can be indexed to speed-up queries
+- Views to build arbitrary state projections
+- subscriptions to subscribe parts of UI to changes in Views
+

package/src/Db.d.ts

@@ -1,13 +1,13 @@
-import { DbPatch, DbTablesSet, DbView, ViewCacheItem } from './types';
-declare type ViewCache = Map<DbView<any, any, any, any>, Map<string, ViewCacheItem>>;
-export declare abstract class Db<TTables extends DbTablesSet<TTables>> {
-    tables: TTables;
-    private viewCache;
-    constructor(tables: TTables, reusedCache?: ViewCache);
-    private update;
-    with(patch: DbPatch<TTables>): this;
-    valueAbsent: symbol;
-    runView<TResult, TParams = void, TDependencies = void>(view: DbView<this, TResult, TParams, TDependencies>, params?: TParams): TResult;
-}
-export {};
+import { DbPatch, DbTablesSet, DbView, ViewCacheItem } from './types';
+declare type ViewCache = Map<DbView<any, any, any, any>, Map<string, ViewCacheItem>>;
+export declare abstract class Db<TTables extends DbTablesSet<TTables>> {
+    tables: TTables;
+    private viewCache;
+    constructor(tables: TTables, reusedCache?: ViewCache);
+    private update;
+    with(patch: DbPatch<TTables>): this;
+    valueAbsent: symbol;
+    runView<TResult, TParams = void, TDependencies = void>(view: DbView<this, TResult, TParams, TDependencies>, params?: TParams): TResult;
+}
+export {};
 //# sourceMappingURL=Db.d.ts.map

package/src/DbRef.d.ts

@@ -1,49 +1,49 @@
-import { Db } from './Db';
-import { DbPatch, DbTablesSet, ServerError, DbSaveResponse, DbView, DbSubscription } from './types';
-import { IClientIdsMap } from './tempIds';
-import { Loader, LoaderOptions } from './Loader';
-import { DataQuery } from '@epam/uui';
-import { ListLoadingTrackerOptions } from './ListLoadingTracker';
-export declare class DbRef<TTables extends DbTablesSet<TTables>, TDb extends Db<TTables>> {
-    blank: TDb;
-    private base;
-    private log;
-    private autoSave;
-    private savedPoint;
-    private tempIdMap;
-    db: TDb;
-    errors: ServerError[];
-    protected throttleSaveMs: number;
-    readonly idMap: IClientIdsMap;
-    constructor(blank: TDb);
-    /** Saves all committed patches. Useful only if autoSave is off. */
-    save(): void;
-    getAutoSave(): boolean;
-    setAutoSave(val: boolean): void;
-    /** Concrete DbRef instances should override and implement their save logic in this method */
-    protected savePatch(patch: DbPatch<TTables>): Promise<DbSaveResponse<TTables>>;
-    commit(patch: DbPatch<TTables>): void;
-    private beforeUpdate;
-    commitFetch(patch: DbPatch<TTables>): void;
-    private rebase;
-    private makeCumulativePatch;
-    private applyResponse;
-    private lastSubscriptionId;
-    private subscriptions;
-    subscribe<TValue, TParams, TDependencies>(view: DbView<TDb, TValue, TParams, TDependencies>, params: TParams, onUpdate: (newValue: TValue) => any): DbSubscription<TValue, TParams>;
-    updateHandlers: (() => any)[];
-    onUpdate(handler: () => any): void;
-    private update;
-    saveErrorHandlers: ((request: DbPatch<TTables>, error: any) => void)[];
-    onSaveError(handler: (request: DbPatch<TTables>, error: any) => void): void;
-    private saveError;
-    private isSaveInProgress;
-    private isSaveThrottled;
-    private enqueueSave;
-    private handleBeforeUnload;
-    loaders: Loader<TTables, any, any>[];
-    protected makeLoader<TResponse, TRequest>(options: LoaderOptions<TTables, TResponse, TRequest>): Loader<TTables, TResponse, TRequest>;
-    protected makeListLoader<TItem, TResponse = DataQuery<TItem>, TRequest extends DataQuery<TItem> = DataQuery<TItem>>(options: (LoaderOptions<TTables, TResponse, TRequest> & ListLoadingTrackerOptions<TItem, TResponse>)): Loader<TTables, TResponse, TRequest>;
-    reload(): void;
-}
+import { Db } from './Db';
+import { DbPatch, DbTablesSet, ServerError, DbSaveResponse, DbView, DbSubscription } from './types';
+import { IClientIdsMap } from './tempIds';
+import { Loader, LoaderOptions } from './Loader';
+import { DataQuery } from '@epam/uui';
+import { ListLoadingTrackerOptions } from './ListLoadingTracker';
+export declare class DbRef<TTables extends DbTablesSet<TTables>, TDb extends Db<TTables>> {
+    blank: TDb;
+    private base;
+    private log;
+    private autoSave;
+    private savedPoint;
+    private tempIdMap;
+    db: TDb;
+    errors: ServerError[];
+    protected throttleSaveMs: number;
+    readonly idMap: IClientIdsMap;
+    constructor(blank: TDb);
+    /** Saves all committed patches. Useful only if autoSave is off. */
+    save(): void;
+    getAutoSave(): boolean;
+    setAutoSave(val: boolean): void;
+    /** Concrete DbRef instances should override and implement their save logic in this method */
+    protected savePatch(patch: DbPatch<TTables>): Promise<DbSaveResponse<TTables>>;
+    commit(patch: DbPatch<TTables>): void;
+    private beforeUpdate;
+    commitFetch(patch: DbPatch<TTables>): void;
+    private rebase;
+    private makeCumulativePatch;
+    private applyResponse;
+    private lastSubscriptionId;
+    private subscriptions;
+    subscribe<TValue, TParams, TDependencies>(view: DbView<TDb, TValue, TParams, TDependencies>, params: TParams, onUpdate: (newValue: TValue) => any): DbSubscription<TValue, TParams>;
+    updateHandlers: (() => any)[];
+    onUpdate(handler: () => any): void;
+    private update;
+    saveErrorHandlers: ((request: DbPatch<TTables>, error: any) => void)[];
+    onSaveError(handler: (request: DbPatch<TTables>, error: any) => void): void;
+    private saveError;
+    private isSaveInProgress;
+    private isSaveThrottled;
+    private enqueueSave;
+    private handleBeforeUnload;
+    loaders: Loader<TTables, any, any>[];
+    protected makeLoader<TResponse, TRequest>(options: LoaderOptions<TTables, TResponse, TRequest>): Loader<TTables, TResponse, TRequest>;
+    protected makeListLoader<TItem, TResponse = DataQuery<TItem>, TRequest extends DataQuery<TItem> = DataQuery<TItem>>(options: (LoaderOptions<TTables, TResponse, TRequest> & ListLoadingTrackerOptions<TItem, TResponse>)): Loader<TTables, TResponse, TRequest>;
+    reload(): void;
+}
 //# sourceMappingURL=DbRef.d.ts.map

package/src/DbTable.d.ts

@@ -1,35 +1,35 @@
-import { DbTablePatch, DbQuery, DbEntitySchema, DbPkFieldType, DbTablesSet } from './types';
-import * as I from 'immutable';
-import { SortDirection, DataQueryFilter, SortingOption } from '@epam/uui';
-interface DbIndex<TEntity, TId> {
-    field: (keyof TEntity);
-    map: I.Map<any, I.Set<any>>;
-}
-interface DbTableState<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> {
-    pk: I.Map<any, TEntity>;
-    indexes: DbIndex<TEntity, TId>[];
-}
-export declare class DbTable<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> {
-    readonly schema: DbEntitySchema<TEntity, TId, TTables>;
-    private state?;
-    private q?;
-    constructor(schema: DbEntitySchema<TEntity, TId, TTables>, state?: DbTableState<TEntity, TId, TTables>, q?: DbQuery<TEntity>);
-    protected keyToImmutable(id: TId): TId | I.List<any>;
-    byId(id: TId): TEntity;
-    getId(entity: Partial<TEntity>): TId;
-    private update;
-    with(patch: DbTablePatch<TEntity>): this;
-    find(filter: DataQueryFilter<TEntity>): DbTable<TEntity, TId, TTables>;
-    order(order: SortingOption[]): this;
-    orderBy(field: Extract<keyof TEntity, string>, direction?: SortDirection): this;
-    thenBy(field: Extract<keyof TEntity, string>, direction?: SortDirection): this;
-    search(text: string): this;
-    range(from: number, count: number): TEntity[];
-    count(): number;
-    one(): TEntity;
-    toArray(): TEntity[];
-    map<T>(fn: (item: TEntity, index?: number) => T): T[];
-    private runQuery;
-}
-export {};
+import { DbTablePatch, DbQuery, DbEntitySchema, DbPkFieldType, DbTablesSet } from './types';
+import * as I from 'immutable';
+import { SortDirection, DataQueryFilter, SortingOption } from '@epam/uui';
+interface DbIndex<TEntity, TId> {
+    field: (keyof TEntity);
+    map: I.Map<any, I.Set<any>>;
+}
+interface DbTableState<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> {
+    pk: I.Map<any, TEntity>;
+    indexes: DbIndex<TEntity, TId>[];
+}
+export declare class DbTable<TEntity, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>> {
+    readonly schema: DbEntitySchema<TEntity, TId, TTables>;
+    private state?;
+    private q?;
+    constructor(schema: DbEntitySchema<TEntity, TId, TTables>, state?: DbTableState<TEntity, TId, TTables>, q?: DbQuery<TEntity>);
+    protected keyToImmutable(id: TId): TId | I.List<any>;
+    byId(id: TId): TEntity;
+    getId(entity: Partial<TEntity>): TId;
+    private update;
+    with(patch: DbTablePatch<TEntity>): this;
+    find(filter: DataQueryFilter<TEntity>): DbTable<TEntity, TId, TTables>;
+    order(order: SortingOption[]): this;
+    orderBy(field: Extract<keyof TEntity, string>, direction?: SortDirection): this;
+    thenBy(field: Extract<keyof TEntity, string>, direction?: SortDirection): this;
+    search(text: string): this;
+    range(from: number, count: number): TEntity[];
+    count(): number;
+    one(): TEntity;
+    toArray(): TEntity[];
+    map<T>(fn: (item: TEntity, index?: number) => T): T[];
+    private runQuery;
+}
+export {};
 //# sourceMappingURL=DbTable.d.ts.map

package/src/IxSet.d.ts

@@ -1,28 +1,28 @@
-import BTree from 'sorted-btree';
-import { DbQuery } from './types';
-export interface IxSetIndexDefinition<TEntity> {
-    fields: (keyof TEntity)[];
-}
-declare const ID: unique symbol;
-declare type IndexKey<TEntity> = TEntity & {
-    [ID]: any;
-};
-export interface IxSetIndex<TEntity> extends IxSetIndexDefinition<TEntity> {
-    tree: BTree<IndexKey<TEntity>, void>;
-    compare: (a: IndexKey<TEntity>, b: IndexKey<TEntity>) => number;
-}
-export declare class IxSet<TEntity, TId> {
-    private getId;
-    empty: BTree<TId, TEntity>;
-    /** Primary key - a b-tree with entity ID as a key, and entity itself as a value */
-    pk: BTree<TId, TEntity>;
-    indexes: IxSetIndex<TEntity>[];
-    constructor(getId: (e: Partial<TEntity>) => TId, indexesDefinition: IxSetIndexDefinition<TEntity>[]);
-    clone(): IxSet<TEntity, TId>;
-    byId(id: TId): TEntity;
-    with(items: Partial<TEntity>[]): IxSet<TEntity, TId>;
-    query(query: DbQuery<TEntity>): TEntity[];
-    queryOne(query: DbQuery<TEntity>): TEntity;
-}
-export {};
+import BTree from 'sorted-btree';
+import { DbQuery } from './types';
+export interface IxSetIndexDefinition<TEntity> {
+    fields: (keyof TEntity)[];
+}
+declare const ID: unique symbol;
+declare type IndexKey<TEntity> = TEntity & {
+    [ID]: any;
+};
+export interface IxSetIndex<TEntity> extends IxSetIndexDefinition<TEntity> {
+    tree: BTree<IndexKey<TEntity>, void>;
+    compare: (a: IndexKey<TEntity>, b: IndexKey<TEntity>) => number;
+}
+export declare class IxSet<TEntity, TId> {
+    private getId;
+    empty: BTree<TId, TEntity>;
+    /** Primary key - a b-tree with entity ID as a key, and entity itself as a value */
+    pk: BTree<TId, TEntity>;
+    indexes: IxSetIndex<TEntity>[];
+    constructor(getId: (e: Partial<TEntity>) => TId, indexesDefinition: IxSetIndexDefinition<TEntity>[]);
+    clone(): IxSet<TEntity, TId>;
+    byId(id: TId): TEntity;
+    with(items: Partial<TEntity>[]): IxSet<TEntity, TId>;
+    query(query: DbQuery<TEntity>): TEntity[];
+    queryOne(query: DbQuery<TEntity>): TEntity;
+}
+export {};
 //# sourceMappingURL=IxSet.d.ts.map

package/src/ListLoadingTracker.d.ts

@@ -1,19 +1,19 @@
-import { DataQuery, LazyDataSourceApiResponse } from '@epam/uui';
-import { ILoadingTracker } from './types';
-export interface ListLoadingTrackerOptions<TItem, TResponse> {
-    extractList?: (response: TResponse) => LazyDataSourceApiResponse<TItem>;
-}
-export declare class ListLoadingTracker<TItem, TRequest extends DataQuery<TItem> = DataQuery<TItem>, TResponse = LazyDataSourceApiResponse<TItem>> implements ILoadingTracker<TRequest, TResponse> {
-    private options?;
-    private cache;
-    private extractList;
-    constructor(options?: ListLoadingTrackerOptions<TItem, TResponse>);
-    private prepare;
-    diff(request: TRequest): TRequest;
-    count(request: TRequest): {
-        knownCount: number;
-        exactCount: number;
-    };
-    append(request: TRequest, response?: TResponse): void;
-}
+import { DataQuery, LazyDataSourceApiResponse } from '@epam/uui';
+import { ILoadingTracker } from './types';
+export interface ListLoadingTrackerOptions<TItem, TResponse> {
+    extractList?: (response: TResponse) => LazyDataSourceApiResponse<TItem>;
+}
+export declare class ListLoadingTracker<TItem, TRequest extends DataQuery<TItem> = DataQuery<TItem>, TResponse = LazyDataSourceApiResponse<TItem>> implements ILoadingTracker<TRequest, TResponse> {
+    private options?;
+    private cache;
+    private extractList;
+    constructor(options?: ListLoadingTrackerOptions<TItem, TResponse>);
+    private prepare;
+    diff(request: TRequest): TRequest;
+    count(request: TRequest): {
+        knownCount: number;
+        exactCount: number;
+    };
+    append(request: TRequest, response?: TResponse): void;
+}
 //# sourceMappingURL=ListLoadingTracker.d.ts.map

package/src/Loader.d.ts

@@ -1,24 +1,24 @@
-import { DbRef } from './DbRef';
-import { DbPatch, DbTablesSet, LoadingState, ILoadingTracker } from './types';
-export interface LoaderOptions<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
-    api: (request: TRequest) => Promise<TResult>;
-    convertToPatch?: (result: TResult) => DbPatch<TTables>;
-    postProcess?: (patch: DbPatch<TTables>) => DbPatch<TTables>;
-    clientToServerRequest?: (request: TRequest) => TRequest;
-}
-export interface LoaderResult<TRequest> extends LoadingState<TRequest> {
-    promise: Promise<void>;
-    reload: () => void;
-}
-export declare class Loader<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
-    private dbRef;
-    private getTracker;
-    private options;
-    private currentRequests;
-    loaded: ILoadingTracker<TRequest, TResult>;
-    private loadedAndLoading;
-    constructor(dbRef: DbRef<TTables, any>, getTracker: () => ILoadingTracker<TRequest, TResult>, options: LoaderOptions<TTables, TResult, TRequest>);
-    private loadImpl;
-    load: (inputRequest: TRequest) => LoaderResult<TRequest>;
-}
+import { DbRef } from './DbRef';
+import { DbPatch, DbTablesSet, LoadingState, ILoadingTracker } from './types';
+export interface LoaderOptions<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
+    api: (request: TRequest) => Promise<TResult>;
+    convertToPatch?: (result: TResult) => DbPatch<TTables>;
+    postProcess?: (patch: DbPatch<TTables>) => DbPatch<TTables>;
+    clientToServerRequest?: (request: TRequest) => TRequest;
+}
+export interface LoaderResult<TRequest> extends LoadingState<TRequest> {
+    promise: Promise<void>;
+    reload: () => void;
+}
+export declare class Loader<TTables extends DbTablesSet<TTables>, TResult, TRequest> {
+    private dbRef;
+    private getTracker;
+    private options;
+    private currentRequests;
+    loaded: ILoadingTracker<TRequest, TResult>;
+    private loadedAndLoading;
+    constructor(dbRef: DbRef<TTables, any>, getTracker: () => ILoadingTracker<TRequest, TResult>, options: LoaderOptions<TTables, TResult, TRequest>);
+    private loadImpl;
+    load: (inputRequest: TRequest) => LoaderResult<TRequest>;
+}
 //# sourceMappingURL=Loader.d.ts.map

package/src/Scheduler.d.ts

@@ -1,19 +1,19 @@
-export interface SchedulerTask {
-    run: () => Promise<any>;
-    result?: any;
-    error?: any;
-    resolve?: (result: any) => void;
-    reject?: (result: any) => void;
-    isConcurrent: boolean;
-}
-export declare class Scheduler {
-    scheduled: SchedulerTask[];
-    running: SchedulerTask[];
-    complete: SchedulerTask[];
-    run(run: () => Promise<any>, isConcurrent?: boolean): Promise<unknown>;
-    isRunScheduled: boolean;
-    private scheduleRun;
-    tasksRunning: number;
-    private runQueues;
-}
+export interface SchedulerTask {
+    run: () => Promise<any>;
+    result?: any;
+    error?: any;
+    resolve?: (result: any) => void;
+    reject?: (result: any) => void;
+    isConcurrent: boolean;
+}
+export declare class Scheduler {
+    scheduled: SchedulerTask[];
+    running: SchedulerTask[];
+    complete: SchedulerTask[];
+    run(run: () => Promise<any>, isConcurrent?: boolean): Promise<unknown>;
+    isRunScheduled: boolean;
+    private scheduleRun;
+    tasksRunning: number;
+    private runQueues;
+}
 //# sourceMappingURL=Scheduler.d.ts.map

package/src/SimpleLoadingTracker.d.ts

@@ -1,9 +1,9 @@
-import { ILoadingTracker } from './types';
-export declare class SimpleLoadingTracker<TRequest, TResult> implements ILoadingTracker<TRequest, TResult> {
-    private set;
-    constructor();
-    private getKey;
-    diff(request: TRequest): TRequest;
-    append(request: TRequest, result: TResult): void;
-}
+import { ILoadingTracker } from './types';
+export declare class SimpleLoadingTracker<TRequest, TResult> implements ILoadingTracker<TRequest, TResult> {
+    private set;
+    constructor();
+    private getKey;
+    diff(request: TRequest): TRequest;
+    append(request: TRequest, result: TResult): void;
+}
 //# sourceMappingURL=SimpleLoadingTracker.d.ts.map

package/src/__benchmarks__/filter.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=filter.d.ts.map

package/src/__benchmarks__/index.d.ts

@@ -1,3 +1,3 @@
-import './pkUpdate';
-import './query';
+import './pkUpdate';
+import './query';
 //# sourceMappingURL=index.d.ts.map

package/src/__benchmarks__/pkLookup.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=pkLookup.d.ts.map

package/src/__benchmarks__/pkUpdate.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=pkUpdate.d.ts.map

package/src/__benchmarks__/query.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=query.d.ts.map

package/src/__benchmarks__/sorting.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=sorting.d.ts.map

package/src/__benchmarks__/testData.d.ts

@@ -1,15 +1,15 @@
-import { IxSet } from '../IxSet';
-export interface Person {
-    id: number;
-    name: string;
-    departmentId: number;
-    location?: string;
-}
-export declare const test100KPersons: {
-    id: number;
-    name: string;
-    departmentId: number;
-}[];
-export declare const blankIxSet: IxSet<Person, number>;
-export declare const blankIxSetNoIndex: IxSet<Person, number>;
+import { IxSet } from '../IxSet';
+export interface Person {
+    id: number;
+    name: string;
+    departmentId: number;
+    location?: string;
+}
+export declare const test100KPersons: {
+    id: number;
+    name: string;
+    departmentId: number;
+}[];
+export declare const blankIxSet: IxSet<Person, number>;
+export declare const blankIxSetNoIndex: IxSet<Person, number>;
 //# sourceMappingURL=testData.d.ts.map

package/src/index.d.ts

@@ -1,9 +1,9 @@
-export * from './types';
-export * from './Db';
-export * from './DbTable';
-export * from './DbRef';
-export * from './tempIds';
-export * from './utils';
-export * from './patchHelpers';
-export * from './reactHooks';
+export * from './types';
+export * from './Db';
+export * from './DbTable';
+export * from './DbRef';
+export * from './tempIds';
+export * from './utils';
+export * from './patchHelpers';
+export * from './reactHooks';
 //# sourceMappingURL=index.d.ts.map

package/src/patchHelpers.d.ts

@@ -1,18 +1,18 @@
-import { Db } from "./Db";
-import { DbPatch, DbTablesSet, DbEntitySchema, DbPkFieldType } from "./types";
-import { IClientIdsMap } from "./tempIds";
-export declare function unionPatches<TTables extends DbTablesSet<TTables>>(patches: DbPatch<TTables>[]): DbPatch<TTables>;
-export declare function mergeEntityPatches<TTables extends DbTablesSet<TTables>>(tables: TTables, patch: DbPatch<TTables>): DbPatch<TTables>;
-export declare function flattenResponse<TTables extends DbTablesSet<any>>(response: any, tables: TTables): DbPatch<TTables>;
-export declare function isPatchBlank<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>): boolean;
-/**
- * Given several patches, creates a new single patch with all fields from all entities in all patches.
- */
-export declare function makeCumulativePatch<TTables extends DbTablesSet<TTables>>(updatedDb: Db<TTables>, patches: DbPatch<TTables>[], clientIdsMap: IClientIdsMap): DbPatch<TTables>;
-export declare function isClientOnly<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: T, schema: DbEntitySchema<T, TId, TTables>): boolean;
-export declare function getId<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>): TId;
-export declare function isNew<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>, clientIdsMap: IClientIdsMap): boolean;
-export declare function hasServerFields<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>, clientIdsMap: IClientIdsMap, tables: TTables): boolean;
-export declare function getParentEntities<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>, tables: TTables): DbPatch<TTables>;
-export declare function getEntityParentDependencies<TEntity, TTables extends DbTablesSet<TTables>>(entity: Partial<TEntity>, entityName: keyof TTables, tables: TTables): DbPatch<TTables>;
+import { Db } from "./Db";
+import { DbPatch, DbTablesSet, DbEntitySchema, DbPkFieldType } from "./types";
+import { IClientIdsMap } from "./tempIds";
+export declare function unionPatches<TTables extends DbTablesSet<TTables>>(patches: DbPatch<TTables>[]): DbPatch<TTables>;
+export declare function mergeEntityPatches<TTables extends DbTablesSet<TTables>>(tables: TTables, patch: DbPatch<TTables>): DbPatch<TTables>;
+export declare function flattenResponse<TTables extends DbTablesSet<any>>(response: any, tables: TTables): DbPatch<TTables>;
+export declare function isPatchBlank<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>): boolean;
+/**
+ * Given several patches, creates a new single patch with all fields from all entities in all patches.
+ */
+export declare function makeCumulativePatch<TTables extends DbTablesSet<TTables>>(updatedDb: Db<TTables>, patches: DbPatch<TTables>[], clientIdsMap: IClientIdsMap): DbPatch<TTables>;
+export declare function isClientOnly<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: T, schema: DbEntitySchema<T, TId, TTables>): boolean;
+export declare function getId<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>): TId;
+export declare function isNew<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>, clientIdsMap: IClientIdsMap): boolean;
+export declare function hasServerFields<T, TId extends DbPkFieldType, TTables extends DbTablesSet<TTables>>(entity: Partial<T>, schema: DbEntitySchema<T, TId, TTables>, clientIdsMap: IClientIdsMap, tables: TTables): boolean;
+export declare function getParentEntities<TTables extends DbTablesSet<TTables>>(patch: DbPatch<TTables>, tables: TTables): DbPatch<TTables>;
+export declare function getEntityParentDependencies<TEntity, TTables extends DbTablesSet<TTables>>(entity: Partial<TEntity>, entityName: keyof TTables, tables: TTables): DbPatch<TTables>;
 //# sourceMappingURL=patchHelpers.d.ts.map

package/src/reactHooks.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="react" />
-import { DbRef } from './DbRef';
-import { DbViewOptions } from '.';
-export declare const DbContext: import("react").Context<any>;
-export declare function useDbRef<TDbRef extends DbRef<any, any>>(): TDbRef;
-export declare function useDbView<TDb, TResult, TParams = void, TDependencies = void>(fn: (db: TDb, params: TParams, dependencies: TDependencies) => TResult, params?: TParams, options?: DbViewOptions<TDb, TResult, TParams, TDependencies>): TResult;
+/// <reference types="react" />
+import { DbRef } from './DbRef';
+import { DbViewOptions } from '.';
+export declare const DbContext: import("react").Context<any>;
+export declare function useDbRef<TDbRef extends DbRef<any, any>>(): TDbRef;
+export declare function useDbView<TDb, TResult, TParams = void, TDependencies = void>(fn: (db: TDb, params: TParams, dependencies: TDependencies) => TResult, params?: TParams, options?: DbViewOptions<TDb, TResult, TParams, TDependencies>): TResult;
 //# sourceMappingURL=reactHooks.d.ts.map