global-store 1.0.0-beta.21 → 1.0.0-beta.23

package/ts/createStore.spec.ts

@@ -1,217 +0,0 @@
-import a from 'assertron'
-import { assertType } from 'type-plus'
-import { createStore, StoreValue } from '.'
-
-const moduleName = 'your-module'
-
-test('create with same id will get existing store', () => {
-  const key = 'same-key'
-  const version = 0
-  const initializer = () => ({ a: 1 })
-  const store1 = createStore({ moduleName, key, version, initializer })
-  const store2 = createStore({ moduleName, key, version, initializer })
-  store1.value.a = 2
-
-  expect(store2.value).toEqual({ a: 2 })
-})
-
-test('initializer of the same version is skipped', () => {
-  const key = 'skip-same-ver-init'
-  const version = 0
-  createStore({ moduleName, key, version, initializer: () => ({ a: 1 }) })
-  createStore({ moduleName, key, version, initializer: () => { throw new Error('should not reach') } })
-})
-
-test('initializer receives empty object the first time', () => {
-  let actual
-  createStore({ moduleName, key: 'init-receive-empty-obj', version: 0, initializer: previous => actual = previous })
-  expect(actual).toEqual({})
-})
-
-test('initialize receives the versions processed', () => {
-  const key = 'init-receive-versions'
-  createStore({
-    moduleName, key, version: 0, initializer: (_, versions) => {
-      expect(versions).toEqual([])
-      return {}
-    }
-  })
-  createStore({
-    moduleName, key, version: 1, initializer: (_, versions) => {
-      expect(versions).toEqual([0])
-      return {}
-    }
-  })
-  createStore({
-    moduleName, key, version: 2, initializer: (_, versions) => {
-      expect(versions).toEqual([0, 1])
-      return {}
-    }
-  })
-})
-
-test('store is typed by the initializer', () => {
-  const key = 'typed-by-initializer'
-  const store1 = createStore({
-    moduleName, key, version: 0, initializer: () => ({ a: 1 })
-  })
-  const store2 = createStore({
-    moduleName, key, version: 1, initializer: prev => ({ ...prev, b: 1 })
-  })
-  assertType.isNumber(store1.value.a)
-  assertType.isNumber(store2.value.b)
-})
-
-test('initialize input is partial T because previous version may not have the same data structure', () => {
-  const key = 'initializer-receive-partial'
-  const store = createStore<{ a: string }>({
-    moduleName, key, version: 1,
-    initializer: prev => ({
-      a: 'abc',
-      ...prev
-    })
-  })
-
-  store.value.a = '123'
-})
-
-test('store type can be overridden', () => {
-  const store = createStore<{ a: number | undefined }>({
-    moduleName, key: 'override-type', version: 0, initializer: () => ({ a: undefined })
-  })
-  assertType<number | undefined>(store.value.a)
-})
-
-test('initializer receives the previous initial value', () => {
-  const key = 'init-get-prev'
-  createStore({ moduleName, key, version: 0, initializer: () => ({ a: 1 }) })
-
-  let actual
-  createStore({ moduleName, key, version: 1, initializer: prev => actual = prev })
-
-  expect(actual).toEqual({ a: 1 })
-})
-
-test('reset() will reset object values', () => {
-  const key = 'reset-obj'
-  const store = createStore({ moduleName, key, version: 0, initializer: () => ({ a: { b: 2 } }) })
-  store.value.a.b = 3
-  store.reset()
-
-  expect(store.value.a.b).toBe(2)
-})
-
-test('call reset() on 1st store gets latest initial value', () => {
-  const key = '2nd-reset-get-1st'
-  const store1 = createStore({ moduleName, key, version: 0, initializer: () => ({ a: 1 }) })
-  createStore({ moduleName, key, version: 1, initializer: () => ({ a: 2, b: true }) })
-  store1.reset()
-  expect(store1.value).toEqual({ a: 2, b: true })
-})
-
-test('gets initial value', () => {
-  const store = createStore({ moduleName, key: 'get-all', version: 0, initializer: () => ({ a: 1, b: 'b' }) })
-  expect(store.value).toEqual({ a: 1, b: 'b' })
-})
-
-test('property reference are persisted', () => {
-  const store = createStore({ moduleName, key: 'prop-ref', version: 0, initializer: () => ({ a: { b: 1 } }) })
-  const orig = store.value
-  orig.a = { b: 3 }
-  const actual = store.value
-  expect(actual.a).toEqual(orig.a)
-})
-
-describe('freeze store', () => {
-  test('cannot add new property', () => {
-    const store = createStore<{ a: number } & StoreValue>({ moduleName, key: 'freeze-no-add', version: 0, initializer: () => ({ a: 1 }) })
-    store.freeze()
-    store.value
-    a.throws(() => store.value.b = 2, TypeError)
-  })
-
-  test('cannot be freezed again', () => {
-    const store = createStore<any>({ moduleName, key: 'freeze-no-freeze', version: 0, initializer: () => ({ a: 1 }) })
-    store.freeze()
-
-    a.throws(() => store.freeze(), TypeError)
-  })
-
-
-  test('property values are frozen', () => {
-    const store = createStore({ moduleName, key: 'prop-freeze', version: 0, initializer: () => ({ a: 1, b: true, c: 'str', d: {}, e: [] as any[] }) })
-    store.freeze()
-
-    a.throws(() => store.value.a = 2, TypeError)
-    a.throws(() => store.value.b = false, TypeError)
-    a.throws(() => store.value.c = 'abc', TypeError)
-    a.throws(() => store.value.d = { z: 1 }, TypeError)
-    a.throws(() => store.value.e = ['a'], TypeError)
-  })
-
-  test('object property is not frozen', () => {
-    const store = createStore({ moduleName, key: 'obj-not-frozen', version: 0, initializer: () => ({ a: { b: 1, c: {} } }) })
-    store.freeze()
-    store.value.a.b = 2
-    store.value.a.c = { p: 'power' }
-  })
-
-  test('array property is frozen', () => {
-    const store = createStore({ moduleName, key: 'prop-array-freeze', version: 0, initializer: () => ({ arr: [] as any[], und: undefined }) })
-    store.freeze()
-
-    a.throws(() => store.value.arr.push('a'), TypeError)
-  })
-
-  test('object in array property is not frozen', () => {
-    const store = createStore({
-      moduleName,
-      key: 'obj-in-array-not-frozen',
-      version: 0,
-      initializer: () => ({ a: [{ x: 'x' }] })
-    })
-    store.freeze()
-    store.value.a[0].x = 'y'
-  })
-
-  test('freeze provided value but not array property', () => {
-    const store = createStore({
-      moduleName,
-      key: 'not freeze array value',
-      version: 0,
-      initializer: () => ({ a: { b: 1 }, c: [{ x: 1 }] })
-    })
-
-    store.freeze(store.value)
-    a.throws(() => store.value.a = { b: 2 }, TypeError)
-    store.value.c.push({ x: 2 })
-  })
-  test('user can pre-freeze value', () => {
-    const store = createStore({
-      moduleName,
-      key: 'self freeze',
-      version: 0,
-      initializer: () => ({ a: { b: 1 } })
-    })
-
-    store.freeze(Object.freeze(store.value))
-  })
-})
-
-test('reset on freezed store will get new unfreezed value', () => {
-  const store = createStore({
-    moduleName,
-    key: 'reset on freeze',
-    version: 0,
-    initializer: () => ({ a: { b: 1 } })
-  })
-
-  store.freeze()
-  store.reset()
-  store.value.a = { b: 2 }
-})
-
-test('key is optional', () => {
-  const store = createStore({ moduleName, version: '1.0.0', initializer: () => ({ a: 1 }) })
-  expect(store.value.a).toBe(1)
-})

package/ts/createStore.ts

@@ -1,43 +0,0 @@
-import { StoreOptions, StoreValue } from './types'
-import { Stores } from './typesInternal'
-import { freezeStoreValue, getStoreValue, initStoreValue, resetStoreValue } from './util'
-
-export type Store<T extends StoreValue> = {
-  /**
-   * The store value.
-   */
-  readonly value: T,
-  /**
-   * Freezes the store value.
-   * @param value Optional new store value.
-   * If supplied, this value will be freezed and used as the store value.
-   * You can use this update the store value and freeze part of it.
-   * If not supplied,
-   * the original value will be freezed and its array property will also be freezed.
-   */
-  freeze(value?: { [k in keyof T]: Readonly<T[k]> }): void,
-  /**
-   * Resets the store to its initial value.
-   * You should only use this during testing.
-   */
-  reset(): void,
-}
-
-const stores = Object.create(null) as Stores
-
-/**
- * Creates a store of type T.
- * @see https://www.npmjs.com/package/global-store
- */
-export function createStore<
-  T extends StoreValue
->({ moduleName, key, version, initializer }: StoreOptions<T>): Store<T> {
-  const id = { moduleName, key }
-  initStoreValue(stores, id, version, initializer)
-
-  return {
-    get value() { return getStoreValue<T>(stores, id) },
-    freeze(value) { return freezeStoreValue(stores, id, value) },
-    reset() { return resetStoreValue(stores, id) }
-  }
-}

package/ts/index.spec.ts

@@ -1,7 +0,0 @@
-import defaultCreate, { createStore } from '.'
-
-describe('package', () => {
-  test('default export is `createStore`', () => {
-    expect(defaultCreate).toBe(createStore)
-  })
-})

package/ts/index.ts

@@ -1,5 +0,0 @@
-export * from './createAsyncStore'
-export * from './createStore'
-export { createStore as default } from './createStore'
-export * from './types'
-

package/ts/shouldInvokeInitializer.spec.ts

@@ -1,41 +0,0 @@
-import { shouldInvokeInitializer } from './shouldInvokeInitializer'
-
-describe('numeric version', () => {
-  test('true if no versions', () => {
-    expect(shouldInvokeInitializer([], 0)).toBeTruthy()
-  })
-
-  test('true if no match major', () => {
-    expect(shouldInvokeInitializer(['1.0.0'], 0)).toBeTruthy()
-  })
-
-  test('false if same version exist', () => {
-    expect(shouldInvokeInitializer([0], 0)).toBeFalsy()
-    expect(shouldInvokeInitializer([6], 6)).toBeFalsy()
-  })
-});
-
-describe('string version', () => {
-  test('true if no versions', () => {
-    expect(shouldInvokeInitializer([], '1.0.0')).toBeTruthy()
-  })
-
-  test('true if no match major', () => {
-    expect(shouldInvokeInitializer(['1.0.0'], '0.0.0')).toBeTruthy()
-  })
-
-  test('true if minor and patch is newer', () => {
-    expect(shouldInvokeInitializer(['1.0.0'], '1.1.0')).toBeTruthy()
-    expect(shouldInvokeInitializer(['1.0.0'], '1.0.1')).toBeTruthy()
-  })
-
-  test('false if same version exist', () => {
-    expect(shouldInvokeInitializer([0], '0.0.0')).toBeFalsy()
-    expect(shouldInvokeInitializer(['1.2.4'], '1.2.4')).toBeFalsy()
-  })
-
-  test('false if newer minor or patch already exist', () => {
-    expect(shouldInvokeInitializer(['1.1.0'], '1.0.1')).toBeFalsy()
-    expect(shouldInvokeInitializer(['1.0.2'], '1.0.1')).toBeFalsy()
-  })
-})

package/ts/shouldInvokeInitializer.ts

@@ -1,17 +0,0 @@
-import { ParsedVersion, toVersionArray } from './toVersionArray'
-import { StoreVersion } from './types'
-
-export function shouldInvokeInitializer(versions: StoreVersion[], version: StoreVersion) {
-  const vs = versions.map(toVersionArray)
-  const v = toVersionArray(version)
-  return noMatchMajor(vs, v) || hasNewVersion(vs, v)
-}
-
-function noMatchMajor(versions: ParsedVersion[], version: ParsedVersion) {
-  return !versions.some(v => v[0] === version[0])
-}
-
-function hasNewVersion(versions: ParsedVersion[], version: ParsedVersion) {
-  return versions.filter(v => v[0] === version[0])
-    .some(v => version[1] > v[1] || (version[1] === v[1] && version[2] > v[2]))
-}

package/ts/toVersionArray.ts

@@ -1,8 +0,0 @@
-import { StoreVersion } from './types'
-
-export type ParsedVersion = [number, number, number]
-
-export function toVersionArray(v: StoreVersion): ParsedVersion {
-  return typeof v === 'number' ? [0, 0, v] :
-    v.split('.').map(v => parseInt(v, 10)) as ParsedVersion
-}

package/ts/types.ts

@@ -1,12 +0,0 @@
-export type StoreValue = Record<string | symbol, unknown>
-
-export type StoreVersion = `${number}.${number}.${number}` | number
-
-export type StoreInitializer<T extends StoreValue> = (current: StoreValue, processedVersions: StoreVersion[]) => T
-
-export interface StoreOptions<T extends StoreValue> {
-  moduleName: string,
-  key?: string,
-  version: StoreVersion,
-  initializer: StoreInitializer<T>
-}

package/ts/typesInternal.ts

@@ -1,21 +0,0 @@
-import { StoreInitializer, StoreVersion, StoreValue } from './types'
-
-export interface StoreId { moduleName: string, key?: string }
-
-export type Stores = Record<
-  StoreId['moduleName'],
-  Record<
-    string,
-    { versions: StoreVersion[], initializers: StoreInitializer<StoreValue>[], value: StoreValue }
-  >
->
-
-export interface StoreCreator<S> {
-  version: StoreVersion,
-  resolve: (store: S) => void,
-  initializer: StoreInitializer<StoreValue>
-}
-
-export type StoreCreators<Store> = Record<
-  StoreId['moduleName'],
-  Record<string, Array<StoreCreator<Store>>>>

package/ts/util.ts

@@ -1,69 +0,0 @@
-import { compareVersion } from './compareVersion'
-import { createStore } from './createStore'
-import { shouldInvokeInitializer } from './shouldInvokeInitializer'
-import { StoreInitializer, StoreValue, StoreVersion } from './types'
-import { StoreCreator, StoreId, Stores } from './typesInternal'
-
-export function getStoreValue<T extends StoreValue>(stores: Stores, id: StoreId): T {
-  return getStore(stores, id).value as T
-}
-
-export function initStoreValue<T extends StoreValue>(stores: Stores, id: StoreId, version: StoreVersion, initializer: StoreInitializer<T>) {
-  const store = getStore(stores, id)
-  if (shouldInvokeInitializer(store.versions, version)) {
-    store.initializers.push(initializer as StoreInitializer<StoreValue>)
-    store.value = initializer(store.value as T, store.versions)
-    store.versions.push(version)
-  }
-}
-
-export function resetStoreValue(stores: Stores, id: StoreId) {
-  const store = getStore(stores, id)
-  const versions = store.versions
-  store.versions = []
-  store.value = store.initializers.reduce<StoreValue>((value, initializer, i) => {
-    value = initializer(value, store.versions)
-    store.versions.push(versions[i])
-    return value
-  }, {})
-}
-
-export function getStore(stores: Stores, id: StoreId) {
-  const moduleStore = stores[id.moduleName] = stores[id.moduleName] || Object.create(null)
-  const key = id.key ?? 'default'
-  return moduleStore[key] = moduleStore[key] || { versions: [], value: {}, initializers: [] }
-}
-
-export function resolveCreators(moduleName: string, key: string, storeCreators: Array<StoreCreator<any>>, cs: typeof createStore) {
-  sortByVersion(storeCreators).forEach(({ version, resolve, initializer }) => resolve(cs({ moduleName, key, version, initializer })))
-}
-
-export function sortByVersion<S>(storeCreators: Array<StoreCreator<S>>) {
-  return storeCreators.sort((a, b) => compareVersion(a.version, b.version))
-}
-
-export function freezeStoreValue(stores: Stores, id: StoreId, value?: StoreValue) {
-  const store = getStore(stores, id)
-  store.value = value ?
-    Object.isFrozen(value) ? value : Object.freeze(value) :
-    freezeValue(store.value)
-}
-
-function freezeValue(storeValue: StoreValue) {
-  if (Object.isFrozen(storeValue)) throw TypeError('Frozen value cannot be freezed again')
-
-  Object.keys(storeValue).forEach(k => freezeIfIsArray(storeValue, k))
-  // istanbul ignore next
-  if (Object.getOwnPropertySymbols) {
-    Object.getOwnPropertySymbols(storeValue).forEach(k => freezeIfIsArray(storeValue, k))
-  }
-
-  return Object.freeze(storeValue)
-}
-
-function freezeIfIsArray(storeValue: StoreValue, k: string | number | symbol) {
-  const value = storeValue[k]
-  if (Array.isArray(value)) {
-    storeValue[k] = Object.freeze(value)
-  }
-}