feat(core): create scope

To replace `Transient` and `Singleton` patterns.

Author: runjuu

src/core/index.ts

@@ -3,3 +3,4 @@ export * from './ikari'
 export * from './types'
 export * from './decorators'
 export * from './utils'
+export * from './scope'

src/core/scope/__test__/scope.spec.ts

@@ -0,0 +1,55 @@
+import { getInstanceWithScope, TransientScope } from '../'
+import { createNewInstance, createOrGetInstanceInScope } from '../utils'
+
+describe('Scope spec:', () => {
+  describe('createNewInstance', () => {
+    it('should always return new instance', () => {
+      class Test {}
+
+      expect(createNewInstance(Test)).toBeInstanceOf(Test)
+      expect(createNewInstance(Test) === createNewInstance(Test)).toBeFalsy()
+    })
+  })
+
+  describe('createOrGetInstanceInScope', () => {
+    class Test {}
+    const scope = 'Scope'
+
+    it('should create a new instance if not in scope', () => {
+      expect(createOrGetInstanceInScope(Test, scope)).toBeInstanceOf(Test)
+    })
+
+    it('should return a same instance if in scope', () => {
+      expect(createOrGetInstanceInScope(Test, scope)).toBe(createOrGetInstanceInScope(Test, scope))
+    })
+  })
+
+  describe('getInstanceWithScope', () => {
+    it('should accept any valid variable as scope', () => {
+      const scopes = ['', 0, Symbol('symbol'), {}, null]
+
+      scopes.forEach((scope) => {
+        class Test {}
+        expect(getInstanceWithScope(Test, { scope })).toBeInstanceOf(Test)
+      })
+    })
+
+    it('should always return same instance if same scope', () => {
+      const scope = 'scope'
+      class Test {}
+
+      expect(getInstanceWithScope(Test, { scope })).toBe(getInstanceWithScope(Test, { scope }))
+    })
+
+    it('should always return new instance if scope is TransientScope', () => {
+      class Test {}
+
+      expect(getInstanceWithScope(Test, { scope: TransientScope })).toBeInstanceOf(Test)
+
+      expect(
+        getInstanceWithScope(Test, { scope: TransientScope }) ===
+          getInstanceWithScope(Test, { scope: TransientScope }),
+      ).toBeFalsy()
+    })
+  })
+})

src/core/scope/index.ts

@@ -0,0 +1,25 @@
+import { InjectableFactory } from '@asuka/di'
+import { get } from 'lodash'
+
+import { ConstructorOf } from '../types'
+import { ScopeConfig } from './type'
+import { createNewInstance, createOrGetInstanceInScope } from './utils'
+
+export { ScopeConfig }
+
+export const TransientScope = Symbol('scope:transient')
+
+export const SingletonScope = Symbol('scope:singleton')
+
+export function getInstanceWithScope<T>(constructor: ConstructorOf<T>, config?: ScopeConfig): T {
+  const scope = get(config, 'scope', SingletonScope)
+
+  switch (scope) {
+    case SingletonScope:
+      return InjectableFactory.getInstance(constructor)
+    case TransientScope:
+      return createNewInstance(constructor)
+    default:
+      return createOrGetInstanceInScope(constructor, scope)
+  }
+}

src/core/scope/type.ts

@@ -0,0 +1,5 @@
+export type Scope = any
+
+export interface ScopeConfig {
+  scope: Scope
+}

src/core/scope/utils.ts

@@ -0,0 +1,43 @@
+import { InjectableFactory } from '@asuka/di'
+
+import { ConstructorOf } from '../types'
+import { Scope } from './type'
+
+type ScopeMap<K, V> = Map<K, V>
+
+type Instance = any
+
+type Key = ConstructorOf<Instance>
+
+const map: Map<Key, ScopeMap<Scope, Instance>> = new Map()
+
+export function createNewInstance<T>(constructor: ConstructorOf<T>): T {
+  return InjectableFactory.injector.resolveAndCreateChild([constructor]).get(constructor)
+}
+
+export function createOrGetInstanceInScope<T>(constructor: ConstructorOf<T>, scope: Scope): T {
+  const instanceAtScope = getInstanceFrom(constructor, scope)
+
+  return instanceAtScope ? instanceAtScope : createInstanceInScope(constructor, scope)
+}
+
+function createInstanceInScope<T>(constructor: ConstructorOf<T>, scope: Scope): T {
+  const newInstance = createNewInstance(constructor)
+
+  setInstanceInScope(constructor, scope, newInstance)
+
+  return newInstance
+}
+
+function setInstanceInScope<T>(constructor: ConstructorOf<T>, scope: Scope, newInstance: Instance) {
+  const scopeMap: ScopeMap<Scope, Instance> = map.get(constructor) || new Map()
+
+  scopeMap.set(scope, newInstance)
+  map.set(constructor, scopeMap)
+}
+
+function getInstanceFrom<T>(constructor: ConstructorOf<T>, scope: Scope): T | undefined {
+  const scopeMap = map.get(constructor)
+
+  return scopeMap && scopeMap.get(scope)
+}

src/hooks.ts

@@ -1,7 +1,13 @@
-import { InjectableFactory } from '@asuka/di'
 import * as React from 'react'
 
-import { Ayanami, combineWithIkari, ActionMethodOfAyanami, ConstructorOf } from './core'
+import {
+  Ayanami,
+  combineWithIkari,
+  getInstanceWithScope,
+  ScopeConfig,
+  ActionMethodOfAyanami,
+  ConstructorOf,
+} from './core'
 
 export type HooksResult<M extends Ayanami<S>, S> = [Readonly<S>, ActionMethodOfAyanami<M, S>]
 
@@ -18,9 +24,10 @@ export function useAyanamiInstance<M extends Ayanami<S>, S>(ayanami: M): HooksRe
 }
 
 export function useAyanami<M extends Ayanami<S>, S>(
-  constructor: ConstructorOf<M>,
+  A: ConstructorOf<M>,
+  config?: ScopeConfig,
 ): M extends Ayanami<infer SS> ? HooksResult<M, SS> : HooksResult<M, S> {
-  const ayanami = React.useMemo(() => InjectableFactory.getInstance(constructor), [constructor])
+  const ayanami = React.useMemo(() => getInstanceWithScope(A, config), [A])
 
   return useAyanamiInstance<M, S>(ayanami) as any
 }