sync features and bugfix from 0275c2d (#1638)

Author: embbnux

.sync

@@ -1 +1 @@
-e8bf8f74050d43715af4216e79e297525396f39b
+a72216f034c9bc684506f18c4d99ed1138b70099

packages/babel-settings/babel.config.js

@@ -5,7 +5,6 @@ const plugins = [
       legacy: true,
     },
   ],
-  '@babel/plugin-proposal-function-bind',
   [
     '@babel/plugin-proposal-class-properties',
     {

packages/babel-settings/lib/crius.js

@@ -0,0 +1,7 @@
+module.exports = require('babel-jest').createTransformer({
+  presets: [['@babel/preset-env'], ['babel-preset-crius']],
+  plugins: [['@babel/plugin-proposal-decorators', { legacy: true }]],
+  ignore: [/node_modules/],
+  rootMode: 'upward',
+  test: './test',
+});

packages/babel-settings/package.json

@@ -18,7 +18,6 @@
     "@babel/plugin-proposal-decorators": "^7.8.3",
     "@babel/plugin-proposal-export-default-from": "^7.8.3",
     "@babel/plugin-proposal-export-namespace-from": "^7.8.3",
-    "@babel/plugin-proposal-function-bind": "^7.8.3",
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.8.3",
     "@babel/plugin-proposal-object-rest-spread": "^7.9.6",
     "@babel/plugin-proposal-optional-chaining": "^7.9.0",

packages/core/README.md

@@ -12,13 +12,16 @@ yarn add @ringcentral-integration/core
 
  The decorator `storage` depends on `Storage` Module, And  The decorator `globalStorage` depends on `GlobalStorage` Module.
 
+> If you use `@computed(callback)`, you should make sure that the return value of its callback function is an Array of dependency collections.
+
 For example:
 
 ```js
 import {
   RcModuleV2,
   state,
   action,
+  computed,
 } from '@ringcentral-integration/core';
 
 class Auth extends RcModuleV2 {
@@ -27,7 +30,12 @@ class Auth extends RcModuleV2 {
 
   @action
   changeConnection(connected) {
-    this.state.connected = connected;
+    this.connected = connected;
+  }
+
+  @computed(({ connected }: Auth) => [connected])
+  get permissions() {
+      return { writeable: this.connected, readable: true };
   }
 }
 ```
@@ -124,36 +132,7 @@ class Auth extends RcModuleV2 {
 
   @action
   changeConnection(connected) {
-    this.state.connected = connected;
-  }
-}
-```
-
-### Harmony with old RcModule
-
-Handle `initialize` and `constructor` with `RcModuleV2`.
-
-```js
-class Phone extends RcModule {
-  constructor(params) {
-    super(params);
-    // ...omit
-    for (const [key, value] of Object.entries(params)) {
-      if (value instanceof RcModuleV2) {
-        value.parentModule = this;
-        value.__key__ = key;
-      }
-    }
-    // ...omit
-  }
-
-  initialize() {
-    // ...omit
-    for (const value of Object.values(this)) {
-      if (value instanceof RcModuleV2) {
-        value.initModule();
-      }
-    }
+    this.connected = connected;
   }
 }
 ```

packages/core/enums/moduleStatuses.ts

@@ -1,6 +1,6 @@
-import { createEnum } from 'usm/lib/utils/enum';
+import { ObjectMap } from '../lib/ObjectMap';
 
-export const moduleStatuses = createEnum(
+export const moduleStatuses = ObjectMap.prefixKeys(
   ['pending', 'initializing', 'ready', 'resetting'],
   'module',
 );

packages/core/lib/ObjectMap/ObjectMap.ts

@@ -3,6 +3,7 @@ import { find } from 'ramda';
 const sDefinition = Symbol('definition');
 const RUNTIME = {
   usingFactory: false,
+  prefixCache: new Map(),
 };
 
 function factory<T>(
@@ -13,7 +14,7 @@ function factory<T>(
   const baseFunction = descriptor.value;
   return {
     ...descriptor,
-    value(this: ThisType<T>, ...args) {
+    value(this: ThisType<T>, ...args: any) {
       RUNTIME.usingFactory = true;
       const result = baseFunction.call(this, ...args);
       RUNTIME.usingFactory = false;
@@ -22,13 +23,13 @@ function factory<T>(
   };
 }
 
-export type ObjectMapKey<D> = D extends ObjectMap<infer K, infer V, infer T> &
-  infer T
+export type ObjectMapKey<D> = D extends ObjectMap<infer D, infer K, infer V> &
+  infer D
   ? K
   : never;
 
-export type ObjectMapValue<D> = D extends ObjectMap<infer K, infer V, infer T> &
-  infer T
+export type ObjectMapValue<D> = D extends ObjectMap<infer D, infer K, infer V> &
+  infer D
   ? V
   : never;
 
@@ -37,13 +38,13 @@ export function prefixString(str: string, prefix: string = ''): string {
 }
 
 export class ObjectMap<
-  K extends keyof T,
-  V extends T[K],
-  T extends Record<string | number, any>
+  D extends Record<string | number, any>,
+  K extends keyof D,
+  V extends D[K]
 > {
   private readonly [sDefinition] = new Map();
 
-  constructor(definition: T) {
+  constructor(definition: D) {
     if (!RUNTIME.usingFactory) {
       throw TypeError(
         'Instantiating ObjectMap with `new ObjectMap(definition)` is not recommended. ' +
@@ -67,42 +68,39 @@ export class ObjectMap<
 
   @factory
   static fromObject<
-    K extends keyof T,
-    V extends T[K],
-    T extends Record<string | number, any>
-  >(definition: T) {
-    return new ObjectMap(definition) as ObjectMap<K, V, T> & T;
+    D extends Record<string | number, any>,
+    K extends keyof D,
+    V extends D[K]
+  >(definition: D) {
+    return new ObjectMap(definition) as ObjectMap<D, K, V> & D;
   }
 
   @factory
-  static fromKeys<T extends string>(keys: T[]) {
-    const definition = {} as Record<T, T>;
+  static fromKeys<K extends string>(keys: K[]) {
+    const definition = {} as Record<K, K>;
     for (const key of keys) {
       definition[key] = key;
     }
-    return new ObjectMap(definition) as ObjectMap<T, T, { [K in T]: K }> &
-      { [K in T]: K };
+    return new ObjectMap(definition) as ObjectMap<{ [V in K]: V }, K, K> &
+      { [V in K]: V };
   }
 
   @factory
-  static prefixKeys<T extends string, K extends T>(
-    keys: K[],
-    prefix: string = '',
-  ) {
+  static prefixKeys<K extends string>(keys: K[], prefix: string = '') {
     const definition = {} as Record<K, string>;
     for (const key of keys) {
       definition[key] = prefixString(key, prefix);
     }
     return new ObjectMap(definition) as ObjectMap<
+      { [V in K]: string },
       K,
-      string,
-      { [V in K]: string }
+      string
     > &
       { [V in K]: string };
   }
 
-  static getKey<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static getKey<D, K extends keyof D, V extends D[K]>(
+    instance: ObjectMap<D, K, V> & D,
     value: V,
   ): K {
     const [key = null] =
@@ -111,48 +109,75 @@ export class ObjectMap<
     return key;
   }
 
-  static entries<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static entries<D, K extends keyof D, V extends D[K]>(
+    instance: ObjectMap<D, K, V> & D,
   ): IterableIterator<[K, V]> {
     return instance[sDefinition].entries();
   }
 
-  static size<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static size<K extends keyof D, V extends D[K], D>(
+    instance: ObjectMap<D, K, V> & D,
   ): number {
     return instance[sDefinition].size;
   }
 
-  static has<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static has<K extends keyof D, V extends D[K], D>(
+    instance: ObjectMap<D, K, V> & D,
     key: K,
   ): boolean {
     return instance[sDefinition].has(key);
   }
 
-  static hasValue<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static hasValue<D, K extends keyof D, V extends D[K]>(
+    instance: ObjectMap<D, K, V> & D,
     value: V,
   ): boolean {
     return !!ObjectMap.getKey(instance, value);
   }
 
-  static keys<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static keys<D, K extends keyof D, V extends D[K]>(
+    instance: ObjectMap<D, K, V> & D,
   ): IterableIterator<K> {
     return instance[sDefinition].keys();
   }
 
-  static values<K extends keyof T, V extends T[K], T>(
-    instance: ObjectMap<K, V, T> & T,
+  static values<D, K extends keyof D, V extends D[K]>(
+    instance: ObjectMap<D, K, V> & D,
   ): IterableIterator<V> {
     return instance[sDefinition].values();
   }
 
-  static forEach<K extends keyof T, V extends T[K], T>(
-    fn: (value: V, key: K, map: ObjectMap<K, V, T> & T) => void,
-    instance: ObjectMap<K, V, T> & T,
+  static forEach<D, K extends keyof D, V extends D[K]>(
+    fn: (value: V, key: K, map: ObjectMap<D, K, V> & D) => void,
+    instance: ObjectMap<D, K, V> & D,
   ): void {
     return instance[sDefinition].forEach((v, k) => fn(v, k, instance));
   }
+
+  static prefixValues<
+    D extends Record<K, string>,
+    K extends keyof D,
+    V extends D[K]
+  >(instance: ObjectMap<D, K, V> & D, prefix = '') {
+    if (prefix === '') {
+      return instance;
+    }
+    if (!RUNTIME.prefixCache.has(prefix)) {
+      RUNTIME.prefixCache.set(prefix, new Map());
+    }
+    if (!RUNTIME.prefixCache.get(prefix).has(instance)) {
+      const definition = {} as Record<K, string>;
+      ObjectMap.forEach((value, key) => {
+        definition[key] = prefixString(value, prefix);
+      }, instance);
+      const prefixedInstance = ObjectMap.fromObject(definition);
+      RUNTIME.prefixCache.get(prefix).set(instance, prefixedInstance);
+    }
+    return RUNTIME.prefixCache.get(prefix).get(instance) as ObjectMap<
+      { [V in K]: string },
+      K,
+      string
+    > &
+      { [V in K]: string };
+  }
 }