@arcote.tech/arc 0.0.27 → 0.1.2

package/dist/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./model";
+//# sourceMappingURL=index.d.ts.map

package/dist/model/model.d.ts

@@ -1,40 +1,46 @@
-import { Subject } from "rxjs";
-import type { CommandsClient } from "../context/commands";
-import { type ArcContextChanges, type ArcContextWithCommandsAny } from "../context/context";
-import type { ArcContextElementAny } from "../context/element";
-import type { ArcQuery } from "../context/query";
-import type { QueryFactoryFunction } from "../context/query-builders";
-import type { DatabaseAdapter, DBAdapterFactory, ReadWriteTransaction } from "../db";
-import type { RealTimeCommunicationAdapter, RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
-export interface IArcModel<C extends ArcContextWithCommandsAny> {
-    readonly context: C;
-    changes$: Subject<ArcContextChanges<C>>;
-    query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
-    commands(): CommandsClient<C["commands"]>;
-    getContextElement(name: string): ArcContextElementAny;
-    applyChanges(changes: ArcContextChanges<C>[]): Promise<void>;
+import { type ArcContextAny, type IArcQueryBuilder } from "../context";
+import { type DataStorage } from "../data-storage";
+type UnaryFunction<T, R> = (input: T) => R;
+export declare abstract class ModelBase<C extends ArcContextAny> {
+    abstract query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    abstract subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+        result: ReturnType<Q["toQuery"]>["lastResult"];
+        unsubscribe: () => void;
+    };
+    abstract commands(): ReturnType<C["commandsClient"]>;
 }
-export declare class ArcModel<C extends ArcContextWithCommandsAny> implements IArcModel<C> {
-    readonly context: C;
-    rtc: RealTimeCommunicationAdapter<C>;
-    dbAdapterPromise: Promise<DatabaseAdapter>;
-    changes$: Subject<ArcContextChanges<C>>;
-    constructor(context: C, dbAdapterFactory: DBAdapterFactory, rtcAdapterFactory: RealTimeCommunicationAdapterFactory<C>);
-    query(queryFactory: QueryFactoryFunction<C>): import("..").ArcQueryAny;
-    private runQuery;
-    commands(): CommandsClient<C["commands"]>;
-    executeCommand(command: C["commands"][string], ...args: any[]): Promise<{
-        changes: any;
-        result: any;
-    }>;
-    applyChangesForTransaction(transaction: ReadWriteTransaction, changes: ArcContextChanges<C>[]): Promise<void>;
-    private notifyChange;
-    applyChanges(changes: ArcContextChanges<C>[]): Promise<void>;
-    getContextElement(name: string): any;
+export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
+    private readonly context;
+    private readonly dataStorage;
+    private readonly client;
+    private readonly catchErrorCallback;
+    private queryCache;
+    constructor(context: C, dataStorage: DataStorage, client: string, catchErrorCallback: (error: any) => void);
+    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+        result: ReturnType<Q["toQuery"]>["lastResult"];
+        unsubscribe: () => void;
+    };
+    commands(): ReturnType<C["commandsClient"]>;
+    fork(): ForkedModel<C>;
+    get $debug(): {};
 }
-export type ArcModelAny = ArcModel<ArcContextWithCommandsAny>;
-export type ArcModelDependencies<C extends ArcContextWithCommandsAny> = {
-    dbAdapterFactory: DBAdapterFactory;
-    rtcAdapterFactory: RealTimeCommunicationAdapterFactory<C>;
-};
-export declare function model<C extends ArcContextWithCommandsAny>(context: C, dependencies: ArcModelDependencies<C>): ArcModel<C>;
+export declare class ForkedModel<C extends ArcContextAny> extends Model<C> {
+    constructor(context: C, dataStorage: DataStorage, client: string, catchErrorCallback: (error: any) => void);
+    merge(): void;
+}
+export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBase<C> {
+    private readonly context;
+    private readonly apiBaseUrl;
+    private readonly client;
+    private readonly catchErrorCallback;
+    constructor(context: C, apiBaseUrl: string, client: string, catchErrorCallback: (error: any) => void);
+    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+        result: ReturnType<Q["toQuery"]>["lastResult"];
+        unsubscribe: () => void;
+    };
+    commands(): ReturnType<C["commandsClient"]>;
+}
+export {};
+//# sourceMappingURL=model.d.ts.map

package/dist/state/query-builder.d.ts

@@ -1,9 +1,2 @@
-import { ArcQueryBuilder } from "../context/query-builders";
-import { ArcStateQuery } from "./query";
-import type { ArcStateAny } from "./state";
-export declare class ArcStateQueryBuilder<S extends ArcStateAny> extends ArcQueryBuilder {
-    private state;
-    constructor(state: S);
-    toQuery(): ArcStateQuery<S>;
-}
+export {};
 //# sourceMappingURL=query-builder.d.ts.map

package/dist/state/query.d.ts

@@ -1,15 +1,2 @@
-import { ArcQuery, type ArcQueryListener } from "../context/query";
-import type { DataStorage, ListenerEvent } from "../data-storage";
-import type { ArcStateAny, StateItem } from "./state";
-export declare class ArcStateQuery<State extends ArcStateAny> extends ArcQuery<StateItem<State>> {
-    protected state: State;
-    private bindedChangeHandler;
-    private store;
-    constructor(state: State);
-    run(dataStorage: DataStorage, listener?: ArcQueryListener<StateItem<State>>): Promise<ReturnType<State["deserialize"]> extends infer T ? { [KeyType in keyof T]: ReturnType<State["deserialize"]>[KeyType]; } : never>;
-    protected onChange(change: ListenerEvent<StateItem<State>>): false | (ReturnType<State["deserialize"]> extends infer T ? { [KeyType in keyof T]: ReturnType<State["deserialize"]>[KeyType]; } : never);
-    protected changeHandler(changes: ListenerEvent<StateItem<State>>[]): void;
-    unsubscribe(): void;
-    private nextResult;
-}
+export {};
 //# sourceMappingURL=query.d.ts.map

package/dist/state/state.d.ts

@@ -1,32 +1,2 @@
-import { ArcContextElement } from "../context/element";
-import type { DataStorage } from "../data-storage";
-import { type ArcObjectAny } from "../elements/object";
-import { objectUtil, type DeepPartial, type util } from "../utils";
-import { ArcStateQueryBuilder } from "./query-builder";
-export type StateItem<S extends ArcStateAny> = objectUtil.simplify<ReturnType<S["deserialize"]>>;
-export type StateItemWithId<S extends ArcStateAny> = objectUtil.simplify<{
-    _id: string;
-} & ReturnType<S["deserialize"]>>;
-export declare class ArcState<Name extends string, Schema extends ArcObjectAny> extends ArcContextElement<{
-    type: "modify";
-    from: StateItem<ArcState<Name, Schema>>;
-    to: StateItem<ArcState<Name, Schema>>;
-    changes: objectUtil.simplify<Partial<util.FirstArgument<Schema["serialize"]>>>;
-}> {
-    readonly name: Name;
-    readonly schema: Schema;
-    constructor(name: Name, schema: Schema);
-    serialize(data: objectUtil.simplify<objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): {
-        _id: Name;
-    };
-    deserialize(data: objectUtil.simplify<objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): ReturnType<Schema["deserialize"]>;
-    queryBuilder(): ArcStateQueryBuilder<this>;
-    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): {
-        get: () => Promise<StateItem<ArcState<Name, Schema>>>;
-        modify: (data: DeepPartial<StateItem<ArcState<Name, Schema>>>) => Promise<void>;
-        edit: (editCallback: (item: StateItem<ArcState<Name, Schema>>) => Promise<void> | void) => Promise<void>;
-    };
-}
-export type ArcStateAny = ArcState<any, any>;
-export declare function state<Name extends string, Schema extends ArcObjectAny>(name: Name, schema: Schema): ArcState<Name, Schema>;
+export {};
 //# sourceMappingURL=state.d.ts.map

package/dist/tests/context/context.test.d.ts

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

package/dist/tests/pipe.d.ts

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

package/dist/tests/query/advance-query.test.d.ts

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

package/dist/tests/query/collection-all.test.d.ts

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

package/dist/tests/utils/expect-not-false.d.ts

@@ -0,0 +1,2 @@
+export declare function expectNotFalse<T>(value: T | false): asserts value is T;
+//# sourceMappingURL=expect-not-false.d.ts.map

package/dist/tests/utils/sqlite-adapter.d.ts

@@ -0,0 +1,3 @@
+import { type DBAdapterFactory } from "../../index";
+export declare const sqliteAdapterFactory: (dbName: string) => DBAdapterFactory;
+//# sourceMappingURL=sqlite-adapter.d.ts.map

package/dist/tests/utils/test-model.d.ts

@@ -0,0 +1,26 @@
+import type { ArcContextAny } from "../../context/context";
+import { type DataStorageChanges } from "../../data-storage";
+import { Model } from "../../model";
+import type { RealTimeCommunicationAdapter } from "../../rtc";
+export declare class TestRTCAdapter implements RealTimeCommunicationAdapter {
+    private syncCalls;
+    private commitCalls;
+    commitChanges(changes: DataStorageChanges[]): void;
+    sync(progressCallback: ({ store, size, }: {
+        store: string;
+        size: number;
+    }) => void): Promise<void>;
+    getSyncCalls(): {
+        store: string;
+        size: number;
+    }[];
+    getCommitCalls(): DataStorageChanges[][];
+    clearHistory(): void;
+}
+export declare function testModel<C extends ArcContextAny>(arcContext: C): {
+    model: Model<C>;
+    getRTCAdapter(): TestRTCAdapter;
+    fork(): import("../..").ForkedModel<C>;
+    clearRTCHistory(): void;
+};
+//# sourceMappingURL=test-model.d.ts.map

package/dist/tests/validations/array.test.d.ts

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

package/dist/tests/validations/date.test.d.ts

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

package/dist/tests/validations/record.test.d.ts

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

package/dist/tests/validations/string-enum.test.d.ts

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

package/dist/utils/arcObjectToStoreSchema.d.ts

@@ -0,0 +1,4 @@
+import type { StoreSchema } from "../context/element";
+import { ArcObject } from "../elements";
+export declare function arcObjectToStoreSchema(tableName: string, schema: ArcObject<any>): StoreSchema;
+//# sourceMappingURL=arcObjectToStoreSchema.d.ts.map

package/dist/utils/murmur-hash.d.ts

@@ -0,0 +1,2 @@
+export declare function murmurHash(key: string, seed?: number): number;
+//# sourceMappingURL=murmur-hash.d.ts.map

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import type { ArcCollectionAny, ArcIndexedCollectionAny, CollectionItem } from "./collection/collection";
-import type { QueryCollectionResult } from "./collection/queries/abstract-many-items";
+import type { ArcCollectionAny, CollectionItem } from "./collection/collection";
+import type { QueryCollectionResult } from "./collection/queries/find";
 import type { ArcElement } from "./elements/element";
 export declare namespace objectUtil {
     export type MergeShapes<U, V> = {
@@ -42,12 +42,12 @@ export declare namespace objectUtil {
 export declare namespace util {
     type FirstArgument<T> = T extends (arg: infer U, ...args: any[]) => any ? U : never;
     type GetType<Element extends ArcElement> = ReturnType<Element["deserialize"]>;
-    type CollectionItemWithId<C extends ArcCollectionAny | ArcIndexedCollectionAny> = ReturnType<C["deserialize"]>;
+    type CollectionItemWithId<C extends ArcCollectionAny> = ReturnType<C["deserialize"]>;
 }
 export type ContextTypes<Ctx extends {
     elements: any[];
 }> = {
-    [key in keyof Ctx["elements"]]: Ctx["elements"][key] extends ArcCollectionAny | ArcIndexedCollectionAny ? {
+    [key in keyof Ctx["elements"]]: Ctx["elements"][key] extends ArcCollectionAny ? {
         [Collection in Ctx["elements"][number] as `${Collection["name"]}.bodyWithoutId`]: util.GetType<Collection["schema"]>;
     } & {
         [Collection in Ctx["elements"][number] as `${Collection["name"]}.setBody`]: objectUtil.addQuestionMarks<util.FirstArgument<Collection["schema"]["parse"]>>;

package/dist/view/view.d.ts

@@ -0,0 +1,49 @@
+import { ArcContextElementWithStore, type ArcContextElementAny, type StoreSchema } from "../context/element";
+import type { QueryBuilderContext } from "../context/query-builder-context";
+import type { DataStorage } from "../data-storage";
+import type { FindOptions } from "../data-storage/types";
+import { type ArcIdAny, type ArcObjectAny } from "../elements";
+import type { $type } from "../utils";
+type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
+type ArcViewHandlerContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    modify: (id: $type<Id>, data: $type<Schema>) => Promise<void>;
+    set: (id: $type<Id>, data: $type<Schema>) => Promise<void>;
+    remove: (id: $type<Id>) => Promise<void>;
+    find: (options: FindOptions<ArcViewItem<Id, Schema>>) => Promise<ArcViewItem<Id, Schema>[]>;
+    findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => Promise<ArcViewItem<Id, Schema> | undefined>;
+};
+type ArcViewItem<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    _id: $type<Id>;
+} & $type<Schema>;
+type ArcViewHandler<Elements extends ArcContextElementAny[], Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    [Event in GetEvents<Elements> as Event["type"]]: (ctx: ArcViewHandlerContext<Id, Schema>, event: Event) => Promise<void>;
+};
+export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, const Elements extends ArcContextElementAny[]> extends ArcContextElementWithStore<null, Name> {
+    readonly name: Name;
+    readonly id: Id;
+    readonly schema: Schema;
+    private _description?;
+    private _elements?;
+    private _handler?;
+    constructor(name: Name, id: Id, schema: Schema);
+    storeSchema: () => StoreSchema;
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcView<Name, Id, Schema, E>;
+    description(description: string): ArcView<Name, Id, Schema, Elements>;
+    handle<Handler extends ArcViewHandler<Elements, Id, Schema>>(handler: Handler): ArcView<Name, Id, Schema, Elements>;
+    queryBuilder: (context: QueryBuilderContext) => {
+        readonly find: (options?: FindOptions<$type<Schema>>) => never;
+    };
+    commandContext: (dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>) => {
+        readonly find: (options: FindOptions<ArcViewItem<Id, Schema>>) => Promise<{
+            _id: string;
+        }[]>;
+        readonly findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => Promise<{
+            _id: string;
+        }>;
+    };
+    observer: () => Record<string, any>;
+    private clone;
+}
+export declare function view<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcView<Name, Id, Schema, any[]>;
+export {};
+//# sourceMappingURL=view.d.ts.map

package/package.json

@@ -1,13 +1,20 @@
 {
   "name": "@arcote.tech/arc",
-  "module": "index.ts",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.27",
+  "version": "0.1.2",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
     "build": "bun build --target=node ./index.ts --outfile=dist/index.js --external rxjs --external mutative && bun run build:declaration",
     "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json --declarationMap",

package/dist/collection/collection-change.d.ts

@@ -1,18 +0,0 @@
-import type { Patches } from "mutative";
-export type CollectionChange = {
-    collection: string;
-} & ({
-    type: "set";
-    body: any;
-} | {
-    type: "delete";
-    id: string;
-} | {
-    type: "mutate";
-    id: string;
-    patches: Patches<any>;
-});
-export type CollectionChangesWithoutMutate = Exclude<CollectionChange, {
-    type: "mutate";
-}>;
-//# sourceMappingURL=collection-change.d.ts.map

package/dist/collection/db.d.ts

@@ -1,17 +0,0 @@
-import type { ReadTransaction, ReadWriteTransaction } from "../db/interface";
-import type { util } from "../utils";
-import type { ArcCollectionAny, ArcIndexedCollectionAny } from "./collection";
-export declare class CollectionReadTransaction {
-    protected dbTransaction: ReadTransaction;
-    constructor(dbTransaction: ReadTransaction);
-    findById<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<ReturnType<C["deserialize"]> | undefined>;
-    findByIndex<C extends ArcIndexedCollectionAny>(collection: C, index: string, data: any): Promise<ReturnType<C["deserialize"]>[]>;
-    findAll<C extends ArcCollectionAny>(collection: C): Promise<ReturnType<C["deserialize"]>[]>;
-}
-export declare class CollectionReadWriteTransaction extends CollectionReadTransaction {
-    protected dbTransaction: ReadWriteTransaction;
-    constructor(dbTransaction: ReadWriteTransaction);
-    remove<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<void>;
-    set<C extends ArcCollectionAny>(collection: C, data: util.CollectionItemWithId<C>): Promise<void>;
-    commit(): Promise<void>;
-}

package/dist/collection/queries/all-items.d.ts

@@ -1,7 +0,0 @@
-import type { StoreState } from "../../data-storage";
-import { type ArcCollectionAny, type CollectionItem } from "../collection";
-import { ArcManyItemsQuery } from "./abstract-many-items";
-export declare class ArcAllItemsQuery<Collection extends ArcCollectionAny> extends ArcManyItemsQuery<Collection> {
-    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
-}
-//# sourceMappingURL=all-items.d.ts.map

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

@@ -1,13 +0,0 @@
-import type { StoreState } from "../../data-storage";
-import type { ArcIndexedCollectionAny, CollectionItem } from "../collection";
-import { ArcManyItemsQuery } from "./abstract-many-items";
-export declare class ArcIndexedItemsQuery<Collection extends ArcIndexedCollectionAny> extends ArcManyItemsQuery<Collection> {
-    private index;
-    private data;
-    protected filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined;
-    protected sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined;
-    constructor(collection: Collection, index: string, data: any, filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined, sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined);
-    protected checkItem(item: CollectionItem<Collection>): boolean;
-    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
-}
-//# sourceMappingURL=indexed.d.ts.map

package/dist/collection/query-builders/abstract-many-items.d.ts

@@ -1,11 +0,0 @@
-import { ArcQueryBuilder } from "../../context/query-builders";
-import { type ArcCollectionAny, type CollectionItem } from "../collection";
-type SortComparator<C extends ArcCollectionAny> = ((a: CollectionItem<C>, b: CollectionItem<C>) => number) | Array<[keyof CollectionItem<C>, "ASC" | "DESC"]>;
-export declare abstract class ArcManyItemsQueryBuilder<C extends ArcCollectionAny> extends ArcQueryBuilder {
-    protected filterFn?: (item: CollectionItem<C>) => boolean;
-    protected sortFn?: (a: CollectionItem<C>, b: CollectionItem<C>) => number;
-    filter(callback: (item: CollectionItem<C>) => boolean): this;
-    sort(comparator: SortComparator<C>): this;
-}
-export {};
-//# sourceMappingURL=abstract-many-items.d.ts.map

package/dist/collection/query-builders/all-items.d.ts

@@ -1,9 +0,0 @@
-import { type ArcCollectionAny } from "../collection";
-import { ArcAllItemsQuery } from "../queries/all-items";
-import { ArcManyItemsQueryBuilder } from "./abstract-many-items";
-export declare class ArcAllItemsQueryBuilder<C extends ArcCollectionAny> extends ArcManyItemsQueryBuilder<C> {
-    private collection;
-    constructor(collection: C);
-    toQuery(): ArcAllItemsQuery<C>;
-}
-//# sourceMappingURL=all-items.d.ts.map

package/dist/collection/query-builders/indexed.d.ts

@@ -1,11 +0,0 @@
-import type { ArcIndexedCollectionAny } from "../collection";
-import { ArcIndexedItemsQuery } from "../queries/indexed";
-import { ArcManyItemsQueryBuilder } from "./abstract-many-items";
-export declare class ArcIndexedItemsQueryBuilder<C extends ArcIndexedCollectionAny> extends ArcManyItemsQueryBuilder<C> {
-    private collection;
-    private index;
-    private data;
-    constructor(collection: C, index: string, data: any);
-    toQuery(): ArcIndexedItemsQuery<C>;
-}
-//# sourceMappingURL=indexed.d.ts.map

package/dist/collection/query-builders/one-item.d.ts

@@ -1,11 +0,0 @@
-import { ArcQueryBuilder } from "../../context/query-builders";
-import type { util } from "../../utils";
-import type { ArcCollectionAny } from "../collection";
-import { ArcOneItemQuery } from "../queries/one-item";
-export declare class ArcOneItemQueryBuilder<C extends ArcCollectionAny> extends ArcQueryBuilder {
-    private collection;
-    private id;
-    constructor(collection: C, id: util.GetType<C["id"]>);
-    toQuery(): ArcOneItemQuery<C>;
-}
-//# sourceMappingURL=one-item.d.ts.map

package/dist/collection/utils/index-query.d.ts

@@ -1,6 +0,0 @@
-import { IndexQueryArgument } from "./interface";
-export declare function indexQueryPredicate<T>(
-  item: T,
-  query: IndexQueryArgument<any>,
-): boolean;
-//# sourceMappingURL=index-query.d.ts.map

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

@@ -1,11 +0,0 @@
-import type { ReadTransaction, ReadWriteTransaction } from "../db";
-import type { ForkedDataStorage, StoreState } from "./data-storage";
-export interface DataStorage {
-    getStore<Item extends {
-        _id: string;
-    }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
-    fork(): ForkedDataStorage;
-    getReadTransaction(): Promise<ReadTransaction>;
-    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
-}
-//# sourceMappingURL=DataStorage.d.ts.map

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

@@ -1,32 +0,0 @@
-import type { QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.abstract";
-import type { MasterStoreState } from "./store-state-master";
-import { StoreState } from "./store-state.abstract";
-export declare class ForkStoreState<
-  Item extends {
-    _id: string;
-  },
-> extends StoreState<Item> {
-  master: MasterStoreState<Item>;
-  protected changedItems: Map<string, Item>;
-  changes: StoreStateChange<Item>[];
-  constructor(
-    storeName: string,
-    dataStorage: DataStorage,
-    master: MasterStoreState<Item>,
-    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 matchesIndex;
-}
-//# sourceMappingURL=ForkStoreState.d.ts.map

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

@@ -1,39 +0,0 @@
-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;
-}
-//# sourceMappingURL=StoreState.d.ts.map

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

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

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

@@ -1,46 +0,0 @@
-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>;
-}
-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.interface.d.ts.map

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

@@ -1,30 +0,0 @@
-import type { QueryListenerCallback, StoreStateChange } from "./data-storage";
-import type { DataStorage } from "./data-storage.abstract";
-import { StoreState } from "./store-state.abstract";
-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;
-}
-//# sourceMappingURL=master-store-state.d.ts.map