atom.io 0.27.2 → 0.27.4

package/json/dist/index.js

@@ -1,7 +1,9 @@
 import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
 export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-JRENM6KL.js';
+import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, IMPLICIT, createSelectorFamily, growMoleculeInStore, initFamilyMemberInStore, seekInStore } from 'atom.io/internal';
+import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
 
 // json/src/entries.ts
 function fromEntries(entries) {
@@ -19,52 +21,54 @@ var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
     store
   );
 };
-function selectJsonFamily(family, transform, store = IMPLICIT.STORE) {
-  const jsonFamily = createSelectorFamily(
+function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+  const jsonFamily = createWritableSelectorFamily(
     {
-      key: `${family.key}:JSON`,
+      key: `${atomFamilyToken.key}:JSON`,
       get: (key) => ({ seek, get }) => {
-        const existingState = seek(family, key);
+        const existingState = seek(atomFamilyToken, key);
         if (existingState) {
           return transform.toJson(get(existingState));
         }
         const stringKey = stringifyJson(key);
         const molecule = store.molecules.get(stringKey);
         if (molecule) {
-          const atom = growMoleculeInStore(molecule, family, store);
+          const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
           return transform.toJson(get(atom));
         }
         if (store.config.lifespan === `immortal`) {
           throw new Error(`No molecule found for key "${stringKey}"`);
         }
-        const newToken = initFamilyMemberInStore(family, key, store);
+        const newToken = initFamilyMemberInStore(atomFamilyToken, key, store);
         return transform.toJson(get(newToken));
       },
       set: (key) => ({ seek, set }, newValue) => {
-        const existingState = seek(family, key);
+        const existingState = seek(atomFamilyToken, key);
         if (existingState) {
           set(existingState, transform.fromJson(newValue));
         } else {
           const stringKey = stringifyJson(key);
           const molecule = store.molecules.get(stringKey);
           if (molecule) {
-            const atom = growMoleculeInStore(molecule, family, store);
+            const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
             set(atom, transform.fromJson(newValue));
           } else {
             if (store.config.lifespan === `immortal`) {
               throw new Error(`No molecule found for key "${stringKey}"`);
             }
             set(
-              initFamilyMemberInStore(family, key, store),
+              initFamilyMemberInStore(atomFamilyToken, key, store),
               transform.fromJson(newValue)
             );
           }
         }
       }
     },
-    store
+    store,
+    [`mutable`, `json`]
   );
-  family.subject.subscribe(
+  const atomFamily = withdraw(atomFamilyToken, store);
+  atomFamily.subject.subscribe(
     `store=${store.config.name}::json-selector-family`,
     (event) => {
       if (event.token.family) {

package/json/src/select-json-family.ts

@@ -1,13 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
 import {
-	createSelectorFamily,
 	growMoleculeInStore,
 	IMPLICIT,
 	initFamilyMemberInStore,
 	seekInStore,
+	withdraw,
 } from "atom.io/internal"
 
+import { createWritableSelectorFamily } from "../../internal/src/families/create-writable-selector-family"
 import type { Canonical, Json, JsonInterface } from "."
 import { parseJson, stringifyJson } from "."
 
@@ -16,70 +17,70 @@ export function selectJsonFamily<
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	atomFamily: AtomIO.MutableAtomFamily<T, J, K>,
+	atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>,
 	transform: JsonInterface<T, J>,
 	store: Store,
-): AtomIO.WritableSelectorFamily<J, K>
+): AtomIO.WritableSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	atomFamily: AtomIO.RegularAtomFamily<T, K>,
+	atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
 	store: Store,
-): AtomIO.WritableSelectorFamily<J, K>
+): AtomIO.WritableSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	family:
-		| AtomIO.MutableAtomFamily<T extends Transceiver<any> ? T : never, J, K>
-		| AtomIO.RegularAtomFamily<T, K>,
+	atomFamilyToken:
+		| AtomIO.MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, J, K>
+		| AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.WritableSelectorFamily<J, K> {
-	const jsonFamily = createSelectorFamily<J, K>(
+): AtomIO.WritableSelectorFamilyToken<J, K> {
+	const jsonFamily = createWritableSelectorFamily<J, K>(
 		{
-			key: `${family.key}:JSON`,
+			key: `${atomFamilyToken.key}:JSON`,
 			get:
 				(key) =>
 				({ seek, get }) => {
-					const existingState = seek(family, key)
+					const existingState = seek(atomFamilyToken, key)
 					if (existingState) {
 						return transform.toJson(get(existingState))
 					}
 					const stringKey = stringifyJson(key)
 					const molecule = store.molecules.get(stringKey)
 					if (molecule) {
-						const atom = growMoleculeInStore(molecule, family, store)
+						const atom = growMoleculeInStore(molecule, atomFamilyToken, store)
 						return transform.toJson(get(atom))
 					}
 					if (store.config.lifespan === `immortal`) {
 						throw new Error(`No molecule found for key "${stringKey}"`)
 					}
-					const newToken = initFamilyMemberInStore(family, key, store)
+					const newToken = initFamilyMemberInStore(atomFamilyToken, key, store)
 					return transform.toJson(get(newToken))
 				},
 			set:
 				(key) =>
 				({ seek, set }, newValue) => {
-					const existingState = seek(family, key)
+					const existingState = seek(atomFamilyToken, key)
 					if (existingState) {
 						set(existingState, transform.fromJson(newValue))
 					} else {
 						const stringKey = stringifyJson(key)
 						const molecule = store.molecules.get(stringKey)
 						if (molecule) {
-							const atom = growMoleculeInStore(molecule, family, store)
+							const atom = growMoleculeInStore(molecule, atomFamilyToken, store)
 							set(atom, transform.fromJson(newValue))
 						} else {
 							if (store.config.lifespan === `immortal`) {
 								throw new Error(`No molecule found for key "${stringKey}"`)
 							}
 							set(
-								initFamilyMemberInStore(family, key, store),
+								initFamilyMemberInStore(atomFamilyToken, key, store),
 								transform.fromJson(newValue),
 							)
 						}
@@ -87,8 +88,10 @@ export function selectJsonFamily<
 				},
 		},
 		store,
+		[`mutable`, `json`],
 	)
-	family.subject.subscribe(
+	const atomFamily = withdraw(atomFamilyToken, store)
+	atomFamily.subject.subscribe(
 		`store=${store.config.name}::json-selector-family`,
 		(event) => {
 			if (event.token.family) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.27.2",
+  "version": "0.27.4",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -59,30 +59,30 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.0.1",
-    "@typescript-eslint/rule-tester": "8.0.1",
+    "@typescript-eslint/parser": "8.1.0",
+    "@typescript-eslint/rule-tester": "8.1.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
     "drizzle-kit": "0.24.0",
     "drizzle-orm": "0.33.0",
     "eslint": "9.9.0",
-    "framer-motion": "11.3.24",
+    "framer-motion": "11.3.28",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.23.1",
+    "preact": "10.23.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.0",
+    "react-router-dom": "6.26.1",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
     "tsx": "4.17.0",
     "typescript": "5.5.4",
-    "vite": "5.4.0",
+    "vite": "5.4.1",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },

package/realtime-server/dist/index.d.ts

@@ -112,7 +112,7 @@ declare function redactTransactionUpdateContent(visibleStateKeys: string[], upda
 declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyToken<{
     occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[];
 }, string>;
-declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "id" | "epoch" | "updates" | "output">[], string>;
+declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
 declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, string>;
 declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;

package/src/atom.ts

@@ -1,4 +1,4 @@
-import type { Store, Subject, Transceiver } from "atom.io/internal"
+import type { Transceiver } from "atom.io/internal"
 import {
 	createAtomFamily,
 	createStandaloneAtom,
@@ -6,13 +6,7 @@ import {
 } from "atom.io/internal"
 import type { Canonical, Json, JsonInterface } from "atom.io/json"
 
-import type {
-	AtomToken,
-	MutableAtomToken,
-	RegularAtomToken,
-	StateCreation,
-	StateDisposal,
-} from "."
+import type { AtomToken, MutableAtomToken, RegularAtomToken } from "."
 
 export type Effectors<T> = {
 	setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
@@ -74,14 +68,6 @@ export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	__T?: T
 	__K?: K
 }
-// biome-ignore format: intersection
-export type RegularAtomFamily<T, K extends Canonical> = 
-	& RegularAtomFamilyToken<T, K>
-	& {
-		(key: K): RegularAtomToken<T>
-		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
-		install: (store: Store) => void
-	}
 
 // biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
@@ -108,23 +94,7 @@ export type MutableAtomFamilyToken<
 	__J?: J
 	__K?: K
 }
-// biome-ignore format: intersection
-export type MutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
-> = 
-	& JsonInterface<T, J>
-	& MutableAtomFamilyToken<T, J, K>
-	& {
-			(key: K): MutableAtomToken<T, J>
-			subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
-			install: (store: Store) => void
-		}
 
-export type AtomFamily<T, K extends Canonical = Canonical> =
-	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
-	| RegularAtomFamily<T, K>
 export type AtomFamilyToken<T, K extends Canonical = Canonical> =
 	| MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K>
 	| RegularAtomFamilyToken<T, K>

package/src/index.ts

@@ -1,11 +1,9 @@
 import type { Transceiver } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
 
-import type { AtomFamily, AtomFamilyToken } from "./atom"
+import type { AtomFamilyToken } from "./atom"
 import type {
-	SelectorFamily,
 	SelectorFamilyToken,
-	WritableSelectorFamily,
 	WritableSelectorFamilyToken,
 } from "./selector"
 
@@ -61,13 +59,6 @@ export type SelectorToken<T> =
 export type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>
 export type ReadableToken<T> = AtomToken<T> | SelectorToken<T>
 
-export type WritableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| WritableSelectorFamily<T, K>
-export type ReadableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| SelectorFamily<T, K>
-
 export type WritableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| WritableSelectorFamilyToken<T, K>

package/src/logger.ts

@@ -52,12 +52,16 @@ const LoggerIconDictionary = {
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
+	| `atom_family`
 	| `atom`
 	| `continuity`
 	| `molecule_family`
 	| `molecule`
+	| `mutable_atom_family`
 	| `mutable_atom`
+	| `readonly_selector_family`
 	| `readonly_selector`
+	| `selector_family`
 	| `selector`
 	| `state`
 	| `timeline`

package/src/selector.ts

@@ -1,4 +1,3 @@
-import type { Store, Subject } from "atom.io/internal"
 import {
 	createSelectorFamily,
 	createStandaloneSelector,
@@ -7,7 +6,7 @@ import {
 import type { Canonical } from "atom.io/json"
 
 import type { ReadonlySelectorToken, WritableSelectorToken } from "."
-import type { Read, StateCreation, StateDisposal, Write } from "./transaction"
+import type { Read, Write } from "./transaction"
 
 export type WritableSelectorOptions<T> = {
 	key: string
@@ -48,15 +47,6 @@ export type WritableSelectorFamilyToken<T, K extends Canonical> = {
 	__K?: K
 }
 
-// biome-ignore format: intersection
-export type WritableSelectorFamily<T, K extends Canonical> = 
-	& WritableSelectorFamilyToken<T, K> 
-	& {
-		(key: K): WritableSelectorToken<T>
-		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
-		install: (store: Store) => void
-	}
-
 export type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
 	key: string
 	type: `readonly_selector_family`
@@ -64,21 +54,6 @@ export type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
 	__K?: K
 }
 
-// biome-ignore format: intersection
-export type ReadonlySelectorFamily<T, K extends Canonical> = 
-	& ((key: K) => ReadonlySelectorToken<T>)
-	& {
-		key: string
-		type: `readonly_selector_family`
-		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
-		install: (store: Store) => void
-		__T?: T
-		__K?: K
-	}
-
-export type SelectorFamily<T, K extends Canonical> =
-	| ReadonlySelectorFamily<T, K>
-	| WritableSelectorFamily<T, K>
 export type SelectorFamilyToken<T, K extends Canonical> =
 	| ReadonlySelectorFamilyToken<T, K>
 	| WritableSelectorFamilyToken<T, K>

package/src/silo.ts

@@ -24,13 +24,13 @@ import type {
 	getState,
 	makeMolecule,
 	moleculeFamily,
-	MutableAtomFamily,
 	MutableAtomFamilyOptions,
+	MutableAtomFamilyToken,
 	MutableAtomOptions,
 	MutableAtomToken,
 	redo,
-	RegularAtomFamily,
 	RegularAtomFamilyOptions,
+	RegularAtomFamilyToken,
 	RegularAtomOptions,
 	RegularAtomToken,
 	setState,
@@ -74,15 +74,17 @@ export class Silo {
 			T extends Transceiver<any>,
 			J extends Json.Serializable,
 			K extends Canonical,
-		>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>
+		>(
+			options: MutableAtomFamilyOptions<T, J, K>,
+		): MutableAtomFamilyToken<T, J, K>
 		function _atomFamily<T, K extends Canonical>(
 			options: RegularAtomFamilyOptions<T, K>,
-		): RegularAtomFamily<T, K>
+		): RegularAtomFamilyToken<T, K>
 		function _atomFamily<T, K extends Canonical>(
 			options:
 				| MutableAtomFamilyOptions<any, any, any>
 				| RegularAtomFamilyOptions<T, K>,
-		): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+		): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
 			return createAtomFamily(options, s)
 		}
 		this.store = s