as-model 0.2.9 → 0.3.1

package/index.d.ts

@@ -27,10 +27,18 @@ declare type ValidInstance<S, T extends ModelInstance> = {
       : T[K];
 };
 
-export declare type Model<S, T extends ModelInstance> = (
+export declare type Model<S = any, T extends ModelInstance = any> = (
   state: S
 ) => ValidInstance<S, T>;
 
+export type PickState<R extends Model> = R extends (state: infer S) => any
+  ? S
+  : never;
+
+export type Instance<R extends Model> = R extends (state: any) => infer T
+  ? T
+  : never;
+
 export declare type Action<S = any, T extends ModelInstance = ModelInstance> = {
   type: null | string;
   method: null | ((...args: any[]) => any);
@@ -49,22 +57,18 @@ export interface Token {
 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;
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+> extends M {
+  (s: PickState<M>): Instance<M>;
+  source: M;
+  wrapper: R;
   modelKeyIdentifier: () => boolean;
   [k: string]: any;
-  defaultState?: S;
+  defaultState?: PickState<M>;
 }
 
-declare interface UpdaterStore<
-  S = any,
-  T extends ModelInstance = ModelInstance
-> {
+declare interface UpdaterStore<S = any, T extends ModelInstance = any> {
   getState: () => { state: S; instance: T };
   dispatch: (action: Action) => void;
 }
@@ -85,114 +89,110 @@ export declare interface Config {
 /** createStore * */
 
 export declare interface StoreIndex<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
+  M extends Model,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
 > {
-  key: Key<S, T, R>;
+  key: Key<M, R>;
 }
 
 export declare interface Store<
-  S = any,
-  T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
-> extends StoreIndex<S, T, R> {
+  M extends Model,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+> extends StoreIndex<M, R> {
   subscribe: (dispatcher: Dispatch) => () => void;
   getToken: () => Token;
-  getInstance: () => ReturnType<R>;
-  getStoreInstance: () => T;
+  getInstance: () => R extends undefined
+    ? Instance<M>
+    : ReturnType<R extends undefined ? never : R>;
+  getStoreInstance: () => Instance<M>;
   update: (args?: {
-    model?: Model<S, T>;
-    key?: Key<S, T, R>;
-    initialState?: S;
-    state?: S;
+    model?: M;
+    key?: Key<M, R>;
+    initialState?: PickState<M>;
+    state?: PickState<M>;
   }) => 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;
+  extends: <E extends Record<string, any>>(e: E) => Store<M, 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, Model<S, T>, R>,
-  state?: D
-): Store<S, T, R>;
+  M extends Model,
+  D extends PickState<M>,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+>(model: M | Key<M, R> | ModelUsage<M, R>, state?: D): Store<M, 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;
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+> extends Key<M, R> {
+  (s: PickState<M>): Instance<M>;
+  createStore: <D extends PickState<M>>(initialState?: D) => Store<M, R>;
+  extends: <E extends Record<string, any>>(e: E) => ModelKey<M, 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, Model<S, T>, R>,
-  state?: D
-): ModelKey<S, T, R>;
+  M extends Model = any,
+  D extends PickState<M>,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+>(model: M | ModelUsage<M, R>, initialState?: D): ModelKey<M, R>;
 
 /** createStores * */
 
 export declare interface StoreCollection {
   find: <
-    S,
-    T extends ModelInstance,
-    R extends (instance: () => T) => any = (instance: () => T) => T
+    M extends Model = any,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
-    key: Key<S, T, R> | StoreIndex<S, T, R>
-  ) => Store<S, T, R> | null;
-  update: (...keys: (ModelKey | StoreIndex)[]) => void;
+    key: Key<M, R> | StoreIndex<M, R>
+  ) => Store<M, R> | null;
+  update: (...keys: (ModelKey<any, any> | StoreIndex<any, any>)[]) => void;
   keys: () => Key[];
   destroy: () => void;
 }
 
 export declare function createStores(
-  ...modelKeys: (ModelKey | StoreIndex)[]
+  ...modelKeys: (ModelKey<any, any> | StoreIndex<any, any>)[]
 ): StoreCollection;
 
 /** model API * */
 
 export declare type ModelUsage<
-  S,
-  T extends ModelInstance,
-  M extends Model<S, T>,
-  R extends (instance: () => T) => any = (instance: () => T) => T
+  M extends Model,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
 > = M & {
-  createKey: <D extends S>(state?: D) => ModelKey<S, T, R>;
-  createStore: <D extends S>(state?: D) => Store<S, T, R>;
-  produce: <C extends (instance: () => T) => any = (instance: () => T) => T>(
+  createKey: <D extends PickState<M>>(state?: D) => ModelKey<M, R>;
+  createStore: <D extends PickState<M>>(state?: D) => Store<M, R>;
+  produce: <
+    C extends (instance: () => Instance<M>) => any = (
+      instance: () => Instance<M>
+    ) => Instance<M>
+  >(
     s: C
-  ) => ModelUsage<S, T, M, C>;
+  ) => ModelUsage<M, C>;
   wrapper: R;
-  extends: <E extends Record<string, any>>(e: E) => ModelUsage<S, T, M, R> & E;
+  extends: <E extends Record<string, any>>(e: E) => ModelUsage<M, R> & E;
 };
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export declare interface model {
+  <M extends Model>(modelFn: M): ModelUsage<M, undefined>;
+  <M extends Model, R extends (instance: () => Instance<M>) => any>(
+    modelFn: M,
+    s: R
+  ): ModelUsage<M, R>;
   <
-    S,
-    T extends ModelInstance,
-    R extends (instance: () => T) => any = (instance: () => T) => T
+    M extends Model,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
-    modelFn: Model<S, T>,
+    modelFn: M,
     s?: R
-  ): ModelUsage<S, T, typeof modelFn, R>;
+  ): ModelUsage<M, R>;
   createField: <P extends () => any>(
     callback: P,
     deps?: any[]
@@ -210,51 +210,66 @@ export interface SignalOptions {
 
 // 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> {
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+> extends StoreIndex<M, R> {
   getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
   getSignal: () => {
-    (options?: SignalOptions): ReturnType<R>;
+    (
+      options?: SignalOptions
+    ): R extends undefined
+      ? Instance<M>
+      : ReturnType<R extends undefined ? never : R>;
     startStatistics: () => void;
     stopStatistics: () => void;
     subscribe: (dispatcher: Dispatch) => () => void;
-    store: Store<S, T, R>;
+    store: Store<M, R>;
   };
 }
 
 export declare function createSignal<
-  S,
-  T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => T
->(store: Store<S, T, R>): SignalStore<S, T, R>;
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+>(store: Store<M, R>): SignalStore<M, R>;
 
 /** createSelector * */
 
 declare type SelectMethod<
   T extends ModelInstance = any,
-  R extends (instance: () => T) => any = (instance: () => T) => T
+  R extends undefined | ((instance: () => T) => any) = undefined
 > = {
-  (): ReturnType<R>;
-  <C extends (instance: () => ReturnType<R>) => any>(
+  (): R extends undefined ? T : ReturnType<R extends undefined ? never : R>;
+  <
+    C extends (
+      instance: () => R extends undefined
+        ? T
+        : ReturnType<R extends undefined ? never : R>
+    ) => any
+  >(
     selector: C
   ): ReturnType<C>;
-  <C extends (instance: () => ReturnType<R>) => any>(
+  <
+    C extends (
+      instance: () => R extends undefined
+        ? T
+        : ReturnType<R extends undefined ? never : R>
+    ) => any
+  >(
     selector?: C
-  ): ReturnType<R> | ReturnType<C>;
+  ):
+    | (R extends undefined ? T : ReturnType<R extends undefined ? never : 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) => T
-> extends StoreIndex<S, T, R> {
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+> extends StoreIndex<M, R> {
   getToken: () => Token;
   subscribe: (dispatcher: Dispatch) => () => void;
-  select: SelectMethod<T, R>;
+  select: SelectMethod<Instance<M>, R>;
 }
 
 declare interface SelectorOption<T = any> {
@@ -262,31 +277,28 @@ declare interface SelectorOption<T = any> {
 }
 
 export declare function createSelector<
-  S,
-  T extends ModelInstance,
-  R extends (instance: () => T) => any = (instance: () => T) => T
->(store: Store<S, T, R>, opts?: SelectorOption): SelectorStore<S, T, R>;
+  M extends Model = any,
+  R extends undefined | ((instance: () => Instance<M>) => any) = undefined
+>(store: Store<M, R>, opts?: SelectorOption): SelectorStore<M, R>;
 
 /** config * */
 export declare function config(configuration: Config): {
   createStore: <
-    S,
-    T extends ModelInstance,
-    D extends S,
-    R extends (instance: () => T) => any = (instance: () => T) => T
+    M extends Model,
+    D extends PickState<M>,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
-    model: Model<S, T> | Key<S, T, R> | ModelUsage<S, T, R>,
+    modelLike: M | Key<M, R> | ModelUsage<M, R>,
     state?: D
-  ) => Store<S, T, R>;
+  ) => Store<M, R>;
   createKey: <
-    S,
-    T extends ModelInstance,
-    D extends S,
-    R extends (instance: () => T) => any = (instance: () => T) => T
+    M extends Model,
+    D extends PickState<M>,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
-    model: Model<S, T> | ModelUsage<S, T, R>,
+    modelLike: M | ModelUsage<M, R>,
     state?: D
-  ) => ModelKey<S, T, R>;
+  ) => ModelKey<M, R>;
   createStores: (...modelKeys: (ModelKey | StoreIndex)[]) => StoreCollection;
   model: model;
 };
@@ -295,33 +307,29 @@ export declare function config(configuration: Config): {
 export declare const validations: {
   isInstanceFromNoStateModel: (instance: any) => boolean;
   isModelKey: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
+    M extends Model,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
     data: any
-  ) => data is ModelKey<S, T, R>;
+  ) => data is ModelKey<M, R>;
   isModelStore: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
+    M extends Model,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
     data: any
-  ) => data is Store<S, T, R>;
+  ) => data is Store<M, R>;
   isModelUsage: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
+    M extends Model,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
-    data: any
-  ) => data is ModelUsage<S, T, typeof data, R>;
+    data: M
+  ) => data is ModelUsage<typeof data, R>;
   isStoreIndex: <
-    S,
-    T extends ModelInstance,
-    R extends (ins: () => T) => any = (ins: () => T) => T
+    M extends Model,
+    R extends undefined | ((instance: () => Instance<M>) => any) = undefined
   >(
     data: any
-  ) => data is StoreIndex<S, T, R>;
+  ) => data is StoreIndex<M, R>;
 };
 
 /** tools * */

package/package.json

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