Add registry as base of store & manager

src/manager.ts

@@ -1,13 +1,12 @@
-import { IListenable, KeyPart, ListenEventRecord, multiplexerMap } from '@jujulego/event-tree';
+import { KeyPart } from '@jujulego/event-tree';
 
 import { query$, QueryRef, QueryStrategy } from './refs/index.js';
-import { WeakStore } from './utils/weak-store.js';
+import { Registry, registry$ } from './registry.js';
 
 // Types
 export type ManagerFetcher<K extends KeyPart, D> = (key: K) => PromiseLike<D>;
-export type ManagerEventMap<K extends KeyPart, D> = ListenEventRecord<K, QueryRef<D>>;
 
-export interface Manager<K extends KeyPart, D> extends IListenable<ManagerEventMap<K, D>> {
+export interface Manager<K extends KeyPart, D> extends Registry<K, QueryRef<D>> {
   /**
    * Returns a reference on the "key" element.
    *
@@ -26,27 +25,14 @@ export interface Manager<K extends KeyPart, D> extends IListenable<ManagerEventM
 
 // Builder
 export function manager$<K extends KeyPart, D>(fetcher: ManagerFetcher<K, D>): Manager<K, D> {
-  // Ref management
-  const refs = new WeakStore<K, QueryRef<D>>();
+  const registry = registry$<K, QueryRef<D>>((key) => query$(() => fetcher(key)));
 
-  function getRef(key: K): QueryRef<D> {
-    return refs.getOrCreate(key, () => query$(() => fetcher(key)));
-  }
-
-  // Store
-  const events = multiplexerMap(getRef);
-
-  return {
-    on: events.on,
-    off: events.off,
-    clear: events.clear,
-
-    ref: getRef,
+  return Object.assign(registry, {
     refresh(key: K, strategy: QueryStrategy): QueryRef<D> {
-      const ref = getRef(key);
+      const ref = registry.ref(key);
       ref.refresh(strategy);
 
       return ref;
     }
-  };
+  });
 }

src/registry.ts

@@ -0,0 +1,57 @@
+import { IListenable, KeyPart, ListenEventRecord, multiplexerMap } from '@jujulego/event-tree';
+
+import { Ref } from './refs/index.js';
+import { WeakStore } from './utils/weak-store.js';
+
+// Types
+export type RegistryFn<K extends KeyPart, R extends Ref<unknown>> = (key: K) => R;
+export type RegistryEventMap<K extends KeyPart, R extends Ref<unknown>> = ListenEventRecord<K, R>;
+
+export interface Registry<K extends KeyPart, R extends Ref<unknown>> extends IListenable<RegistryEventMap<K, R>> {
+  /**
+   * Returns a reference on the "key" element.
+   *
+   * @param key
+   * @param lazy if true will not create a reference if none exists
+   */
+  ref(key: K): R;
+
+  /**
+   * Returns a reference on the "key" element.
+   *
+   * @param key
+   * @param lazy if true will not create a reference if none exists
+   */
+  ref(key: K, lazy: false): R;
+
+  /**
+   * Returns a reference on the "key" element.
+   *
+   * @param key
+   * @param lazy if true will not create a reference if none exists
+   */
+  ref(key: K, lazy: boolean): R | undefined;
+}
+
+// Builder
+export function registry$<K extends KeyPart, R extends Ref<unknown>>(fn: RegistryFn<K, R>): Registry<K, R> {
+  // Ref management
+  const refs = new WeakStore<K, R>();
+
+  function getRef(key: K): R {
+    return refs.getOrCreate(key, () => fn(key));
+  }
+
+  // Store
+  const events = multiplexerMap(getRef);
+
+  return {
+    on: events.on,
+    off: events.off,
+    clear: events.clear,
+
+    ref(key: K, lazy = false) {
+      return lazy ? refs.get(key) : getRef(key);
+    },
+  } as Registry<K, R>;
+}

src/stores/store.ts

@@ -1,21 +1,12 @@
-import { IListenable, KeyPart, multiplexerMap } from '@jujulego/event-tree';
+import { KeyPart } from '@jujulego/event-tree';
 
 import { MutableRef } from '../refs/index.js';
-import { WeakStore } from '../utils/weak-store.js';
+import { Registry, registry$, RegistryFn } from '../registry.js';
 
 // Types
-export type StoreEventMap<K extends KeyPart, D> = Record<K, D>;
-
-export type StoreFn<K extends KeyPart, D, A = D, R extends MutableRef<D, A> = MutableRef<D, A>> = (key: K) => R;
-
-export interface Store<K extends KeyPart, D, A = D, R extends MutableRef<D, A> = MutableRef<D, A>> extends IListenable<StoreEventMap<K, D>> {
-  /**
-   * Returns a reference on the "key" element.
-   *
-   * @param key
-   */
-  ref(key: K): R;
+export type StoreFn<K extends KeyPart, R extends MutableRef<unknown, unknown>> = RegistryFn<K, R>;
 
+export interface Store<K extends KeyPart, D, A = D, R extends MutableRef<D, A> = MutableRef<D, A>> extends Registry<K, R> {
   /**
    * Mutates the "key" element, using the given arg.
    * Return a reference on the mutated element.
@@ -36,35 +27,22 @@ export interface Store<K extends KeyPart, D, A = D, R extends MutableRef<D, A> =
 }
 
 // Builder
-export function store$<K extends KeyPart, D, A = D, R extends MutableRef<D, A> = MutableRef<D, A>>(fn: StoreFn<K, D, A, R>): Store<K, D, A, R> {
-  // Ref management
-  const refs = new WeakStore<K, R>();
-
-  function getRef(key: K): R {
-    return refs.getOrCreate(key, () => fn(key));
-  }
-
-  // Store
-  const events = multiplexerMap(getRef);
-
-  return {
-    on: events.on,
-    off: events.off,
-    clear: events.clear,
+export function store$<K extends KeyPart, D, A = D, R extends MutableRef<D, A> = MutableRef<D, A>>(fn: StoreFn<K, R>): Store<K, D, A, R> {
+  const registry = registry$(fn);
 
-    ref: getRef,
+  return Object.assign(registry, {
     mutate(key: K, arg: A): R {
-      const ref = getRef(key);
+      const ref = registry.ref(key);
       ref.mutate(arg);
 
       return ref;
     },
     trigger(key: K, data: D): void {
-      const ref = refs.get(key);
+      const ref = registry.ref(key, true);
 
       if (ref) {
         ref.next(data);
       }
     }
-  };
+  });
 }