teamplay 0.4.0 → 0.5.0-alpha.1

package/orm/rootContext.js

@@ -1,313 +0,0 @@
-import { observable } from '@nx-js/observer-util'
-import { normalizeRootId } from './rootScope.js'
-import { getDefaultFetchOnly } from './connection.js'
-
-const ROOT_CONTEXTS = new Map()
-const CLOSED_ROOT_CONTEXTS = new Set()
-const EMPTY_SET = new Set()
-const EMPTY_MAP = new Map()
-const RUNTIME_KIND_QUERY = 'query'
-const RUNTIME_KIND_AGGREGATION = 'aggregation'
-
-export default class RootContext {
-  constructor (rootId, { fetchOnly } = {}) {
-    this.rootId = normalizeRootId(rootId)
-    this.fetchOnly = fetchOnly == null ? getDefaultFetchOnly() : !!fetchOnly
-    this.privateDataRaw = {}
-    this.privateData = observable(this.privateDataRaw)
-    this.refLinks = new Map()
-    this.activeRefs = new Map()
-    this.modelListeners = {
-      change: new Map(),
-      all: new Map()
-    }
-    this.queryRuntimeHashes = new Set()
-    this.aggregationRuntimeHashes = new Set()
-    this.signalHashes = new Set()
-    this.directDocSubscriptions = new Map()
-  }
-
-  getModelEventStore (eventName, create = false) {
-    let store = this.modelListeners[eventName]
-    if (!store && create) {
-      store = new Map()
-      this.modelListeners[eventName] = store
-    }
-    return store
-  }
-
-  getFetchOnly () {
-    return !!this.fetchOnly
-  }
-
-  setFetchOnly (value) {
-    this.fetchOnly = !!value
-  }
-
-  getPrivateDataRoot () {
-    return this.privateData
-  }
-
-  getPrivateDataRawRoot () {
-    return this.privateDataRaw
-  }
-
-  getPrivateDataAt (segments) {
-    return getPath(segments, this.privateData)
-  }
-
-  getPrivateDataRawAt (segments) {
-    return getPath(segments, this.privateDataRaw)
-  }
-
-  setPrivateDataAt (segments, value) {
-    setPath(segments, value, this.privateData)
-  }
-
-  delPrivateDataAt (segments) {
-    delPath(segments, this.privateData)
-  }
-
-  getRuntimeHashes (kind) {
-    switch (kind) {
-      case RUNTIME_KIND_QUERY:
-        return this.queryRuntimeHashes
-      case RUNTIME_KIND_AGGREGATION:
-        return this.aggregationRuntimeHashes
-      default:
-        throw Error(`Unsupported root-owned runtime kind: ${kind}`)
-    }
-  }
-
-  registerRuntime (kind, runtimeHash) {
-    if (runtimeHash == null) return
-    this.getRuntimeHashes(kind).add(runtimeHash)
-  }
-
-  unregisterRuntime (kind, runtimeHash) {
-    if (runtimeHash == null) return
-    this.getRuntimeHashes(kind).delete(runtimeHash)
-  }
-
-  registerSignalHash (signalHash) {
-    if (signalHash == null) return
-    this.signalHashes.add(signalHash)
-  }
-
-  unregisterSignalHash (signalHash) {
-    if (signalHash == null) return
-    this.signalHashes.delete(signalHash)
-  }
-
-  registerDirectDocSubscription (hash, segments, token) {
-    if (hash == null) return
-    let entry = this.directDocSubscriptions.get(hash)
-    if (!entry) {
-      entry = {
-        segments: [...segments],
-        count: 0,
-        tokenCounts: new Map()
-      }
-      this.directDocSubscriptions.set(hash, entry)
-    }
-    entry.count += 1
-    if (token != null) {
-      entry.tokenCounts.set(token, (entry.tokenCounts.get(token) || 0) + 1)
-    }
-  }
-
-  unregisterDirectDocSubscription (hash, token) {
-    const entry = this.directDocSubscriptions.get(hash)
-    if (!entry) return
-    entry.count = Math.max(entry.count - 1, 0)
-    if (token != null) {
-      const nextTokenCount = (entry.tokenCounts.get(token) || 0) - 1
-      if (nextTokenCount > 0) entry.tokenCounts.set(token, nextTokenCount)
-      else entry.tokenCounts.delete(token)
-    }
-    if (entry.count === 0) this.directDocSubscriptions.delete(hash)
-  }
-
-  resetRefs () {
-    this.refLinks.clear()
-  }
-
-  resetActiveRefs () {
-    this.activeRefs.clear()
-  }
-
-  resetModelListeners () {
-    for (const store of Object.values(this.modelListeners)) {
-      store.clear()
-    }
-  }
-
-  resetRuntimeHashes () {
-    this.queryRuntimeHashes.clear()
-    this.aggregationRuntimeHashes.clear()
-  }
-
-  resetPrivateData () {
-    this.privateDataRaw = {}
-    this.privateData = observable(this.privateDataRaw)
-  }
-
-  resetSignalHashes () {
-    this.signalHashes.clear()
-  }
-
-  resetDirectDocSubscriptions () {
-    this.directDocSubscriptions.clear()
-  }
-
-  isRuntimeEmpty () {
-    return (
-      isPlainObjectEmpty(this.privateData) &&
-      this.refLinks.size === 0 &&
-      this.activeRefs.size === 0 &&
-      Object.values(this.modelListeners).every(store => store.size === 0) &&
-      this.queryRuntimeHashes.size === 0 &&
-      this.aggregationRuntimeHashes.size === 0 &&
-      this.signalHashes.size === 0 &&
-      this.directDocSubscriptions.size === 0
-    )
-  }
-}
-
-export function getRootContext (rootId, create = true, options = {}) {
-  const normalizedRootId = normalizeRootId(rootId)
-  if (create && CLOSED_ROOT_CONTEXTS.has(normalizedRootId)) return undefined
-  let context = ROOT_CONTEXTS.get(normalizedRootId)
-  if (!context && create) {
-    context = new RootContext(normalizedRootId, options)
-    ROOT_CONTEXTS.set(normalizedRootId, context)
-  }
-  return context
-}
-
-export function getRootContexts () {
-  return ROOT_CONTEXTS.values()
-}
-
-export function registerRootOwnedRuntime (rootId, kind, runtimeHash) {
-  getRootContext(rootId, true).registerRuntime(kind, runtimeHash)
-}
-
-export function unregisterRootOwnedRuntime (rootId, kind, runtimeHash) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.unregisterRuntime(kind, runtimeHash)
-}
-
-export function getRootOwnedRuntimeHashes (rootId, kind) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_SET
-  return context.getRuntimeHashes(kind)
-}
-
-export function registerRootOwnedSignalHash (rootId, signalHash) {
-  getRootContext(rootId, true).registerSignalHash(signalHash)
-}
-
-export function getRootOwnedSignalHashes (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_SET
-  return context.signalHashes
-}
-
-export function clearRootOwnedSignalHashes (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.resetSignalHashes()
-}
-
-export function registerRootOwnedDirectDocSubscription (rootId, hash, segments, token) {
-  getRootContext(rootId, true).registerDirectDocSubscription(hash, segments, token)
-}
-
-export function unregisterRootOwnedDirectDocSubscription (rootId, hash, token) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.unregisterDirectDocSubscription(hash, token)
-}
-
-export function getRootOwnedDirectDocSubscriptions (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return EMPTY_MAP
-  return context.directDocSubscriptions
-}
-
-export function clearRootOwnedDirectDocSubscriptions (rootId) {
-  const context = getRootContext(rootId, false)
-  if (!context) return
-  context.resetDirectDocSubscriptions()
-}
-
-export function deleteRootContext (rootId) {
-  const normalizedRootId = normalizeRootId(rootId)
-  ROOT_CONTEXTS.delete(normalizedRootId)
-  CLOSED_ROOT_CONTEXTS.add(normalizedRootId)
-}
-
-export function reviveRootContext (rootId) {
-  CLOSED_ROOT_CONTEXTS.delete(normalizeRootId(rootId))
-}
-
-export function isRootContextClosed (rootId) {
-  return CLOSED_ROOT_CONTEXTS.has(normalizeRootId(rootId))
-}
-
-export function __getRootContextForTests (rootId) {
-  return getRootContext(rootId, false)
-}
-
-export function __resetRootContextsForTests () {
-  ROOT_CONTEXTS.clear()
-  CLOSED_ROOT_CONTEXTS.clear()
-}
-
-function getPath (segments, dataNode) {
-  for (const segment of segments) {
-    if (dataNode == null) return dataNode
-    dataNode = dataNode[segment]
-  }
-  return dataNode
-}
-
-function setPath (segments, value, tree) {
-  if (!Array.isArray(segments) || segments.length === 0) {
-    throw Error('setPrivateDataAt requires a non-empty segments array')
-  }
-  let dataNode = tree
-  for (let i = 0; i < segments.length - 1; i++) {
-    const segment = segments[i]
-    const next = dataNode[segment]
-    if (next == null || typeof next !== 'object') {
-      dataNode[segment] = {}
-    }
-    dataNode = dataNode[segment]
-  }
-  dataNode[segments[segments.length - 1]] = value
-}
-
-function delPath (segments, tree) {
-  if (!Array.isArray(segments) || segments.length === 0) return
-  const parents = []
-  let dataNode = tree
-  for (let i = 0; i < segments.length - 1; i++) {
-    if (dataNode == null) return
-    parents.push([dataNode, segments[i]])
-    dataNode = dataNode[segments[i]]
-  }
-  if (dataNode == null) return
-  delete dataNode[segments[segments.length - 1]]
-  for (let i = parents.length - 1; i >= 0; i--) {
-    const [parent, segment] = parents[i]
-    if (!isPlainObjectEmpty(parent[segment])) break
-    delete parent[segment]
-  }
-}
-
-function isPlainObjectEmpty (value) {
-  return value != null && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0
-}

package/orm/rootScope.js

@@ -1,51 +0,0 @@
-import { GLOBAL_ROOT_ID } from './Root.js'
-
-const REGEX_PRIVATE_COLLECTION = /^[_$]/
-
-export function normalizeRootId (rootId) {
-  return rootId ?? GLOBAL_ROOT_ID
-}
-
-export function isGlobalRootId (rootId) {
-  return normalizeRootId(rootId) === GLOBAL_ROOT_ID
-}
-
-export function isPrivateCollectionSegments (segments) {
-  return Array.isArray(segments) &&
-    segments.length > 0 &&
-    REGEX_PRIVATE_COLLECTION.test(String(segments[0]))
-}
-
-export function getPrivateDataSegments (logicalSegments) {
-  if (!isPrivateCollectionSegments(logicalSegments)) return logicalSegments
-  return [...logicalSegments]
-}
-
-export function getLogicalRootSnapshot (rootId, tree, privateDataRoot) {
-  const snapshot = {}
-  for (const key of Object.keys(tree)) {
-    snapshot[key] = tree[key]
-  }
-  if (!privateDataRoot || typeof privateDataRoot !== 'object') return snapshot
-  for (const key of Object.keys(privateDataRoot)) {
-    snapshot[key] = privateDataRoot[key]
-  }
-  return snapshot
-}
-
-export function getSignalIdentityHash (rootId, segments) {
-  const normalizedRootId = normalizeRootId(rootId)
-  if (segments.length === 0) return JSON.stringify({ root: normalizedRootId })
-  if (isPrivateCollectionSegments(segments)) {
-    return JSON.stringify({ private: [normalizedRootId, segments] })
-  }
-  return JSON.stringify({ public: [normalizedRootId, segments] })
-}
-
-export function getScopedSignalHash (rootId, transportHash, kind = 'querySignal') {
-  return JSON.stringify({ [kind]: [normalizeRootId(rootId), transportHash] })
-}
-
-export function getRootScopedRegistryKey (rootId, key) {
-  return JSON.stringify([normalizeRootId(rootId), key])
-}

package/orm/sub.js

@@ -1,151 +0,0 @@
-import { isAggregationHeader, isAggregationFunction, isClientAggregationFunction } from '@teamplay/utils/aggregation'
-import Signal, { SEGMENTS, isPublicCollectionSignal, isPublicDocumentSignal } from './Signal.js'
-import { docSubscriptions } from './Doc.js'
-import { querySubscriptions, getQuerySignal } from './Query.js'
-import { aggregationSubscriptions, getAggregationSignal } from './Aggregation.js'
-import { getRoot } from './Root.js'
-import isServer from '../utils/isServer.js'
-
-export default function sub ($signal, params) {
-  // TODO: temporarily disable support for multiple subscriptions
-  //       since this has to be properly cached using useDeferredSignal() in useSub()
-  // if (Array.isArray($signal)) {
-  //   const res = $signal.map(args => Array.isArray(args) ? sub(...args) : sub(args))
-  //   if (res.some($s => $s.then)) return Promise.all(res)
-  //   return res
-  // }
-  if (Array.isArray($signal)) throw Error('sub() does not support multiple subscriptions yet')
-  if (isPublicDocumentSignal($signal)) {
-    if (arguments.length > 1) throw Error(ERRORS.subDocArguments(...arguments))
-    return doc$($signal)
-  } else if (isPublicCollectionSignal($signal)) {
-    if (arguments.length !== 2) throw Error(ERRORS.subQueryArguments(...arguments))
-    return query$($signal, params)
-  } else if (isClientAggregationFunction($signal)) {
-    return getAggregationFromFunction($signal, $signal.collection, params)
-  } else if (isAggregationHeader($signal)) {
-    params = {
-      $aggregationName: $signal.name,
-      $params: sanitizeAggregationParams(params)
-    }
-    return aggregation$($signal.collection, params)
-  } else if (isAggregationFunction($signal)) {
-    if (isServer) {
-      if (!params?.$collection) throw Error(ERRORS.subServerAggregationCollection($signal, params))
-      params = { ...params }
-      const collection = params.$collection
-      delete params.$collection
-      return getAggregationFromFunction($signal, collection, params)
-    } else {
-      throw Error(ERRORS.gotAggregationFunction($signal))
-    }
-  } else if (typeof $signal === 'function' && !($signal instanceof Signal)) {
-    return api$($signal, params)
-  } else {
-    throw Error('Invalid args passed for sub()')
-  }
-}
-
-function getAggregationFromFunction (fn, collection, params) {
-  params = sanitizeAggregationParams(params) // clones it, so mutation becomes safe
-  let session
-  if (params.$session) {
-    session = params.$session
-    delete params.$session
-  }
-  session ??= {}
-  // should match the context in @teamplay/backend/features/serverAggregate.js
-  const context = { collection, session, isServer }
-  params = fn(params, context)
-  if (Array.isArray(params)) params = { $aggregate: params }
-  return aggregation$(collection, params)
-}
-
-function doc$ ($doc) {
-  const promise = docSubscriptions.subscribe($doc)
-  if (!promise) return $doc
-  return new Promise(resolve => promise.then(() => resolve($doc)))
-}
-
-function query$ ($collection, params) {
-  const collectionName = $collection[SEGMENTS][0]
-  if (typeof params !== 'object') throw Error(ERRORS.queryParamsObject(collectionName, params))
-  const signalOptions = getQuerySignalOptions($collection)
-  if (params?.$aggregate || params?.$aggregationName) return aggregation$(collectionName, params, signalOptions)
-  const $query = getQuerySignal(collectionName, params, signalOptions)
-  const promise = querySubscriptions.subscribe($query)
-  if (!promise) return $query
-  return new Promise(resolve => promise.then(() => resolve($query)))
-}
-
-function aggregation$ (collectionName, params, signalOptions) {
-  const $aggregationQuery = getAggregationSignal(collectionName, params, signalOptions)
-  const promise = aggregationSubscriptions.subscribe($aggregationQuery)
-  if (!promise) return $aggregationQuery
-  return new Promise(resolve => promise.then(() => resolve($aggregationQuery)))
-}
-
-function api$ (fn, args) {
-  throw Error('sub() for async functions is not implemented yet')
-}
-
-// aggregation params get transferred to the server
-// and while doing so if some value is 'undefined', it actually gets transferred as 'null'
-// which breaks logic of setting default values in the aggregation function.
-// That's why we have to explicitly remove 'undefined' values from the aggregation params.
-// This can be easily done by serializing and deserializing it to JSON.
-function sanitizeAggregationParams (params) {
-  return JSON.parse(JSON.stringify(params))
-}
-
-function getQuerySignalOptions ($collection) {
-  const $root = getRoot($collection)
-  if (!$root) return undefined
-  return { root: $root }
-}
-
-const ERRORS = {
-  subDocArguments: ($signal, ...args) => `
-    sub($doc) accepts only 1 argument - the document signal to subscribe to
-    Doc: ${$signal[SEGMENTS]}
-    Got args: ${[$signal, ...args]}
-  `,
-  subQueryArguments: ($signal, params, ...args) => `
-    sub($collection, params) accepts 2 arguments - the collection signal and an object with query params.
-    If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
-    Collection: ${$signal[SEGMENTS]}
-    Params: ${params}
-    Got args: ${[$signal, params, ...args]}
-  `,
-  queryParamsObject: (collectionName, params) => `
-    sub($collection, params):
-      Params must be an object.
-      If you want to subscribe to all documents in a collection, pass an empty object: sub($collection, {}).
-
-      Got:
-        collectionName: ${collectionName}
-        params: ${params}
-  `,
-  gotAggregationFunction: aggregationFn => `
-    sub($$aggregation, params):
-      Got aggregation function itself instead of the aggregation header.
-      Looks like client-side code transformation did not work properly and your
-      aggregation() function was not transformed into an __aggregationHeader().
-      Make sure you only use aggregation() function inside project's 'model' folder using
-      import { aggregation } from 'startupjs'
-
-      Got:
-        ${aggregationFn.toString()}
-  `,
-  subServerAggregationCollection: ($signal, params) => `
-    sub($$aggregation, params):
-      Server-side aggregation function must receive the collection name from the params.
-      Make sure you pass the collection name as $collection in the params object
-      when running aggregation from the server code:
-      sub($$aggregation, { $collection: 'collectionName', ...actualParams })
-
-      Got:
-        Aggregation: ${$signal}
-        Params: ${params}
-  `
-}

package/orm/subscriptionGcDelay.js

@@ -1,32 +0,0 @@
-import { isCompatEnv } from './compatEnv.js'
-
-const DEFAULT_COMPAT_SUBSCRIPTION_GC_DELAY = 3000
-const DEFAULT_SUBSCRIPTION_GC_DELAY = 0
-
-let subscriptionGcDelay = getDefaultSubscriptionGcDelay()
-
-export function getSubscriptionGcDelay () {
-  return subscriptionGcDelay
-}
-
-export function setSubscriptionGcDelay (ms) {
-  if (ms == null) {
-    subscriptionGcDelay = getDefaultSubscriptionGcDelay()
-    return subscriptionGcDelay
-  }
-  if (typeof ms !== 'number' || !Number.isFinite(ms) || ms < 0) {
-    throw Error('setSubscriptionGcDelay() expects a non-negative finite number')
-  }
-  subscriptionGcDelay = ms
-  return subscriptionGcDelay
-}
-
-export function getDefaultSubscriptionGcDelay () {
-  return isCompatEnv()
-    ? DEFAULT_COMPAT_SUBSCRIPTION_GC_DELAY
-    : DEFAULT_SUBSCRIPTION_GC_DELAY
-}
-
-export function __resetSubscriptionGcDelayForTests () {
-  subscriptionGcDelay = getDefaultSubscriptionGcDelay()
-}

package/react/compatComponentRegistry.js

@@ -1,20 +0,0 @@
-const compatComponentIds = new Set()
-
-export function markCompatComponent (componentId) {
-  if (!componentId) return
-  compatComponentIds.add(componentId)
-}
-
-export function unmarkCompatComponent (componentId) {
-  if (!componentId) return
-  compatComponentIds.delete(componentId)
-}
-
-export function isCompatComponent (componentId) {
-  if (!componentId) return false
-  return compatComponentIds.has(componentId)
-}
-
-export function __resetCompatComponentRegistryForTests () {
-  compatComponentIds.clear()
-}

package/react/convertToObserver.js

@@ -1,117 +0,0 @@
-import { forwardRef as _forwardRef, useRef } from 'react'
-import { observe, unobserve } from '@nx-js/observer-util'
-import _throttle from 'lodash/throttle.js'
-import { createCaches, getDummyCache } from '@teamplay/cache'
-import { __increment, __decrement } from '@teamplay/debug'
-import executionContextTracker from './executionContextTracker.js'
-import { pipeComponentMeta, useUnmount, useId, useTriggerUpdate } from './helpers.js'
-import trapRender from './trapRender.js'
-import { scheduleReaction } from '../orm/batchScheduler.js'
-import { isCompatComponent, unmarkCompatComponent } from './compatComponentRegistry.js'
-
-const DEFAULT_THROTTLE_TIMEOUT = 100
-
-export default function convertToObserver (BaseComponent, {
-  forwardRef,
-  cache: enableCache = true,
-  throttle,
-  ...options
-} = {}) {
-  throttle = normalizeThrottle(throttle)
-  // MAGIC. This fixes hot-reloading. TODO: figure out WHY it fixes it
-  // const random = Math.random()
-
-  // memo; we are not intested in deep updates
-  // in props; we assume that if deep objects are changed,
-  // this is in observables, which would have been tracked anyway
-  let Component = (...args) => {
-    const [cache, destroyCache] = useCreateCacheRef(enableCache)
-    const componentId = useId()
-    const triggerUpdate = useTriggerUpdate()
-
-    // wrap the BaseComponent into an observe decorator once.
-    // This way it will track any observable changes and will trigger rerender
-    const reactionRef = useRef()
-    const destroyRef = useRef()
-    if (!reactionRef.current) {
-      let hasDeferredUpdateAfterExecutionContext = false
-      let update = () => {
-        // It's important to block updates caused by rendering itself
-        // (when the sync rendering is in progress).
-        if (!executionContextTracker.isActive()) {
-          hasDeferredUpdateAfterExecutionContext = false
-          triggerUpdate()
-        } else if (isCompatComponent(componentId)) {
-          if (hasDeferredUpdateAfterExecutionContext) return
-          hasDeferredUpdateAfterExecutionContext = true
-          queueMicrotask(() => {
-            if (!hasDeferredUpdateAfterExecutionContext) return
-            if (executionContextTracker.isActive()) return
-            hasDeferredUpdateAfterExecutionContext = false
-            update()
-          })
-        }
-      }
-      if (throttle) update = _throttle(update, throttle)
-      destroyRef.current = (where) => {
-        if (!reactionRef.current) throw Error(`NO REACTION REF - ${where}`)
-        destroyRef.current = undefined
-        unmarkCompatComponent(componentId)
-        unobserve(reactionRef.current)
-        reactionRef.current = undefined
-        destroyCache(where)
-      }
-      const trappedRender = trapRender({
-        render: BaseComponent,
-        cache,
-        destroy: destroyRef.current,
-        componentId
-      })
-      reactionRef.current = observe(trappedRender, {
-        scheduler: () => scheduleReaction(update),
-        lazy: true
-      })
-    }
-
-    // clean up observer on unmount
-    useUnmount(() => {
-      unmarkCompatComponent(componentId)
-      destroyRef.current?.('useUnmount()')
-    })
-
-    return reactionRef.current(...args)
-  }
-
-  if (forwardRef) Component = _forwardRef(Component)
-  pipeComponentMeta(BaseComponent, Component)
-
-  return { Component, forwardRef, ...options }
-}
-
-function normalizeThrottle (throttle) {
-  if (typeof throttle === 'boolean') {
-    if (throttle) return DEFAULT_THROTTLE_TIMEOUT
-    else return undefined
-  }
-  if (typeof throttle === 'number') return throttle
-  if (throttle == null) return undefined
-  throw Error('observer(): throttle can be either boolean or number (milliseconds)')
-}
-
-function useCreateCacheRef (enableCache) {
-  const cacheRef = useRef()
-  const destroyCacheRef = useRef()
-  if (!cacheRef.current) {
-    __increment('ObserverWrapper.cache')
-    const _createCaches = enableCache ? createCaches : getDummyCache
-    cacheRef.current = _createCaches(['styles', 'model'])
-    destroyCacheRef.current = (where) => {
-      if (!cacheRef.current) throw Error(`NO CACHE REF - ${where}`)
-      __decrement('ObserverWrapper.cache')
-      cacheRef.current.clear()
-      cacheRef.current = undefined
-      destroyCacheRef.current = undefined
-    }
-  }
-  return [cacheRef.current, destroyCacheRef.current]
-}