fix stores package imports from atoms package

packages/atoms/package.json

@@ -17,16 +17,6 @@
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js",
       "default": "./dist/cjs/index.js"
-    },
-    "./factories": {
-      "import": "./dist/esm/factories",
-      "require": "./dist/cjs/factories",
-      "default": "./dist/cjs/factories"
-    },
-    "./utils": {
-      "import": "./dist/esm/utils",
-      "require": "./dist/cjs/utils",
-      "default": "./dist/cjs/utils"
     }
   },
   "files": [

packages/atoms/src/classes/index.ts

@@ -4,6 +4,8 @@ export * from './templates/AtomTemplate'
 export * from './templates/AtomTemplateBase'
 export * from './AtomApi'
 export * from './Ecosystem'
-export * from './GraphNode'
+export { ExternalNode, GraphNode } from './GraphNode'
+export * from './MappedSignal'
 export * from './SelectorInstance'
+export * from './SignalInstance'
 export * from './ZeduxPlugin'

packages/atoms/src/index.ts

@@ -1,6 +1,31 @@
+import {
+  destroyNodeFinish,
+  destroyNodeStart,
+  scheduleDependents,
+} from './classes/GraphNode'
+import { createInjector } from './factories/createInjector'
+import {
+  destroyBuffer,
+  flushBuffer,
+  getEvaluationContext,
+  startBuffer,
+} from './utils/evaluationContext'
+
 export * from '@zedux/core'
 export * from './classes/index'
 export * from './factories/index'
 export * from './injectors/index'
 export { getEcosystem, getInternals, setInternals, wipe } from './store/index'
 export * from './types/index'
+
+// These are very obfuscated on purpose. Don't use! They're for Zedux packages.
+export const zi = {
+  b: destroyNodeStart,
+  c: createInjector,
+  d: destroyBuffer,
+  e: destroyNodeFinish,
+  f: flushBuffer,
+  g: getEvaluationContext,
+  s: startBuffer,
+  u: scheduleDependents,
+}

packages/atoms/src/utils/general.ts

@@ -23,6 +23,8 @@ export const OutOfRange = 8 // not a flag; use a value bigger than any flag
 /**
  * The InternalEvaluationTypes. These get translated to user-friendly
  * EvaluationTypes by `ecosytem.why`.
+ *
+ * IMPORTANT! Keep these in sync with `@zedux/stores/atoms-port.ts`
  */
 export const Invalidate = 1
 export const Destroy = 2

packages/atoms/tsconfig.json

@@ -3,5 +3,5 @@
   "compilerOptions": {
     "lib": ["DOM", "ESNext"]
   },
-  "include": ["../stores", "./src", "./test", "../../global.d.ts"]
+  "include": ["./src", "./test", "../../global.d.ts"]
 }

packages/stores/src/AtomApi.ts

@@ -1,6 +1,6 @@
+import { AtomInstanceTtl, Prettify } from '@zedux/atoms'
 import { is, Store } from '@zedux/core'
-import { AtomInstanceTtl, Prettify } from '@zedux/atoms/types/index'
-import { prefix } from '@zedux/atoms/utils/general'
+import { prefix } from './atoms-port'
 import { AtomApiGenerics } from './types'
 
 export class AtomApi<G extends AtomApiGenerics> {

packages/stores/src/AtomInstance.ts

@@ -15,41 +15,28 @@ import {
   AnyAtomGenerics,
 } from './types'
 import {
+  AtomInstance as NewAtomInstance,
   Cleanup,
+  Ecosystem,
   ExportsInfusedSetter,
   PromiseState,
   PromiseStatus,
-  DehydrationFilter,
-  NodeFilter,
-  DehydrationOptions,
   InternalEvaluationReason,
   ExplicitEvents,
   Transaction,
-} from '@zedux/atoms/types/index'
-import { Invalidate, prefix, PromiseChange } from '@zedux/atoms/utils/general'
-import { pluginActions } from '@zedux/atoms/utils/plugin-actions'
+  ZeduxPlugin,
+  zi,
+} from '@zedux/atoms'
+import { AtomApi } from './AtomApi'
 import {
+  Invalidate,
+  prefix,
+  PromiseChange,
   getErrorPromiseState,
   getInitialPromiseState,
   getSuccessPromiseState,
-} from '@zedux/atoms/utils/promiseUtils'
-import { InjectorDescriptor } from '@zedux/atoms/utils/types'
-import { Ecosystem } from '@zedux/atoms/classes/Ecosystem'
-import { AtomApi } from './AtomApi'
-import { AtomInstance as NewAtomInstance } from '@zedux/atoms/classes/instances/AtomInstance'
-import { AtomTemplateBase } from '@zedux/atoms/classes/templates/AtomTemplateBase'
-import {
-  destroyNodeFinish,
-  destroyNodeStart,
-  normalizeNodeFilter,
-  scheduleDependents,
-} from '@zedux/atoms/classes/GraphNode'
-import {
-  destroyBuffer,
-  flushBuffer,
-  getEvaluationContext,
-  startBuffer,
-} from '@zedux/atoms/utils/evaluationContext'
+  InjectorDescriptor,
+} from './atoms-port'
 import { AtomTemplate } from './AtomTemplate'
 
 const StoreState = 1
@@ -144,7 +131,7 @@ export class AtomInstance<
    * @see GraphNode.destroy
    */
   public destroy(force?: boolean) {
-    if (!destroyNodeStart(this, force)) return
+    if (!zi.b(this, force)) return
 
     // Clean up effect injectors first, then everything else
     const nonEffectInjectors: InjectorDescriptor[] = []
@@ -160,7 +147,7 @@ export class AtomInstance<
     })
     this._subscription?.unsubscribe()
 
-    destroyNodeFinish(this)
+    zi.e(this)
   }
 
   /**
@@ -228,76 +215,11 @@ export class AtomInstance<
     meta?: any
   ): G['State'] => this.store.setStateDeep(settable, meta)
 
-  /**
-   * @see GraphNode.d
-   */
-  public d(options?: DehydrationFilter) {
-    if (!this.f(options)) return
-
-    const { t } = this
-    const state = this.get()
-    const transform =
-      (typeof options === 'object' &&
-        !is(options, AtomTemplateBase) &&
-        (options as DehydrationOptions).transform) ??
-      true
-
-    return transform && t.dehydrate ? t.dehydrate(state) : state
-  }
-
-  /**
-   * @see GraphNode.f
-   */
-  public f(options?: NodeFilter) {
-    const { id, t } = this
-    const lowerCaseId = id.toLowerCase()
-    const {
-      exclude = [],
-      excludeFlags = [],
-      include = [],
-      includeFlags = [],
-    } = normalizeNodeFilter(options)
-
-    if (
-      exclude.some(templateOrKey =>
-        typeof templateOrKey === 'string'
-          ? lowerCaseId.includes(templateOrKey.toLowerCase())
-          : is(templateOrKey, AtomTemplateBase) &&
-            t.key === (templateOrKey as AtomTemplateBase).key
-      ) ||
-      excludeFlags.some(flag => t.flags?.includes(flag))
-    ) {
-      return false
-    }
-
-    if (
-      (!include.length && !includeFlags.length) ||
-      include.some(templateOrKey =>
-        typeof templateOrKey === 'string'
-          ? lowerCaseId.includes(templateOrKey.toLowerCase())
-          : is(templateOrKey, AtomTemplateBase) &&
-            t.key === (templateOrKey as AtomTemplateBase).key
-      ) ||
-      includeFlags.some(flag => t.flags?.includes(flag))
-    ) {
-      return true
-    }
-
-    return false
-  }
-
-  /**
-   * @see GraphNode.h
-   */
-  public h(val: any) {
-    this.setState(this.t.hydrate ? this.t.hydrate(val) : val)
-  }
-
   /**
    * @see GraphNode.j
    */
   public j() {
-    const { n, s } = getEvaluationContext()
+    const { n, s } = zi.g()
     this._nextInjectors = []
     this._isEvaluating = true
 
@@ -308,7 +230,7 @@ export class AtomInstance<
     // real ideal is to move off stores completely in favor of signals.
     Store._scheduler = this.e._scheduler
 
-    startBuffer(this)
+    zi.s(this)
 
     try {
       const newFactoryResult = this._eval()
@@ -361,7 +283,7 @@ export class AtomInstance<
         injector.cleanup?.()
       })
 
-      destroyBuffer(n, s)
+      zi.d(n, s)
 
       throw err
     } finally {
@@ -389,7 +311,7 @@ export class AtomInstance<
 
     if (this.l !== 'Initializing') {
       // let this.i flush updates after status is set to Active
-      flushBuffer(n, s)
+      zi.f(n, s)
     }
   }
 
@@ -472,11 +394,11 @@ export class AtomInstance<
     oldState: G['State'] | undefined,
     action: ActionChain
   ) {
-    scheduleDependents({ p: oldState, r: this.w, s: this }, false)
+    zi.u({ p: oldState, r: this.w, s: this }, false)
 
     if (this.e._mods.stateChanged) {
       this.e.modBus.dispatch(
-        pluginActions.stateChanged({
+        ZeduxPlugin.actions.stateChanged({
           action,
           node: this,
           newState,
@@ -527,7 +449,7 @@ export class AtomInstance<
     const state: PromiseState<any> = getInitialPromiseState(currentState?.data)
     this._promiseStatus = state.status
 
-    scheduleDependents({ s: this, t: PromiseChange }, true, true)
+    zi.u({ s: this, t: PromiseChange }, true, true)
 
     return state as unknown as G['State']
   }

packages/stores/src/IonTemplate.ts

@@ -1,5 +1,4 @@
-import { injectAtomGetters } from '@zedux/atoms/injectors/injectAtomGetters'
-import { AtomConfig } from '@zedux/atoms/types/index'
+import { AtomConfig, injectAtomGetters } from '@zedux/atoms'
 import { AtomInstance } from './AtomInstance'
 import { AtomTemplate } from './AtomTemplate'
 import { ion } from './ion'

packages/stores/src/atom.ts

@@ -1,5 +1,5 @@
-import { Store, StoreStateType } from '@zedux/core'
 import { AtomConfig, AtomApiPromise, PromiseState } from '@zedux/atoms'
+import { Store, StoreStateType } from '@zedux/core'
 import { AtomApi } from './AtomApi'
 import { AtomTemplate, AtomTemplateRecursive } from './AtomTemplate'
 import { AtomValueOrFactory } from './types'

packages/stores/src/atoms-port.ts

@@ -0,0 +1,52 @@
+// This file contains lots of code and types duplicated from the `@zedux/atoms`
+// package. This is the best way to get them in the `tsc` build without breaking
+// type compatibility with the external `@zedux/atoms` package. That breakage
+// happens when we give TS a `@zedux/atoms` `paths` alias and let it pull in
+// duplicated classes e.g. in `dist/esm/atoms/classes/...`
+import { PromiseState } from '@zedux/atoms'
+
+export type InjectorDescriptor<T = any> = T extends undefined
+  ? {
+      cleanup?: () => void
+      result?: T
+      type: string
+    }
+  : {
+      cleanup?: () => void
+      result: T
+      type: string
+    }
+
+export const prefix = '@@zedux'
+
+/**
+ * IMPORTANT! Keep these in sync with `@zedux/atoms/utils/general.ts`
+ */
+export const Invalidate = 1
+export const Destroy = 2
+export const PromiseChange = 3
+export const EventSent = 4
+
+export const getErrorPromiseState = <T>(error: Error): PromiseState<T> => ({
+  error,
+  isError: true,
+  isLoading: false,
+  isSuccess: false,
+  status: 'error',
+})
+
+export const getInitialPromiseState = <T>(data?: T): PromiseState<T> => ({
+  data,
+  isError: false,
+  isLoading: true,
+  isSuccess: false,
+  status: 'loading' as const,
+})
+
+export const getSuccessPromiseState = <T>(data: T): PromiseState<T> => ({
+  data,
+  isError: false,
+  isLoading: false,
+  isSuccess: true,
+  status: 'success',
+})

packages/stores/src/injectPromise.ts

@@ -1,18 +1,19 @@
-import { injectEffect, injectMemo, injectRef } from '@zedux/atoms'
-import { detailedTypeof, RecursivePartial, Store } from '@zedux/core'
-import {
-  getErrorPromiseState,
-  getInitialPromiseState,
-  getSuccessPromiseState,
-} from '@zedux/atoms/utils/promiseUtils'
 import {
+  injectEffect,
+  injectMemo,
   InjectorDeps,
   InjectPromiseConfig,
+  injectRef,
   InjectStoreConfig,
+  injectWhy,
   PromiseState,
-} from '@zedux/atoms/types/index'
-import { Invalidate } from '@zedux/atoms/utils/general'
-import { readInstance } from '@zedux/atoms/utils/evaluationContext'
+} from '@zedux/atoms'
+import { detailedTypeof, RecursivePartial, Store } from '@zedux/core'
+import {
+  getErrorPromiseState,
+  getInitialPromiseState,
+  getSuccessPromiseState,
+} from './atoms-port'
 import { AtomApi } from './AtomApi'
 import { api } from './api'
 import { injectStore } from './injectStore'
@@ -109,7 +110,7 @@ export const injectPromise: {
   if (
     runOnInvalidate &&
     // injectWhy is an unrestricted injector - using it conditionally is fine:
-    readInstance().w.some(reason => reason.t === Invalidate)
+    injectWhy().some(reason => reason.type === 'cache invalidated')
   ) {
     refs.current.counter++
   }