implemented new flow

Author: michaelolof

.gitignore

@@ -1,4 +1 @@
-.vscode/
-test-js/
-test-ts/
 node_modules/

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "files.exclude": {
+    "node_modules": true,
+    "test-js/node_modules": true,
+    "test-ts/node_modules": true
+  }
+}

src/actions.ts

@@ -0,0 +1,63 @@
+import { ActionDescriptor, ActionOption, VuexModule, VuexModuleInternalsPrototype } from "./interfaces";
+import { ActionContext } from 'vuex';
+import { LegacyVuexModule } from './module.legacy';
+
+/*
+ * We need a Vuex action to always be present so we can
+ * guarantee access to the context object always exist when creating a
+ * proxy.
+ */
+export const internalAction = ( state :any, context :any ) => undefined;
+
+
+export function action(options? :ActionOption ): (target:any, key:string, descriptor:ActionDescriptor) => any
+export function action(target:any, key:string, descriptor:ActionDescriptor):any
+export function action(...params:any[]) {
+
+  const firstParam = params[0] as VuexModule | ActionOption | undefined;
+  
+  if( firstParam === undefined ) return handleMutateActionMode;
+  
+  if( firstParam instanceof VuexModule || firstParam instanceof LegacyVuexModule ) { 
+    return handleMutateActionMode( firstParam, params[ 1 ], params[ 2 ] )
+  }
+  
+  switch( firstParam.mode ) {
+    case "raw": return handleRawActionMode;
+    case "mutate": return handleMutateActionMode;
+    default: return handleMutateActionMode;
+  }
+
+}
+
+export function getRawActionContext<T extends VuexModule, R>( thisArg:ThisType<T> ) {
+  return thisArg as ActionContext<T, R>
+}
+
+function handleMutateActionMode(target:VuexModule, key:string, descriptor:ActionDescriptor) {
+
+
+  initializeActionsCache( target );
+  
+  (target as VuexModuleInternalsPrototype).__actions__.push({
+    __name__: key,
+    __type__: "mutate",
+  })
+
+}
+
+function handleRawActionMode(target:any, key:string, descriptor:ActionDescriptor) {
+  
+  initializeActionsCache( target );
+  
+  (target as VuexModuleInternalsPrototype).__actions__.push({
+    __name__: key,
+    __type__: "raw",
+  });
+}
+
+function initializeActionsCache(target :any) {  
+  if( ( target as VuexModuleInternalsPrototype).__actions__ === undefined ) {
+    (target as VuexModuleInternalsPrototype).__actions__ = [];
+  }
+}

src/getters.legacy.ts

@@ -0,0 +1,6 @@
+
+/*
+ * The getter decorator exists just for backward compatibility.
+ * Not doing anything.
+ */
+export const getter = (target:any, propertyKey:string) => undefined

src/getters.ts

@@ -0,0 +1,30 @@
+export const internalGetter = ( state :any, context :any ) => ( field :string ) => {
+  const fields = field.split( "." );
+  switch( fields.length ) {
+    case 1: 
+      return state[ fields[0] ];
+    case 2:
+      return state[ fields[0] ][ fields[1] ];
+    case 3:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ];
+    case 4:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ];
+    case 5:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ];
+    case 6:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ];
+    case 7:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ];
+    case 8:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ][ fields[7] ];
+    case 9:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ][ fields[7] ][ fields[8] ];
+    case 10:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ][ fields[7] ][ fields[8] ][ fields[9] ];
+    case 11:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ][ fields[7] ][ fields[8] ][ fields[9] ][ fields[10] ];
+    case 12:
+      return state[ fields[0] ][ fields[1] ][ fields[2] ][ fields[3] ][ fields[4] ][ fields[ 5] ][ fields[6] ][ fields[7] ][ fields[8] ][ fields[9] ][ fields[10] ][ fields[11] ];
+  }
+}
+

src/index.ts

@@ -0,0 +1,8 @@
+export { extractVuexModule, createModule } from "./module";
+export { createSubModule } from "./submodule";
+export { createProxy } from "./proxy"
+export { action, getRawActionContext } from "./actions";
+export { mutation } from "./mutations";
+
+export { Module, LegacyVuexModule as VuexModule } from "./module.legacy";
+export { getter } from "./getters.legacy";

src/interfaces.ts

@@ -1,42 +1,45 @@
 export interface VuexModuleOptions {
-  namespaced ?:boolean;
-  target ?:"nuxt"
+  /*
+   * Takes a boolean or a namespacedPath.
+   * Defines wether the module should be namespaced or not.
+   * If true, then the module will be namespaced.
+   * If false, then the module will not be namespaced.
+   * If it is a string the module will be namespaced and the value will be the namespaced path
+   */
+  namespaced ?:boolean | string;
+  target ?:"nuxt";
+  enableLocalWatchers ?:boolean | string;
+  enableLocalSubscriptions ?:boolean | string;
+  enableLocalActionSubscriptions ?:boolean | string;
 }
 
-export class VuexModule {
-}
-
-type VuexStashTypes =  "state" | "explicit-mutation" | "getter" | "action" | "submodule";
-
-export interface VuexStash<T extends VuexStashTypes> {
-  [ field :string ]: { 
-    type :T, 
-    value: 
-      T extends "state" ? boolean | number | string | object | any : 
-      T extends  "explicit-mutation" ? ( state :any, payload :any ) => void :
-      T extends "getter" ? { getter :( state :any, context :any ) => any, mutation? :( state :any, payload :any ) => void } :
-      T extends "action" ? ( context :any, payload :any ) => Promise<any> :
-      T extends "submodule" ? Map :
-      never
-  }
-}
+export class VuexModule {}
 
 export type VuexModuleConstructor = typeof VuexModule & VuexModuleInternals;
 
 export interface VuexModuleInternals {
-  prototype :{
-    __options__ :VuexModuleOptions | undefined;
-    __vuex_module_cache__ :undefined | VuexObject;
-    __vuex_module_tree_stash__: VuexStash<VuexStashTypes>;
-    __vuex_proxy_cache__ :{} | undefined;
-    __vuex_local_proxy_cache__ :{} | undefined;
-    __submodules_cache__: Map;
-    __mutations_cache__: {
-      __explicit_mutations__: {},
-      __setter_mutations__: {},
-    };
-    __context_store__: Map | undefined;
-  }
+  prototype :VuexModuleInternalsPrototype
+}
+
+export interface VuexModuleInternalsPrototype {
+  __options__ :VuexModuleOptions | undefined;
+  __namespacedPath__ :string;
+  __vuex_module_cache__ :undefined | VuexObject;
+  __vuex_proxy_cache__ :{} | undefined;
+  __vuex_local_proxy_cache__ :{} | undefined;
+  __submodules_cache__: Map;
+  __context_store__: Map | undefined;
+  __mutations_cache__: {
+    __explicit_mutations__: {},
+    __setter_mutations__: {},
+  };
+  __explicit_getter_names__ :string[];
+  __explicit_mutations_names__: string[],
+  __actions__: {
+    __name__ :string,
+    __type__ :ActionType,
+  }[],
+  __watch__ :Map;
 }
 
 export interface SubModuleType<T> {
@@ -60,4 +63,37 @@ export type Map = Record<DictionaryField, any>
 export interface FieldPayload { 
   field :string;
   payload :any;
+}
+
+export type MutationDescriptor = TypedPropertyDescriptor<(payload?:any) => void>
+
+export type ActionType = "raw" | "mutate";
+
+export type ActionOption = {
+  mode? :ActionType
+}
+
+export type ActionDescriptor = TypedPropertyDescriptor<(payload?:any) => Promise<any>>
+
+export interface ProxyWatchers {
+
+  $watch ( 
+    getterField :string,
+    callback :(( newVal :string, oldVal :string) => void) | object,
+    options? :{ deep :boolean, immediate :boolean }
+  ) :() => void 
+
+  $subscribe (
+    mutationfield :string,
+    callback :( payload :any ) => void,
+  ) :void
+
+  $subscribeAction (
+    actionField :string,
+    callbackOrObj :( payload :any ) => void | ({
+      before: ( payload :any ) => void,
+      after: ( payload :any ) => void,
+    })
+  ) :void
+
 }

src/module.legacy.ts

@@ -0,0 +1,57 @@
+import { VuexModuleConstructor, VuexModule, Map } from "./interfaces";
+import { createModule, extractVuexModule } from "./module";
+import { createProxy } from './proxy';
+import { createSubModule } from './submodule';
+
+export function Module({ namespacedPath = "", target = "core" as VuexModuleTarget } = defaultModuleOptions ) {
+
+  return function( module :VuexModule ) :void {
+    
+    const VuexClass = module as VuexModuleConstructor;
+
+    const mod = createModule({
+      target: VuexClass.prototype.__options__ && VuexClass.prototype.__options__.target,
+      namespaced: VuexClass.prototype.__options__ && VuexClass.prototype.__options__.namespaced || false,
+    });
+
+    // Add all fields in mod prototype without replacing
+    for( let field in mod.prototype ) {
+      //@ts-ignore
+      if( VuexClass.prototype[ field ] ) continue;
+      //@ts-ignore
+      VuexClass.prototype[ field ] = mod.prototype[ field ]
+    }    
+
+  
+  }
+
+}
+
+export class LegacyVuexModule {
+
+  static ExtractVuexModule( cls :typeof VuexModule ) {
+    const vxmodule = extractVuexModule( cls );
+    //@ts-ignore
+    return vxmodule[ cls.prototype.__namespacedPath__ ]
+  }
+
+  static CreateProxy( cls :typeof VuexModule, $store :Map ) {
+    return createProxy( cls, $store )
+  }
+
+  static CreateSubModule( cls :typeof VuexModule ) {
+    return createSubModule( cls );
+  }
+}
+
+export type VuexModuleTarget = "core" | "nuxt";
+
+interface ModuleOptions {
+  namespacedPath?: string,
+  target?: VuexModuleTarget
+}
+
+const defaultModuleOptions :ModuleOptions = {
+  namespacedPath: "",
+  target: "core",
+}