fixed store issues

Author: michaelolof

.gitignore

@@ -1 +1,3 @@
-node_modules/
+node_modules/
+test-ts/
+test-js/

src/interfaces.ts

@@ -31,7 +31,7 @@ export interface VuexModuleInternals {
 export interface VuexModuleInternalsPrototype {
   __options__ :VuexModuleOptions | undefined;
   __namespacedPath__ :string;
-  __vuex_module_cache__ :undefined | VuexObject;
+  __vuex_module_cache__ :undefined | { [ path: string ]: VuexObject };
   __vuex_proxy_cache__ :{} | undefined;
   __vuex_local_proxy_cache__ :{} | undefined;
   __submodules_cache__: Map;
@@ -47,6 +47,7 @@ export interface VuexModuleInternalsPrototype {
     __type__ :ActionType,
   }[],
   __watch__ :Map;
+  __store_cache__ :any;
 }
 
 export interface SubModuleType<T> {

src/module.legacy.ts

@@ -40,13 +40,16 @@ export interface LegacyVuexModule extends VuexModuleAddons {}
 export class LegacyVuexModule {
 
   static ExtractVuexModule( cls :typeof VuexModule ) {
-    const vxmodule = extractVuexModule( cls );
-    //@ts-ignore
-    return vxmodule[ cls.prototype.__namespacedPath__ ]
+    
+    const VuexClass = cls as VuexModule & VuexModuleConstructor;
+    
+    const vxmodule = extractVuexModule( VuexClass );
+
+    return vxmodule[ VuexClass.prototype.__namespacedPath__ ];
   }
 
   static CreateProxy<T extends typeof VuexModule>( $store :Map, cls :T ) {
-    return createProxy( $store, cls )
+    return createProxy( $store, cls );
   }
 
   static CreateSubModule( cls :typeof VuexModule ) {

src/module.ts

@@ -41,9 +41,9 @@ export function extractVuexModule( cls :typeof VuexModule ) {
 
   // Check if module has been cached, 
   // and just return the cached version.
-  // if( VuexClass.prototype.__vuex_module_cache__ ) {
-  //   return VuexClass.prototype.__vuex_module_cache__;
-  // }
+  if( VuexClass.prototype.__vuex_module_cache__ ) {
+    return VuexClass.prototype.__vuex_module_cache__;
+  }
 
   // If not extract vuex module from class.
   const fromInstance = extractModulesFromInstance( VuexClass );
@@ -63,12 +63,12 @@ export function extractVuexModule( cls :typeof VuexModule ) {
   };
 
   // Cache the vuex module on the class.
-  VuexClass.prototype.__vuex_module_cache__ = vuexModule;
   const className = getNamespacedPath( VuexClass );
+  
+  const rtn = { [ className ]: vuexModule }
+  VuexClass.prototype.__vuex_module_cache__ = rtn;
 
-  return { 
-    [ className ]: vuexModule
-  } as any
+  return rtn;
 
 }
 

src/proxy.ts

@@ -11,15 +11,14 @@ export function createProxy<T extends typeof VuexModule>( $store :any, cls :T )
   const VuexClass = cls as VuexModuleConstructor;
 
   // Check cache and return from cache if defined.
-  // if( VuexClass.prototype.__vuex_proxy_cache__ ) {
-  //   return VuexClass.prototype.__vuex_proxy_cache__ as InstanceType<T> & ProxyWatchers;
-  // }
+  if( VuexClass.prototype.__vuex_proxy_cache__ ) {
+    return VuexClass.prototype.__vuex_proxy_cache__ as InstanceType<T> & ProxyWatchers;
+  }
 
   const namespacedPath = VuexClass.prototype.__namespacedPath__ ? VuexClass.prototype.__namespacedPath__ + "/" : "";
 
   // Create Proxy and cache
   const proxy = _createProxy( cls, $store, namespacedPath );
-  VuexClass.prototype.__vuex_proxy_cache__ = proxy;
 
   // Setup Local Watchers
   createLocalWatchers( VuexClass, $store, namespacedPath || "" );
@@ -86,6 +85,10 @@ export function createProxy<T extends typeof VuexModule>( $store :any, cls :T )
       })
     }
   }
+
+  if( VuexClass.prototype.__store_cache__ === undefined ) VuexClass.prototype.__store_cache__ = $store;
+
+  VuexClass.prototype.__vuex_proxy_cache__ = proxy;
 
   return proxy as InstanceType<T> & ProxyWatchers;
 }
@@ -114,9 +117,9 @@ export function _createProxy<T>(cls: T, $store: any, namespacedPath = "") {
   const { state, mutations, actions, getters, modules } = extractVuexModule( VuexClass )[ VuexClass.prototype.__namespacedPath__ ];
 
   createGettersAndMutationProxyFromState({ cls: VuexClass, proxy, state, $store, namespacedPath, maxDepth: 7 });
-  createExplicitMutationsProxy({ cls: VuexClass, proxy, $store, namespacedPath });
+  createExplicitMutationsProxy( VuexClass, proxy, $store, namespacedPath );
   createGettersAndGetterMutationsProxy({ cls: VuexClass, mutations, getters, proxy, $store, namespacedPath });
-  createActionProxy({ actions, proxy, $store, namespacedPath });
+  createActionProxy({ cls: VuexClass, actions, proxy, $store, namespacedPath });
   createSubModuleProxy( $store, VuexClass, proxy, modules );
 
   //@ts-ignore
@@ -256,10 +259,10 @@ function createLocalWatchers( cls :VuexModuleConstructor, $store :Map, namespace
 }
 
 function createSubModuleProxy( $store :Map, cls:VuexModuleConstructor, proxy :Map, modules :Map ) {
-
+  const store = cls.prototype.__store_cache__ || $store;
   for( let field in modules ) {
     const subModuleClass = cls.prototype.__submodules_cache__[ field ];
-    proxy[ field ] = createProxy( $store, subModuleClass );
+    proxy[ field ] = createProxy( store, subModuleClass );
   }
 
 }
@@ -322,11 +325,16 @@ function createGettersAndMutationProxyFromState({ cls, proxy, state, $store, nam
 
 }
 
-function createExplicitMutationsProxy({ cls, proxy, $store, namespacedPath } :MutationProxyCreator) {
+function createExplicitMutationsProxy( cls :VuexModuleConstructor, proxy :Map, $store :any, namespacedPath :string ) {
+  
   const mutations = cls.prototype.__mutations_cache__.__explicit_mutations__;
+  const commit = cls.prototype.__store_cache__ ? cls.prototype.__store_cache__.commit : $store.commit;
+  namespacedPath = cls.prototype.__namespacedPath__.length ? cls.prototype.__namespacedPath__ + "/" : namespacedPath;
+
   for( let field in mutations ) {
-    proxy[ field ] = ( payload :any ) => $store.commit( namespacedPath + field, payload )
+    proxy[ field ] = ( payload :any ) => commit( namespacedPath + field, payload )
   }
+
 }
 
 function createGettersAndGetterMutationsProxy({ cls, getters, mutations, proxy, $store, namespacedPath } :GetterProxyCreator) {
@@ -367,11 +375,14 @@ function createGettersAndGetterMutationsProxy({ cls, getters, mutations, proxy,
   }
 }
 
-function createActionProxy({ actions, proxy, $store, namespacedPath } :ActionProxyCreator) {
+function createActionProxy({ cls, actions, proxy, $store, namespacedPath } :ActionProxyCreator) {
+
+  const dispatch = cls.prototype.__store_cache__ ? cls.prototype.__store_cache__.dispatch : $store.dispatch;
+  namespacedPath = cls.prototype.__namespacedPath__.length ? cls.prototype.__namespacedPath__ + "/" : namespacedPath;
+
   for( let field in actions ) {
-    if( $store === undefined ) continue;
     proxy[ field ] = function( payload :any )  { 
-      return $store.dispatch( namespacedPath + field, payload );
+      return dispatch( namespacedPath + field, payload );
     }
   }
 }
@@ -422,6 +433,6 @@ interface GetterProxyCreator extends MutationProxyCreator {
   mutations :Map;
 }
 
-interface ActionProxyCreator extends ProxyCreator {
+interface ActionProxyCreator extends MutationProxyCreator {
   actions :Map;
 }

test/create-proxy.spec.ts

@@ -22,7 +22,8 @@ class UserSettings extends VuexModule {
 
 @Module({ namespacedPath: 'user/' })
 class UserStore extends VuexModule {
-	// settings = UserSettings.CreateSubModule(UserSettings)
+
+	settings = UserSettings.CreateSubModule(UserSettings)
 
 	firstname = 'Michael'
 	lastname = 'Olofinjana'
@@ -78,7 +79,7 @@ describe('CreateProxy', () => {
 		expect(user.lastname).toEqual('Olofinjana')
 	})
 
-	it.only('should proxy actions', async () => {
+	it('should proxy actions', async () => {
 
 		const user = UserStore.CreateProxy(store, UserStore)
 

tsconfig.json

@@ -43,4 +43,8 @@
 
     /* Experimental Options */
   },
+  "exclude": [
+    "test-js/*",
+    "test-ts/*"
+  ]
 }