as-model 0.1.20 → 0.1.22

package/dist/index.js

@@ -604,10 +604,14 @@
       updater.mutate(function(u, effect) {
         var _args_model;
         var model2 = (_args_model = args.model) !== null && _args_model !== void 0 ? _args_model : u.model;
-        var state = "state" in args ? args.state : u.state;
+        var hasState = Object.prototype.hasOwnProperty.call(args, "state");
+        var hasInitialState = Object.prototype.hasOwnProperty.call(args, "initialState");
+        var state = hasState ? args.state : u.state;
+        var isInitialize = !u.initialized || hasInitialState;
         var token = createToken();
         if (u.controlled) {
-          var instance = model2(state);
+          var controlledState = hasInitialState && !hasState ? args.initialState : state;
+          var instance = model2(controlledState);
           return _object_spread_props(_object_spread({}, u), {
             state,
             instance,
@@ -620,8 +624,9 @@
         if (!u.initialized && !("state" in args)) {
           throw new Error("The updater has not been initialized, it should be updated with a state for initializing.");
         }
-        if (!u.initialized) {
-          var instance1 = model2(state);
+        if (isInitialize) {
+          var initialState = hasInitialState ? args.initialState : state;
+          var instance1 = model2(initialState);
           var initializedUpdater = createInitializedUpdater(u, middleWare);
           return _object_spread(_object_spread_props(_object_spread({}, u), {
             model: model2,
@@ -1194,7 +1199,7 @@
       getInstance,
       update: function update(args) {
         var updateArgs = args !== null && args !== void 0 ? args : {};
-        if ("key" in updateArgs && updateArgs.key) {
+        if (updateArgs.key) {
           var updatingKey = updateArgs.key, updatingModel = updateArgs.model, rest = _object_without_properties(updateArgs, [
             "key",
             "model"
@@ -1205,7 +1210,7 @@
           store.key = updatingKey;
           return;
         }
-        if ("model" in updateArgs && updateArgs.model) {
+        if (updateArgs.model) {
           var updatingKey1 = updateArgs.key, updatingModel1 = updateArgs.model, rest1 = _object_without_properties(updateArgs, [
             "key",
             "model"

package/esm/store/index.js

@@ -103,13 +103,13 @@ function createStore(modelLike, config = {}) {
     getInstance,
     update(args) {
       const updateArgs = args != null ? args : {};
-      if ("key" in updateArgs && updateArgs.key) {
+      if (updateArgs.key) {
         const _a = updateArgs, { key: updatingKey, model: updatingModel } = _a, rest = __objRest(_a, ["key", "model"]);
         updater.update(__spreadProps(__spreadValues({}, rest), { model: updatingKey.source }));
         store.key = updatingKey;
         return;
       }
-      if ("model" in updateArgs && updateArgs.model) {
+      if (updateArgs.model) {
         const _b = updateArgs, { key: updatingKey, model: updatingModel } = _b, rest = __objRest(_b, ["key", "model"]);
         updater.update(__spreadProps(__spreadValues({}, rest), { model: updatingModel }));
         store.key = createPrimaryKey(updatingModel, config);

package/esm/updater/index.js

@@ -37,10 +37,17 @@ function createUpdateFn(updater, middleWare) {
     updater.mutate((u, effect) => {
       var _a;
       const model = (_a = args.model) != null ? _a : u.model;
-      const state = "state" in args ? args.state : u.state;
+      const hasState = Object.prototype.hasOwnProperty.call(args, "state");
+      const hasInitialState = Object.prototype.hasOwnProperty.call(
+        args,
+        "initialState"
+      );
+      const state = hasState ? args.state : u.state;
+      const isInitialize = !u.initialized || hasInitialState;
       const token = createToken();
       if (u.controlled) {
-        const instance = model(state);
+        const controlledState = hasInitialState && !hasState ? args.initialState : state;
+        const instance = model(controlledState);
         return __spreadProps(__spreadValues({}, u), { state, instance, model });
       }
       if (u.isDestroyed) {
@@ -51,8 +58,9 @@ function createUpdateFn(updater, middleWare) {
           "The updater has not been initialized, it should be updated with a state for initializing."
         );
       }
-      if (!u.initialized) {
-        const instance = model(state);
+      if (isInitialize) {
+        const initialState = hasInitialState ? args.initialState : state;
+        const instance = model(initialState);
         const initializedUpdater = createInitializedUpdater(u, middleWare);
         return __spreadValues(__spreadProps(__spreadValues({}, u), {
           model,

package/index.d.ts

@@ -1,310 +1,311 @@
-declare interface ModelInstance {
-  [key: string]: any;
-  [key: number]: any;
-}
-
-export declare type FieldStructure<R = any> = {
-  callback: () => R;
-  deps: any[] | undefined;
-  identifier: (d: any) => d is FieldStructure<R>;
-  value: R;
-  get: () => R;
-};
-
-export declare type MethodStructure<
-  R extends (...args: any[]) => any = (...args: any[]) => any
-> = R & {
-  identifier: (d: any) => d is MethodStructure;
-};
-
-declare type ValidInstance<S, T extends ModelInstance> = {
-  [K in keyof T]: T[K] extends
-    | ((...args: any[]) => S)
-    | (((...args: any[]) => any) & { identifier: (d: any) => boolean })
-    ? T[K]
-    : T[K] extends (...args: any[]) => any
-      ? never
-      : T[K];
-};
-
-export declare type Model<S, T extends ModelInstance> = (
-  state: S
-) => ValidInstance<S, T>;
-
-export declare type Action<S = any, T extends ModelInstance = ModelInstance> = {
-  type: null | string;
-  method: null | ((...args: any[]) => any);
-  params?: any[];
-  state: S;
-  prevState?: S;
-  instance: T;
-  prevInstance?: T;
-};
-
-export interface Token {
-  isDifferent: (token: Token) => boolean;
-  value: unknown;
-}
-
-export declare type Dispatch = (action: Action) => any;
-
-export declare interface Key<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> extends Model<S, T> {
-  (s: S): T;
-  source: Model<S, T>;
-  selector: R;
-  modelKeyIdentifier: () => boolean;
-  [k: string]: any;
-  defaultState?: S;
-}
-
-declare interface UpdaterStore<
-  S = any,
-  T extends ModelInstance = ModelInstance
-> {
-  getState: () => { state: S; instance: T };
-  dispatch: (action: Action) => void;
-}
-
-export declare type MiddleWare = (
-  store: UpdaterStore
-) => (next: Dispatch) => (action: Action) => void;
-
-export declare interface Config {
-  middleWares?: MiddleWare[];
-  controlled?: boolean;
-  notify?: (
-    notifier: (action: Action) => { errors: any[] | undefined },
-    action: Action
-  ) => any;
-}
-
-/** createStore * */
-
-export declare interface StoreIndex<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> {
-  key: Key<S, T, R>;
-}
-
-export declare interface Store<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> extends StoreIndex<S, T, R> {
-  subscribe: (dispatcher: Dispatch) => () => void;
-  getToken: () => Token;
-  getInstance: () => T;
-  update: (args?: {
-    model?: Model<S, T>;
-    key?: Key<S, T, R>;
-    state?: S;
-  }) => void;
-  destroy: () => void;
-  payload: <P>(
-    callback?: (payload: P | undefined) => P | undefined
-  ) => P | undefined;
-  isDestroyed: () => boolean;
-  extends: <E extends Record<string, any>>(e: E) => Store<S, T, R> & E;
-}
-
-export declare function createStore<
-  S,
-  T extends ModelInstance,
-  D extends S,
-  R extends (instance: () => T) => any = (instance: () => T) => T
->(
-  model: Model<S, T> | Key<S, T, R> | ModelUsage<S, T, R>,
-  state?: D
-): Store<S, T, R>;
-
-/** createKey * */
-
-export declare interface ModelKey<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> extends Key<S, T, R> {
-  (s: S): T;
-  createStore: <D extends S>(state?: D) => Store<S, T, R>;
-  extends: <E extends Record<string, any>>(e: E) => ModelKey<S, T, R> & E;
-}
-
-export declare function createKey<
-  S,
-  T extends ModelInstance,
-  D extends S,
-  R extends (instance: () => T) => any = (instance: () => T) => T
->(model: Model<S, T> | ModelUsage<S, T, R>, state?: D): ModelKey<S, T, R>;
-
-/** createStores * */
-
-export declare interface StoreCollection {
-  find: <
-    S,
-    T extends ModelInstance,
-    R extends (instance: () => T) => any = (instance: () => T) => T
-  >(
-    key: Key<S, T, R> | StoreIndex<S, T, R>
-  ) => Store<S, T, R> | null;
-  update: (...keys: (ModelKey | StoreIndex)[]) => void;
-  keys: () => Key[];
-  destroy: () => void;
-}
-
-export declare function createStores(
-  ...modelKeys: (ModelKey | StoreIndex)[]
-): StoreCollection;
-
-/** model API * */
-
-export declare interface ModelUsage<
-  S,
-  T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> {
-  (s: S): ValidInstance<S, T>;
-  createKey: <D extends S>(state?: D) => ModelKey<S, T, R>;
-  createStore: <D extends S>(state?: D) => Store<S, T, R>;
-  select: <C extends (instance: () => T) => any = (instance: () => T) => T>(
-    s: C
-  ) => ModelUsage<S, T, C>;
-  selector: R;
-  extends: <E extends Record<string, any>>(e: E) => ModelUsage<S, T, R> & E;
-}
-
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export declare interface model {
-  <
-    S,
-    T extends ModelInstance,
-    R extends (instance: () => T) => any = (instance: () => T) => T
-  >(
-    modelFn: Model<S, T>,
-    s?: R
-  ): ModelUsage<S, T, R>;
-  createField: <P extends () => any>(
-    callback: P,
-    deps?: any[]
-  ) => FieldStructure<ReturnType<P>>;
-  createMethod: <P extends (...args: any[]) => any = (...args: any[]) => any>(
-    method: P
-  ) => MethodStructure<P>;
-}
-
-/** createSignal * */
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-declare interface SignalStore<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => any
-> extends StoreIndex<S, T, R> {
-  getToken: () => Token;
-  subscribe: (dispatcher: Dispatch) => () => void;
-  getSignal: () => {
-    (): T;
-    startStatistics: () => void;
-    stopStatistics: () => void;
-    subscribe: (dispatcher: Dispatch) => () => void;
-    store: Store<S, T, R>;
-  };
-}
-
-export declare function createSignal<
-  S,
-  T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => any
->(store: Store<S, T, R>): SignalStore<S, T, R>;
-
-/** createSelector * */
-
-declare type SelectMethod<
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => any
-> = {
-  (): ReturnType<R>;
-  <C extends (instance: () => T) => any>(selector: C): ReturnType<C>;
-  <C extends (instance: () => T) => any>(
-    selector?: C
-  ): ReturnType<R> | ReturnType<C>;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-declare interface SelectorStore<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => any
-> extends StoreIndex<S, T, R> {
-  getToken: () => Token;
-  subscribe: (dispatcher: Dispatch) => () => void;
-  select: SelectMethod<T, R>;
-}
-
-declare interface SelectorOption<T = any> {
-  equality?: (current: T, next: T) => boolean;
-}
-
-export declare function createSelector<
-  S,
-  T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => any
->(store: Store<S, T, R>, opts?: SelectorOption): SelectorStore<S, T, R>;
-
-/** config * */
-export declare function config(configuration: Config): {
-  createStore: <
-    S,
-    T extends ModelInstance,
-    D extends S,
-    R extends (instance: () => T) => any = (instance: () => T) => T
-  >(
-    model: Model<S, T> | Key<S, T, R> | ModelUsage<S, T, R>,
-    state?: D
-  ) => Store<S, T, R>;
-  createKey: <
-    S,
-    T extends ModelInstance,
-    D extends S,
-    R extends (instance: () => T) => any = (instance: () => T) => T
-  >(
-    model: Model<S, T> | ModelUsage<S, T, R>,
-    state?: D
-  ) => ModelKey<S, T, R>;
-  createStores: (...modelKeys: (ModelKey | StoreIndex)[]) => StoreCollection;
-  model: model;
-};
-
-/** validations * */
-export declare const validations: {
-  isInstanceFromNoStateModel: (instance: any) => boolean;
-  isModelKey: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
-  >(
-    data: any
-  ) => data is ModelKey<S, T, R>;
-  isModelStore: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
-  >(
-    data: any
-  ) => data is Store<S, T, R>;
-  isModelUsage: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
-  >(
-    data: any
-  ) => data is ModelUsage<S, T, R>;
-};
-
-/** tools * */
-export declare function shallowEqual(prev: any, current: any): boolean;
+declare interface ModelInstance {
+  [key: string]: any;
+  [key: number]: any;
+}
+
+export declare type FieldStructure<R = any> = {
+  callback: () => R;
+  deps: any[] | undefined;
+  identifier: (d: any) => d is FieldStructure<R>;
+  value: R;
+  get: () => R;
+};
+
+export declare type MethodStructure<
+  R extends (...args: any[]) => any = (...args: any[]) => any
+> = R & {
+  identifier: (d: any) => d is MethodStructure;
+};
+
+declare type ValidInstance<S, T extends ModelInstance> = {
+  [K in keyof T]: T[K] extends
+    | ((...args: any[]) => S)
+    | (((...args: any[]) => any) & { identifier: (d: any) => boolean })
+    ? T[K]
+    : T[K] extends (...args: any[]) => any
+      ? never
+      : T[K];
+};
+
+export declare type Model<S, T extends ModelInstance> = (
+  state: S
+) => ValidInstance<S, T>;
+
+export declare type Action<S = any, T extends ModelInstance = ModelInstance> = {
+  type: null | string;
+  method: null | ((...args: any[]) => any);
+  params?: any[];
+  state: S;
+  prevState?: S;
+  instance: T;
+  prevInstance?: T;
+};
+
+export interface Token {
+  isDifferent: (token: Token) => boolean;
+  value: unknown;
+}
+
+export declare type Dispatch = (action: Action) => any;
+
+export declare interface Key<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+> extends Model<S, T> {
+  (s: S): T;
+  source: Model<S, T>;
+  selector: R;
+  modelKeyIdentifier: () => boolean;
+  [k: string]: any;
+  defaultState?: S;
+}
+
+declare interface UpdaterStore<
+  S = any,
+  T extends ModelInstance = ModelInstance
+> {
+  getState: () => { state: S; instance: T };
+  dispatch: (action: Action) => void;
+}
+
+export declare type MiddleWare = (
+  store: UpdaterStore
+) => (next: Dispatch) => (action: Action) => void;
+
+export declare interface Config {
+  middleWares?: MiddleWare[];
+  controlled?: boolean;
+  notify?: (
+    notifier: (action: Action) => { errors: any[] | undefined },
+    action: Action
+  ) => any;
+}
+
+/** createStore * */
+
+export declare interface StoreIndex<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+> {
+  key: Key<S, T, R>;
+}
+
+export declare interface Store<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+> extends StoreIndex<S, T, R> {
+  subscribe: (dispatcher: Dispatch) => () => void;
+  getToken: () => Token;
+  getInstance: () => T;
+  update: (args?: {
+    model?: Model<S, T>;
+    key?: Key<S, T, R>;
+    initialState?: S;
+    state?: S;
+  }) => void;
+  destroy: () => void;
+  payload: <P>(
+    callback?: (payload: P | undefined) => P | undefined
+  ) => P | undefined;
+  isDestroyed: () => boolean;
+  extends: <E extends Record<string, any>>(e: E) => Store<S, T, R> & E;
+}
+
+export declare function createStore<
+  S,
+  T extends ModelInstance,
+  D extends S,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+>(
+  model: Model<S, T> | Key<S, T, R> | ModelUsage<S, T, R>,
+  state?: D
+): Store<S, T, R>;
+
+/** createKey * */
+
+export declare interface ModelKey<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+> extends Key<S, T, R> {
+  (s: S): T;
+  createStore: <D extends S>(state?: D) => Store<S, T, R>;
+  extends: <E extends Record<string, any>>(e: E) => ModelKey<S, T, R> & E;
+}
+
+export declare function createKey<
+  S,
+  T extends ModelInstance,
+  D extends S,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+>(model: Model<S, T> | ModelUsage<S, T, R>, state?: D): ModelKey<S, T, R>;
+
+/** createStores * */
+
+export declare interface StoreCollection {
+  find: <
+    S,
+    T extends ModelInstance,
+    R extends (instance: () => T) => any = (instance: () => T) => T
+  >(
+    key: Key<S, T, R> | StoreIndex<S, T, R>
+  ) => Store<S, T, R> | null;
+  update: (...keys: (ModelKey | StoreIndex)[]) => void;
+  keys: () => Key[];
+  destroy: () => void;
+}
+
+export declare function createStores(
+  ...modelKeys: (ModelKey | StoreIndex)[]
+): StoreCollection;
+
+/** model API * */
+
+export declare interface ModelUsage<
+  S,
+  T extends ModelInstance,
+  R extends (instance: () => T) => any = (instance: () => T) => T
+> {
+  (s: S): ValidInstance<S, T>;
+  createKey: <D extends S>(state?: D) => ModelKey<S, T, R>;
+  createStore: <D extends S>(state?: D) => Store<S, T, R>;
+  select: <C extends (instance: () => T) => any = (instance: () => T) => T>(
+    s: C
+  ) => ModelUsage<S, T, C>;
+  selector: R;
+  extends: <E extends Record<string, any>>(e: E) => ModelUsage<S, T, R> & E;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export declare interface model {
+  <
+    S,
+    T extends ModelInstance,
+    R extends (instance: () => T) => any = (instance: () => T) => T
+  >(
+    modelFn: Model<S, T>,
+    s?: R
+  ): ModelUsage<S, T, R>;
+  createField: <P extends () => any>(
+    callback: P,
+    deps?: any[]
+  ) => FieldStructure<ReturnType<P>>;
+  createMethod: <P extends (...args: any[]) => any = (...args: any[]) => any>(
+    method: P
+  ) => MethodStructure<P>;
+}
+
+/** createSignal * */
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+declare interface SignalStore<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => any
+> extends StoreIndex<S, T, R> {
+  getToken: () => Token;
+  subscribe: (dispatcher: Dispatch) => () => void;
+  getSignal: () => {
+    (): T;
+    startStatistics: () => void;
+    stopStatistics: () => void;
+    subscribe: (dispatcher: Dispatch) => () => void;
+    store: Store<S, T, R>;
+  };
+}
+
+export declare function createSignal<
+  S,
+  T extends ModelInstance,
+  R extends (instance: () => T) => any = (instance: () => T) => any
+>(store: Store<S, T, R>): SignalStore<S, T, R>;
+
+/** createSelector * */
+
+declare type SelectMethod<
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => any
+> = {
+  (): ReturnType<R>;
+  <C extends (instance: () => T) => any>(selector: C): ReturnType<C>;
+  <C extends (instance: () => T) => any>(
+    selector?: C
+  ): ReturnType<R> | ReturnType<C>;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+declare interface SelectorStore<
+  S = any,
+  T extends ModelInstance = any,
+  R extends (instance: () => T) => any = (instance: () => T) => any
+> extends StoreIndex<S, T, R> {
+  getToken: () => Token;
+  subscribe: (dispatcher: Dispatch) => () => void;
+  select: SelectMethod<T, R>;
+}
+
+declare interface SelectorOption<T = any> {
+  equality?: (current: T, next: T) => boolean;
+}
+
+export declare function createSelector<
+  S,
+  T extends ModelInstance,
+  R extends (instance: () => T) => any = (instance: () => T) => any
+>(store: Store<S, T, R>, opts?: SelectorOption): SelectorStore<S, T, R>;
+
+/** config * */
+export declare function config(configuration: Config): {
+  createStore: <
+    S,
+    T extends ModelInstance,
+    D extends S,
+    R extends (instance: () => T) => any = (instance: () => T) => T
+  >(
+    model: Model<S, T> | Key<S, T, R> | ModelUsage<S, T, R>,
+    state?: D
+  ) => Store<S, T, R>;
+  createKey: <
+    S,
+    T extends ModelInstance,
+    D extends S,
+    R extends (instance: () => T) => any = (instance: () => T) => T
+  >(
+    model: Model<S, T> | ModelUsage<S, T, R>,
+    state?: D
+  ) => ModelKey<S, T, R>;
+  createStores: (...modelKeys: (ModelKey | StoreIndex)[]) => StoreCollection;
+  model: model;
+};
+
+/** validations * */
+export declare const validations: {
+  isInstanceFromNoStateModel: (instance: any) => boolean;
+  isModelKey: <
+    S,
+    T extends ModelInstance,
+    R extends (ins: () => T) => any = (ins: () => T) => T
+  >(
+    data: any
+  ) => data is ModelKey<S, T, R>;
+  isModelStore: <
+    S,
+    T extends ModelInstance,
+    R extends (ins: () => T) => any = (ins: () => T) => T
+  >(
+    data: any
+  ) => data is Store<S, T, R>;
+  isModelUsage: <
+    S,
+    T extends ModelInstance,
+    R extends (ins: () => T) => any = (ins: () => T) => T
+  >(
+    data: any
+  ) => data is ModelUsage<S, T, R>;
+};
+
+/** tools * */
+export declare function shallowEqual(prev: any, current: any): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "as-model",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "This is a model state management tool",
   "license": "MIT",
   "author": "Jimmy.Harding",