@vorplex/core 0.0.46 → 0.0.49

package/dist/index.d.ts

@@ -56,6 +56,7 @@ export * from './modules/reflection/types/type.type';
 export * from './modules/reflection/utils/decorator.util';
 export * from './modules/reflection/utils/reflection.util';
 export * from './modules/router/router.util';
+export * from './modules/state/reducer.type';
 export * from './modules/state/state.model';
 export * from './modules/state/update.type';
 export * from './modules/state/adaptors/array/array-adaptor.util';

package/dist/index.js

@@ -57,6 +57,7 @@ export * from './modules/reflection/types/type.type';
 export * from './modules/reflection/utils/decorator.util';
 export * from './modules/reflection/utils/reflection.util';
 export * from './modules/router/router.util';
+export * from './modules/state/reducer.type';
 export * from './modules/state/state.model';
 export * from './modules/state/update.type';
 export * from './modules/state/adaptors/array/array-adaptor.util';

package/dist/modules/state/reducer.type.d.ts

@@ -0,0 +1,30 @@
+import { ArrayAdaptor } from './adaptors/array/array-adaptor.util';
+import { EntityAdaptor } from './adaptors/entity/entity-adaptor.util';
+import { EntityMap } from './adaptors/entity/entity-map.type';
+import { IEntity } from './adaptors/entity/entity.interface';
+import { Update } from './update.type';
+type EntityItem<V> = V extends EntityMap<infer U> ? U : never;
+type ArrayItem<V> = V extends (infer U)[] ? U : never;
+type FieldOf<TClass, K> = K extends keyof TClass ? TClass[K] : {};
+type ReducerFieldAdaptor<TState, TReducer extends Reducer, K extends keyof TState> = TState[K] extends EntityMap<IEntity> ? {
+    entity: EntityAdaptor<TState, EntityItem<TState[K]>, K & any>;
+} & FieldOf<TReducer, K> : TState[K] extends any[] ? {
+    array: ArrayAdaptor<TState, ArrayItem<TState[K]>, K & any>;
+} & FieldOf<TReducer, K> : {
+    value: {
+        set: (value: TState[K]) => Update<TState>;
+    };
+} & FieldOf<TReducer, K>;
+type StateFields<TState, TReducer extends Reducer> = {
+    [K in keyof TState]: ReducerFieldAdaptor<TState, TReducer, K>;
+};
+export type ReducerFields<TState> = {
+    update: {
+        <V>(path: (state: TState) => V, fn: (value: V) => Partial<V>): Update<TState>;
+        <V>(path: (state: TState) => V, value: Partial<V>): Update<TState>;
+    };
+};
+export type EmptyReducer = Record<never, never>;
+export type Reducer = Record<string, any>;
+export type StateReducer<TState, TReducer extends Reducer> = ReducerFields<TState> & StateFields<TState, TReducer>;
+export {};

package/dist/modules/state/state.model.d.ts

@@ -1,17 +1,13 @@
-import type { Constructor } from '../reflection/types/constructor.type';
 import { Subscribable } from '../subscribable/subscribable.model';
 import type { Subscription } from '../subscribable/subscription.interface';
-import { ArrayAdaptor } from './adaptors/array/array-adaptor.util';
-import { EntityAdaptor } from './adaptors/entity/entity-adaptor.util';
-import type { EntityMap } from './adaptors/entity/entity-map.type';
-import type { IEntity } from './adaptors/entity/entity.interface';
+import { EmptyReducer, Reducer, StateReducer } from './reducer.type';
 import type { Update } from './update.type';
 export interface StateChange<T> {
     previousValue: T;
     value: T;
 }
 export type StateEffect<T> = (value: T) => T;
-export declare class State<T = any, TReducer extends Constructor = Constructor> extends Subscribable<StateChange<T>> {
+export declare class State<T = any, TReducer extends Reducer = EmptyReducer> extends Subscribable<StateChange<T>> {
     private reducer?;
     private _value;
     get value(): T;
@@ -19,22 +15,7 @@ export declare class State<T = any, TReducer extends Constructor = Constructor>
     static combineLatest<T extends any[]>(states: {
         [K in keyof T]: State<T[K]>;
     }, callback: (values: T) => void): Subscription;
-    reduce(update: (reducer: {
-        update: {
-            <V>(path: (state: T) => V, update: (value: V) => Partial<V>): Update<T>;
-            <V>(path: (state: T) => V, value: Partial<V>): Update<T>;
-        };
-    } & {
-        [K in keyof T]: T[K] extends EntityMap<IEntity> ? {
-            entity: EntityAdaptor<T, T[K] extends EntityMap<infer U> ? U : never, K & any>;
-        } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {}) : T[K] extends any[] ? {
-            array: ArrayAdaptor<T, T[K] extends (infer U)[] ? U : never, K & any>;
-        } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {}) : {
-            value: {
-                set: (value: T[K]) => Update<T> & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {});
-            } & (K extends keyof InstanceType<TReducer> ? InstanceType<TReducer>[K & keyof InstanceType<TReducer>] : {});
-        };
-    }) => Update<T>[]): void;
+    reduce(update: (reducer: StateReducer<T, TReducer>) => Update<T>[]): void;
     subscribe(emit: (event: StateChange<T>, subscription: Subscription) => void): Subscription;
     static update<TState>(state: TState, ...updates: Update<TState>[]): TState;
     update(...updates: Update<T>[]): void;

package/dist/modules/state/state.model.js

@@ -42,11 +42,12 @@ export class State extends Subscribable {
         };
     }
     reduce(update) {
-        const reducer = new Proxy({
+        const reducerFields = {
             update: (path, update) => {
                 return (state) => $Value.update(state, path, update);
-            },
-        }, {
+            }
+        };
+        const reducer = new Proxy(reducerFields, {
             get: (target, property) => {
                 if (property === 'update')
                     return target.update;
@@ -59,7 +60,7 @@ export class State extends Subscribable {
                         }),
                     },
                 };
-                Object.assign(reducer, (this.reducer && new this.reducer()[property]) || {});
+                Object.assign(reducer, this.reducer?.[property] ?? {});
                 return reducer;
             },
         });

package/dist/modules/tson/schemas/array.js

@@ -63,16 +63,16 @@ export class TsonArray extends TsonSchemaBase {
             throw new TsonError(`Array min length of ${this.definition.min} expected`, value, this);
         if (this.definition.max != null && value.length > this.definition.max)
             throw new TsonError(`Array max length of ${this.definition.max} expected`, value, this);
-        if (this.definition.itemDefinition) {
-            for (const [index, item] of value.entries()) {
-                try {
-                    result[index] = $Tson.parse(this.definition.itemDefinition).parse(item);
-                }
-                catch (error) {
-                    if (!(error instanceof TsonError))
-                        throw error;
-                    throw new TsonError(`Invalid item in array. ${error.message}`, item, this, `[${index}]${error.path}`);
-                }
+        if (!this.definition.itemDefinition)
+            return [...value];
+        for (const [index, item] of value.entries()) {
+            try {
+                result[index] = $Tson.parse(this.definition.itemDefinition).parse(item);
+            }
+            catch (error) {
+                if (!(error instanceof TsonError))
+                    throw error;
+                throw new TsonError(`Invalid item in array. ${error.message}`, item, this, `[${index}]${error.path}`);
             }
         }
         return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/core",
-  "version": "0.0.46",
+  "version": "0.0.49",
   "type": "module",
   "sideEffects": false,
   "files": [