@arcote.tech/arc 0.0.15 → 0.0.17

package/dist/collection/collection.d.ts

@@ -1,24 +1,22 @@
-import type { ArcContextElement } from "../context/element";
+import { ArcContextElement } from "../context/element";
 import type { ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
-import { objectUtil, type util } from "../utils";
-import type { CollectionChange } from "./collection-change";
+import { objectUtil, type DeepPartial, type util } from "../utils";
 import type { DataStorage } from "../data-storage";
-import type { ArcDefault } from "../elements/default";
 import { ArcAllItemsQueryBuilder } from "./query-builders/all-items";
 import { ArcIndexedItemsQueryBuilder } from "./query-builders/indexed";
 import { ArcOneItemQueryBuilder } from "./query-builders/one-item";
 export type CollectionItem<C extends ArcCollectionAny | ArcIndexedCollectionAny> = objectUtil.simplify<{
     _id: string;
 } & ReturnType<C["deserialize"]>>;
-export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> = objectUtil.simplify<{
+export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny> = objectUtil.simplify<{
     _id: ReturnType<Id["deserialize"]>;
 } & ReturnType<Schema["deserialize"]>>;
 type CollectionQueryBuilder<T extends ArcCollection<any, any, any>> = {
     all: () => ArcAllItemsQueryBuilder<T>;
     one: (id: util.GetType<T["id"]> | undefined) => ArcOneItemQueryBuilder<T>;
 };
-type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> = {
+type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     one: (id: util.GetType<Id>) => Deserialize<Id, Schema>;
     remove: (id: util.GetType<Id>) => Promise<any>;
     all: () => Deserialize<Id, Schema>[];
@@ -26,9 +24,25 @@ type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny |
         id: util.GetType<Id>;
     }>;
     set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["serialize"]>) => Promise<any>;
-    modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<Partial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
+    edit: (id: util.GetType<Id>, editCallback: (item: Deserialize<Id, Schema>) => Promise<void> | void) => Promise<void>;
+    modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<DeepPartial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
 };
-export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> implements ArcContextElement<CollectionChange, CollectionChange> {
+export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElement<{
+    type: "delete";
+    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
+} | {
+    type: "set";
+    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
+} | {
+    type: "modify";
+    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    changes: objectUtil.simplify<DeepPartial<util.FirstArgument<Schema["serialize"]>>>;
+} | {
+    type: "mutate";
+    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
+}> {
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
@@ -43,17 +57,17 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
         _id: util.FirstArgument<Id["deserialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): Deserialize<Id, Schema>;
     queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>>;
-    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema>;
+    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema>;
     indexBy<Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
         [name: string]: Indexes[];
     }>(indexes: I): ArcIndexedCollection<Name, Id, Schema, keyof ReturnType<Schema["deserialize"]>, I>;
 }
-export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>, Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
+export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
     [name: string]: Indexes[];
 }> extends ArcCollection<Name, Id, Schema> {
     readonly indexes: I;
     constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
-    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema> & {
+    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema> & {
         [func in keyof I]: (args: {
             [Key in I[func][number]]: util.GetType<Schema>[Key];
         }) => Deserialize<Id, Schema>[];
@@ -66,9 +80,9 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
 }
 export type ArcCollectionAny = ArcCollection<any, any, any>;
 export type ArcIndexedCollectionAny = ArcIndexedCollection<any, any, any, any, any>;
-type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> = {
+type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     sort?: (a: Deserialize<Id, Schema>, b: Deserialize<Id, Schema>) => number;
 };
-export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
+export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
 export {};
 //# sourceMappingURL=collection.d.ts.map

package/dist/collection/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./collection";
-export * from "./collection-change";
 export * from "./queries/abstract-collection-query";
 export * from "./queries/util";
 //# sourceMappingURL=index.d.ts.map

package/dist/collection/queries/abstract-collection-query.d.ts

@@ -1,15 +1,14 @@
-import type { ArcQuery } from "../../context/query";
+import { ArcQuery, type ArcQueryListener } from "../../context/query";
 import type { DataStorage, ListenerEvent, StoreState } from "../../data-storage";
 import type { ArcCollectionAny, CollectionItem } from "../collection";
-export type CollectionQueryListener<Response> = (result: Response) => void;
-export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Response> implements ArcQuery<Response> {
+export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Result> extends ArcQuery<Result> {
     protected collection: Collection;
-    lastResult?: Response;
-    private listener?;
+    protected bindedChangeHandler: (changes: ListenerEvent<CollectionItem<Collection>>[]) => void;
+    private store;
     constructor(collection: Collection);
-    run(dataStorage: DataStorage, listener?: CollectionQueryListener<Response>): Promise<Response>;
-    protected abstract onChange(change: ListenerEvent<CollectionItem<Collection>>): Response | false;
-    protected abstract fetch(store: StoreState<CollectionItem<Collection>>): Promise<Response>;
+    run(dataStorage: DataStorage, listener?: ArcQueryListener<Result>): Promise<Result>;
+    protected abstract onChange(change: ListenerEvent<CollectionItem<Collection>>): Result | false;
+    protected abstract fetch(store: StoreState<CollectionItem<Collection>>): Promise<Result>;
     protected changeHandler(changes: ListenerEvent<CollectionItem<Collection>>[]): void;
     unsubscribe(): void;
     private nextResult;

package/dist/collection/queries/one-item.d.ts

@@ -9,7 +9,7 @@ export declare class ArcOneItemQuery<Collection extends ArcCollectionAny> extend
         _id: string;
     } & ReturnType<Collection["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
         _id: string;
-    } & ReturnType<Collection["deserialize"]>)[KeyType]; } : never) | undefined;
+    } & ReturnType<Collection["deserialize"]>)[KeyType]; } : never) | null;
     protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<({
         _id: string;
     } & ReturnType<Collection["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({

package/dist/collection/queries/util.d.ts

@@ -1,3 +1,3 @@
-import type { ArcContextAny, ArcQuery, QueryFactoryFunction } from "../../context";
-export type QueryBuilderFunctionResult<QB extends QueryFactoryFunction<ArcContextAny>> = ReturnType<ReturnType<QB>["toQuery"]> extends ArcQuery<infer Result> ? Result : never;
+import type { ArcContextAny, QueryFactoryFunction } from "../../context";
+export type QueryBuilderFunctionResult<QB extends QueryFactoryFunction<ArcContextAny>> = ReturnType<ReturnType<QB>["toQuery"]>["lastResult"];
 //# sourceMappingURL=util.d.ts.map

package/dist/context/context.d.ts

@@ -1,21 +1,32 @@
 import type { DataStorage } from "../data-storage";
-import type { Commands } from "./commands";
-import type { ArcContextElementAny, ArcContextElementChanges } from "./element";
-declare class ArcContext<const C extends ArcContextElementAny[]> {
-    readonly elements: C;
-    readonly commands: Commands<ArcContext<C>>;
+import type { objectUtil } from "../utils";
+import type { CommandContext, Commands, CommandsClient } from "./commands";
+import type { ArcContextElement, ArcContextElementAny } from "./element";
+declare class ArcContext<const C extends ArcContextElementAny[], const Cmds extends Commands<ArcContext<C, any, any>>, const L extends Listener<ArcContext<C, any, any>>[]> {
     readonly version: number;
+    readonly elements: C;
+    readonly commands: Cmds;
+    readonly listeners?: L | undefined;
     elementsMap: {
         [key: string]: C[number];
     };
-    constructor(elements: C, commands: Commands<ArcContext<C>>, version: number);
+    constructor(version: number, elements: C, commands: Cmds, listeners?: L | undefined);
     queryBuilder(): {
         [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
     };
-    commandContext(dataStorage: DataStorage): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; };
+    commandContext(client: string, dataStorage: DataStorage, publishEvent: (event: any) => Promise<void>): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; } & {
+        $client: string;
+    };
+    commandsClient(client: string, dataStorage: DataStorage, catchErrorCallback: (error: any) => void): CommandsClient<Cmds>;
 }
-export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
-export type ArcContextChanges<C extends ArcContextAny> = ArcContextElementChanges<C["elements"][number]>;
-export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements>>>(elements: Elements, commands: Cmds, version: number): ArcContext<Elements>;
+export type ArcContextAny = ArcContext<ArcContextElementAny[], Commands<any>, any>;
+export type ElementEvents<Element extends ArcContextElementAny> = Element extends ArcContextElement<any> ? Element["$event"] : never;
+export type ContextEvents<Context extends ArcContextAny> = {
+    [Element in Context["elements"][number] as Element["name"]]: objectUtil.simplify<{
+        element: Element["name"];
+    } & ElementEvents<Element>>;
+}[Context["elements"][number]["name"]];
+export type Listener<Context extends ArcContextAny> = (event: ContextEvents<Context>, context: CommandContext<Context>) => Promise<void> | void;
+export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements, any, any>>, L extends Listener<ArcContext<Elements, Cmds, any>>[]>(version: number, elements: Elements, commands: Cmds, listeners?: L): ArcContext<Elements, Cmds, L>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -1,10 +1,10 @@
 import type { DataStorage } from "../data-storage";
-export interface ArcContextElement<Change, Event> {
-    name: string;
-    queryBuilder(): any;
-    commandContext(dataStorage: DataStorage): unknown;
-    deserialize?: (data: any) => any;
+export declare abstract class ArcContextElement<const Event> {
+    readonly $event: Event;
+    abstract name: string;
+    abstract queryBuilder(): any;
+    abstract commandContext(dataStorage: DataStorage, publishEvent: (event: Event) => Promise<void>): any;
+    abstract deserialize(data: any): any;
 }
-export type ArcContextElementAny = ArcContextElement<any, any>;
-export type ArcContextElementChanges<Element extends ArcContextElementAny> = Element extends ArcContextElement<infer Change, any> ? Change : never;
+export type ArcContextElementAny = ArcContextElement<any>;
 //# sourceMappingURL=element.d.ts.map

package/dist/context/query.d.ts

@@ -1,7 +1,10 @@
 import type { DataStorage } from "../data-storage";
-export interface ArcQuery<Result> {
-    run(store: DataStorage, callback?: (data: Result) => void): Promise<Result>;
-    unsubscribe(): void;
+export type ArcQueryListener<Result> = (result: Result) => void;
+export declare abstract class ArcQuery<Result> {
+    lastResult: Result;
+    listener?: ArcQueryListener<Result>;
+    abstract run(store: DataStorage, callback?: ArcQueryListener<Result>): Promise<Result>;
+    abstract unsubscribe(): void;
 }
 export type ArcQueryAny = ArcQuery<any>;
 //# sourceMappingURL=query.d.ts.map

package/dist/data-storage/ForkStoreState.d.ts

@@ -1,5 +1,5 @@
 import type { QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.interface";
+import type { DataStorage } from "./data-storage.abstract";
 import type { MasterStoreState } from "./store-state-master";
 import { StoreState } from "./store-state.abstract";
 export declare class ForkStoreState<

package/dist/data-storage/StoreState.d.ts

@@ -1,24 +1,39 @@
-import { ForkStoreState, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.interface";
-export declare abstract class StoreState<Item extends {
+import {
+  ForkStoreState,
+  QueryListener,
+  QueryListenerCallback,
+  StoreStateChange,
+} from "./data-storage";
+import type { DataStorage } from "./data-storage.abstract";
+export declare abstract class StoreState<
+  Item extends {
     _id: string;
-}> {
-    storeName: string;
-    protected dataStorage: DataStorage;
-    protected deserialize?: ((data: any) => Item) | undefined;
-    protected listeners: Set<QueryListener<Item>>;
-    protected indexQueryCache: Map<string, Item[]>;
-    constructor(storeName: string, dataStorage: DataStorage, deserialize?: ((data: any) => Item) | undefined);
-    abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    fork(): ForkStoreState<Item>;
-    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    set(item: Item): void;
-    remove(id: string): void;
-    modify(id: string, data: Partial<Item>): void;
-    unsubscribe(listener: QueryListener<Item>): void;
-    private notifyListeners;
-    private getAllLocalItems;
-    private mergeWithLocalModifications;
-    private matchesIndex;
+  },
+> {
+  storeName: string;
+  protected dataStorage: DataStorage;
+  protected deserialize?: ((data: any) => Item) | undefined;
+  protected listeners: Set<QueryListener<Item>>;
+  protected indexQueryCache: Map<string, Item[]>;
+  constructor(
+    storeName: string,
+    dataStorage: DataStorage,
+    deserialize?: ((data: any) => Item) | undefined
+  );
+  abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+  fork(): ForkStoreState<Item>;
+  findByIndex(
+    index: string,
+    data: any,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item[]>;
+  set(item: Item): void;
+  remove(id: string): void;
+  modify(id: string, data: Partial<Item>): void;
+  unsubscribe(listener: QueryListener<Item>): void;
+  private notifyListeners;
+  private getAllLocalItems;
+  private mergeWithLocalModifications;
+  private matchesIndex;
 }
-//# sourceMappingURL=StoreState.d.ts.map
+//# sourceMappingURL=StoreState.d.ts.map

package/dist/data-storage/data-storage-forked.d.ts

@@ -1,7 +1,7 @@
 import type { ReadTransaction, ReadWriteTransaction } from "../db";
-import type { DataStorage } from "./data-storage.interface";
+import { DataStorage } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
-export declare class ForkedDataStorage implements DataStorage {
+export declare class ForkedDataStorage extends DataStorage {
     private master;
     private stores;
     constructor(master: DataStorage);

package/dist/data-storage/data-storage-master.d.ts

@@ -2,19 +2,21 @@ import type { ArcContextAny } from "../context";
 import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "../db";
 import type { RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
 import { ForkedDataStorage } from "./data-storage-forked";
-import type { DataStorage } from "./data-storage.interface";
+import { DataStorage, type DataStorageChanges } from "./data-storage.abstract";
 import type { StoreState } from "./store-state.abstract";
-export declare class MasterDataStorage implements DataStorage {
+export declare class MasterDataStorage extends DataStorage {
     private dbAdapter;
     private arcContext;
     private stores;
     private rtcAdapter;
-    constructor(dbAdapter: Promise<DatabaseAdapter>, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
+    constructor(dbAdapter: Promise<DatabaseAdapter> | DatabaseAdapter, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
     getReadTransaction(): Promise<ReadTransaction>;
     getReadWriteTransaction(): Promise<ReadWriteTransaction>;
     getStore<Item extends {
         _id: string;
     }>(storeName: string): StoreState<Item>;
+    applyChanges(changes: DataStorageChanges[]): Promise<void[]>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
     fork(): ForkedDataStorage;
     sync(progressCallback: ({ store, size }: {
         store: string;

package/dist/data-storage/data-storage.abstract.d.ts

@@ -0,0 +1,47 @@
+import { type Patch } from "mutative";
+import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import type { ForkedDataStorage } from "./data-storage-forked";
+import type { StoreState } from "./store-state.abstract";
+export declare abstract class DataStorage {
+    abstract getStore<Item extends {
+        _id: string;
+    }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
+    abstract fork(): ForkedDataStorage;
+    abstract getReadTransaction(): Promise<ReadTransaction>;
+    abstract getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+    commitChanges(changes: DataStorageChanges[]): Promise<void>;
+}
+export type StoreStateChange<Item> = {
+    type: "set";
+    data: Item;
+} | {
+    type: "delete";
+    id: string;
+} | {
+    type: "modify";
+    id: string;
+    data: Partial<Item>;
+} | {
+    type: "mutate";
+    id: string;
+    patches: Patch[];
+};
+export type QueryListenerCallback<Item> = (events: ListenerEvent<Item>[]) => void;
+export type QueryListener<Item> = {
+    callback: QueryListenerCallback<Item>;
+    id?: string;
+};
+export type ListenerEvent<Item> = {
+    type: "set";
+    item: Item;
+    id: string;
+} | {
+    type: "delete";
+    item: null;
+    id: string;
+};
+export type DataStorageChanges = {
+    store: string;
+    changes: StoreStateChange<any>[];
+};
+//# sourceMappingURL=data-storage.abstract.d.ts.map

package/dist/data-storage/data-storage.interface.d.ts

@@ -1,13 +1,14 @@
+import { type Patch } from "mutative";
 import type { ReadTransaction, ReadWriteTransaction } from "../db";
 import type { ForkedDataStorage } from "./data-storage-forked";
 import type { StoreState } from "./store-state.abstract";
-export interface DataStorage {
-    getStore<Item extends {
+export declare abstract class DataStorage {
+    abstract getStore<Item extends {
         _id: string;
     }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
-    fork(): ForkedDataStorage;
-    getReadTransaction(): Promise<ReadTransaction>;
-    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+    abstract fork(): ForkedDataStorage;
+    abstract getReadTransaction(): Promise<ReadTransaction>;
+    abstract getReadWriteTransaction(): Promise<ReadWriteTransaction>;
 }
 export type StoreStateChange<Item> = {
     type: "set";
@@ -19,6 +20,10 @@ export type StoreStateChange<Item> = {
     type: "modify";
     id: string;
     data: Partial<Item>;
+} | {
+    type: "mutate";
+    id: string;
+    patches: Patch[];
 };
 export type QueryListenerCallback<Item> = (events: ListenerEvent<Item>[]) => void;
 export type QueryListener<Item> = {
@@ -34,4 +39,8 @@ export type ListenerEvent<Item> = {
     item: null;
     id: string;
 };
+export type DataStorageChanges = {
+    store: string;
+    changes: StoreStateChange<any>[];
+};
 //# sourceMappingURL=data-storage.interface.d.ts.map

package/dist/data-storage/deep-merge.d.ts

@@ -0,0 +1,6 @@
+type DeepMergeable = {
+    [key: string]: any;
+};
+export declare function deepMerge<T extends DeepMergeable>(target: T, source: Partial<T>): T;
+export {};
+//# sourceMappingURL=deep-merge.d.ts.map

package/dist/data-storage/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./data-storage-forked";
 export * from "./data-storage-master";
-export * from "./data-storage.interface";
+export * from "./data-storage.abstract";
 export * from "./store-state-fork";
 export * from "./store-state-master";
 export * from "./store-state.abstract";

package/dist/data-storage/master-store-state.d.ts

@@ -1,17 +1,30 @@
 import type { QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.interface";
+import type { DataStorage } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
-export declare class MasterStoreState<Item extends {
+export declare class MasterStoreState<
+  Item extends {
     _id: string;
-}> extends StoreState<Item> {
-    protected items: Map<string, Item>;
-    protected isComplete: boolean;
-    constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
-    applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | undefined>;
-    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    private mergeWithLocalModifications;
-    private matchesIndex;
+  },
+> extends StoreState<Item> {
+  protected items: Map<string, Item>;
+  protected isComplete: boolean;
+  constructor(
+    storeName: string,
+    dataStorage: DataStorage,
+    deserialize?: (data: any) => Item
+  );
+  applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+  findById(
+    id: string,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item | undefined>;
+  findByIndex(
+    index: string,
+    data: any,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item[]>;
+  findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+  private mergeWithLocalModifications;
+  private matchesIndex;
 }
-//# sourceMappingURL=master-store-state.d.ts.map
+//# sourceMappingURL=master-store-state.d.ts.map

package/dist/data-storage/store-state-fork.d.ts

@@ -1,4 +1,4 @@
-import type { DataStorage, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
+import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
 export declare class ForkedStoreState<Item extends {
     _id: string;
@@ -7,6 +7,15 @@ export declare class ForkedStoreState<Item extends {
     protected changedItems: Map<string, Item | null>;
     changes: StoreStateChange<Item>[];
     constructor(storeName: string, dataStorage: DataStorage, master: StoreState<Item>, deserialize?: (data: any) => Item);
+    applyChangeAndReturnEvent(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+        event: ListenerEvent<Item>;
+    }>;
+    applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;

package/dist/data-storage/store-state-master.d.ts

@@ -1,4 +1,5 @@
-import type { DataStorage, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
+import type { ReadWriteTransaction } from "../db";
+import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
 export declare class MasterStoreState<Item extends {
     _id: string;
@@ -6,6 +7,15 @@ export declare class MasterStoreState<Item extends {
     private items;
     private isComplete;
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
+    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+        event: ListenerEvent<Item>;
+    }>;
+    applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;

package/dist/data-storage/store-state.abstract.d.ts

@@ -1,4 +1,4 @@
-import type { DataStorage, ListenerEvent, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
+import type { DataStorage, ListenerEvent, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { ForkedStoreState } from "./store-state-fork";
 export declare abstract class StoreState<Item extends {
     _id: string;
@@ -6,8 +6,12 @@ export declare abstract class StoreState<Item extends {
     storeName: string;
     protected dataStorage: DataStorage;
     protected deserialize?: ((data: any) => Item) | undefined;
-    protected listeners: Set<QueryListener<Item>>;
+    protected listeners: Map<QueryListenerCallback<Item>, QueryListener<Item>>;
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: ((data: any) => Item) | undefined);
+    abstract applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     abstract findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     abstract findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
@@ -15,8 +19,15 @@ export declare abstract class StoreState<Item extends {
     fork(): ForkedStoreState<Item>;
     set(item: Item): Promise<void>;
     remove(id: string): Promise<void>;
-    modify(id: string, data: Partial<Item>): Promise<void>;
-    unsubscribe(listener: QueryListener<Item>): void;
+    modify(id: string, data: Partial<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
+    mutate(id: string, editCallback: (item: Item) => Promise<void>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
+    unsubscribe(listener: QueryListenerCallback<Item>): void;
     protected notifyListeners(events: ListenerEvent<Item>[]): void;
 }
 //# sourceMappingURL=store-state.abstract.d.ts.map

package/dist/data-storage/store-state.d.ts

@@ -1,24 +1,39 @@
-import { ForkStoreState, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.interface";
-export declare abstract class StoreState<Item extends {
+import {
+  ForkStoreState,
+  QueryListener,
+  QueryListenerCallback,
+  StoreStateChange,
+} from "./data-storage";
+import type { DataStorage } from "./data-storage.abstract";
+export declare abstract class StoreState<
+  Item extends {
     _id: string;
-}> {
-    storeName: string;
-    protected dataStorage: DataStorage;
-    protected deserialize?: ((data: any) => Item) | undefined;
-    protected listeners: Set<QueryListener<Item>>;
-    protected indexQueryCache: Map<string, Item[]>;
-    constructor(storeName: string, dataStorage: DataStorage, deserialize?: ((data: any) => Item) | undefined);
-    abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    fork(): ForkStoreState<Item>;
-    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    set(item: Item): void;
-    remove(id: string): void;
-    modify(id: string, data: Partial<Item>): void;
-    unsubscribe(listener: QueryListener<Item>): void;
-    private notifyListeners;
-    private getAllLocalItems;
-    private mergeWithLocalModifications;
-    private matchesIndex;
+  },
+> {
+  storeName: string;
+  protected dataStorage: DataStorage;
+  protected deserialize?: ((data: any) => Item) | undefined;
+  protected listeners: Set<QueryListener<Item>>;
+  protected indexQueryCache: Map<string, Item[]>;
+  constructor(
+    storeName: string,
+    dataStorage: DataStorage,
+    deserialize?: ((data: any) => Item) | undefined
+  );
+  abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+  fork(): ForkStoreState<Item>;
+  findByIndex(
+    index: string,
+    data: any,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item[]>;
+  set(item: Item): void;
+  remove(id: string): void;
+  modify(id: string, data: Partial<Item>): void;
+  unsubscribe(listener: QueryListener<Item>): void;
+  private notifyListeners;
+  private getAllLocalItems;
+  private mergeWithLocalModifications;
+  private matchesIndex;
 }
-//# sourceMappingURL=store-state.d.ts.map
+//# sourceMappingURL=store-state.d.ts.map