@arcote.tech/arc 0.0.16 → 0.0.17

package/dist/state/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./db";
 export * from "./state";
-export * from "./state-change";
+//# sourceMappingURL=index.d.ts.map

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

@@ -2,7 +2,8 @@ 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 collection;
-    constructor(collection: S);
+    private state;
+    constructor(state: S);
     toQuery(): ArcStateQuery<S>;
 }
+//# sourceMappingURL=query-builder.d.ts.map

package/dist/state/query.d.ts

@@ -1,22 +1,15 @@
-import { Subject } from "rxjs";
-import type { ArcQuery } from "../context/query";
-import type { DatabaseAdapter } from "../db";
-import { StateReadTransaction } from "./db";
-import type { ArcStateAny } from "./state";
-import type { StateChange } from "./state-change";
-import type { StateItem } from "./util";
-export declare class ArcStateQuery<State extends ArcStateAny> implements ArcQuery<StateItem<State>> {
+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;
-    result$: Subject<StateItem<State>>;
-    private resultQueue$?;
-    private subscriptions;
+    private bindedChangeHandler;
+    private store;
     constructor(state: State);
-    getLastResult(): StateItem<State>;
-    run(db: DatabaseAdapter, changes$: Subject<StateChange>): Promise<void>;
-    protected onChange(change: StateChange): any;
-    protected fetch(transaction: StateReadTransaction): Promise<ReturnType<State["deserialize"]> | undefined>;
-    private changeHandler;
+    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;
-    isUnsubscribed(): boolean;
 }
+//# sourceMappingURL=query.d.ts.map

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

@@ -11,3 +11,4 @@ export type StateChange = {
 export type StateEvent = Exclude<StateChange, {
     type: "mutate";
 }>;
+//# sourceMappingURL=state-change.d.ts.map

package/dist/state/state.d.ts

@@ -1,28 +1,32 @@
-import type { ArcContextElement } from "../context/element";
-import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import { ArcContextElement } from "../context/element";
+import type { DataStorage } from "../data-storage";
 import { type ArcObjectAny } from "../elements/object";
-import { objectUtil, type util } from "../utils";
+import { objectUtil, type DeepPartial, type util } from "../utils";
 import { ArcStateQueryBuilder } from "./query-builder";
-import type { StateChange, StateEvent } from "./state-change";
-import type { StateItem } from "./util";
-type StateCommandContext<State extends ArcStateAny> = {
-    context: {
-        get: () => StateItem<State>;
-    };
-    finalize: () => StateChange[];
-};
-export declare class ArcState<Name extends string, Schema extends ArcObjectAny> implements ArcContextElement<StateChange, StateEvent> {
+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"]>>>): {
-        [x: string]: any;
+        _id: Name;
     };
     deserialize(data: objectUtil.simplify<objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): ReturnType<Schema["deserialize"]>;
     queryBuilder(): ArcStateQueryBuilder<this>;
-    commandContext(transaction: ReadTransaction): StateCommandContext<this>;
-    applyChange(transaction: ReadWriteTransaction, change: StateChange, events: StateChange[]): Promise<void>;
+    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/state/util.d.ts

@@ -1,2 +1,3 @@
 import type { ArcStateAny } from "./state";
 export type StateItem<S extends ArcStateAny> = ReturnType<S["deserialize"]>;
+//# sourceMappingURL=util.d.ts.map

package/dist/utils/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/utils.d.ts

@@ -59,7 +59,16 @@ export type ContextTypes<Ctx extends {
         [Collection in Ctx["elements"][number] as `${Collection["name"]}.queryCollectionResult`]: Omit<QueryCollectionResult<Collection>, "result">;
     } : never;
 }[keyof Ctx["elements"]];
-export type infer<E extends {
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type $type<E extends {
     deserialize: (...args: any) => any;
 }> = ReturnType<E["deserialize"]>;
+export type $omit<E extends {
+    deserialize: (...args: any) => any;
+}, K extends keyof ReturnType<E["deserialize"]>> = objectUtil.addQuestionMarks<Omit<objectUtil.simplify<ReturnType<E["deserialize"]>>, K>>;
+export type $partial<E extends {
+    deserialize: (...args: any) => any;
+}, K extends keyof ReturnType<E["deserialize"]> = never> = DeepPartial<objectUtil.addQuestionMarks<Omit<objectUtil.simplify<ReturnType<E["deserialize"]>>, K>>>;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "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.",