@arcote.tech/arc 0.0.16 → 0.0.17

package/dist/collection/collection.d.ts

@@ -1,23 +1,22 @@
 import { ArcContextElement } from "../context/element";
 import type { ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
-import { objectUtil, type util } from "../utils";
+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>[];
@@ -25,19 +24,24 @@ 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>> extends ArcContextElement<{
+export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElement<{
     type: "delete";
-    item: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
 } | {
     type: "set";
-    item: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
 } | {
     type: "modify";
     from: CollectionItem<ArcCollection<Name, Id, Schema>>;
     to: CollectionItem<ArcCollection<Name, Id, Schema>>;
-    changes: objectUtil.simplify<Partial<util.FirstArgument<Schema["serialize"]>>>;
+    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;
@@ -58,7 +62,7 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
         [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;
@@ -76,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/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

@@ -14,8 +14,10 @@ declare class ArcContext<const C extends ArcContextElementAny[], const Cmds exte
     queryBuilder(): {
         [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
     };
-    commandContext(dataStorage: DataStorage, publishEvent: (event: any) => Promise<void>): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; };
-    commandsClient(dataStorage: DataStorage): CommandsClient<Cmds>;
+    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[], Commands<any>, any>;
 export type ElementEvents<Element extends ArcContextElementAny> = Element extends ArcContextElement<any> ? Element["$event"] : never;

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, ListenerEvent, 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;

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

@@ -1,5 +1,5 @@
 import type { ReadWriteTransaction } from "../db";
-import type { DataStorage, ListenerEvent, 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 MasterStoreState<Item extends {
     _id: string;

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,7 +6,7 @@ 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;
@@ -23,7 +23,11 @@ export declare abstract class StoreState<Item extends {
         from: Item | null;
         to: Item | null;
     }>;
-    unsubscribe(listener: QueryListener<Item>): void;
+    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

package/dist/elements/date.d.ts

@@ -2,7 +2,7 @@ import { ArcAbstract } from "./abstract";
 export declare class ArcDate extends ArcAbstract {
     constructor();
     parse(value: string | number | Date): Date;
-    serialize(value: Date): string;
+    serialize(value: Date): number;
     deserialize(value: string): Date;
 }
 export declare function date(): ArcDate;

package/dist/elements/index.d.ts

@@ -6,6 +6,7 @@ export * from "./id";
 export * from "./number";
 export * from "./object";
 export * from "./optional";
+export * from "./record";
 export * from "./string";
 export * from "./string-enum";
 //# sourceMappingURL=index.d.ts.map

package/dist/elements/object copy.d.ts

@@ -0,0 +1,29 @@
+import { objectUtil, type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+export declare type ArcRawShape = {
+    [k: string]: ArcElement;
+};
+export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract {
+    private rawShape;
+    constructor(rawShape: E);
+    parse(value: {
+        [key in keyof E]: util.FirstArgument<E[key]["parse"]>;
+    }): {
+        [key in keyof E]: ReturnType<E[key]["parse"]>;
+    };
+    serialize(value: {
+        [key in keyof E]: util.FirstArgument<E[key]["serialize"]>;
+    }): {
+        [key in keyof E]: ReturnType<E[key]["serialize"]>;
+    };
+    deserialize(value: objectUtil.addQuestionMarks<{
+        [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>;
+    }>): {
+        [key in keyof E]: ReturnType<E[key]["deserialize"]>;
+    };
+    deserializePath(path: string[], value: any): any;
+}
+export type ArcObjectAny = ArcObject<any>;
+export declare function object<E extends ArcRawShape>(element: E): ArcObject<E>;
+//# sourceMappingURL=object%20copy.d.ts.map

package/dist/elements/object.d.ts

@@ -23,6 +23,21 @@ export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract {
         [key in keyof E]: ReturnType<E[key]["deserialize"]>;
     };
     deserializePath(path: string[], value: any): any;
+    parsePartial(value: Partial<{
+        [key in keyof E]: util.FirstArgument<E[key]["parse"]>;
+    }>): {
+        [key in keyof E]: ReturnType<E[key]["parse"]>;
+    };
+    deserializePartial(value: Partial<{
+        [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>;
+    }>): {
+        [key in keyof E]: ReturnType<E[key]["deserialize"]>;
+    };
+    serializePartial(value: Partial<{
+        [key in keyof E]: util.FirstArgument<E[key]["serialize"]>;
+    }>): {
+        [key in keyof E]: ReturnType<E[key]["serialize"]>;
+    };
 }
 export type ArcObjectAny = ArcObject<any>;
 export declare function object<E extends ArcRawShape>(element: E): ArcObject<E>;

package/dist/elements/record.d.ts

@@ -0,0 +1,19 @@
+import { type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+import type { ArcId } from "./id";
+import type { ArcNumber } from "./number";
+import type { ArcString } from "./string";
+type ArcKey = ArcString | ArcNumber | ArcId<any>;
+export declare class ArcRecord<Key extends ArcKey, E extends ArcElement> extends ArcAbstract {
+    private key;
+    private element;
+    constructor(key: Key, element: E);
+    parse(value: Record<util.FirstArgument<Key["parse"]>, util.FirstArgument<E["parse"]>>): Record<ReturnType<Key["parse"]>, ReturnType<E["parse"]>>;
+    serialize(value: Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>): Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>;
+    deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
+}
+export type ArcRecordAny = ArcRecord<any, any>;
+export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E>;
+export {};
+//# sourceMappingURL=record.d.ts.map

package/dist/elements/state.d.ts

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

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from "./data-storage";
 export * from "./db";
 export * from "./elements";
 export * from "./rtc";
+export * from "./state";
 export * from "./utils";
 //# sourceMappingURL=index.d.ts.map