atom.io 0.27.4 → 0.27.5

package/realtime-server/src/realtime-continuity-synchronizer.ts

@@ -36,7 +36,7 @@ export function realtimeContinuitySynchronizer({
 			socket.id,
 			store,
 		).userKeyOfSocket
-		const userKey = getFromStore(userKeyState, store)
+		const userKey = getFromStore(store, userKeyState)
 		if (!userKey) {
 			store.logger.error(
 				`❌`,
@@ -70,8 +70,8 @@ export function realtimeContinuitySynchronizer({
 					)
 					return
 				}
-				const newSocketState = findInStore(socketAtoms, newSocketKey, store)
-				const newSocket = getFromStore(newSocketState, store)
+				const newSocketState = findInStore(store, socketAtoms, newSocketKey)
+				const newSocket = getFromStore(store, newSocketState)
 				socket = newSocket
 			},
 			`sync-continuity:${continuityKey}:${userKey}`,
@@ -79,13 +79,13 @@ export function realtimeContinuitySynchronizer({
 		)
 
 		const userUnacknowledgedQueue = findInStore(
+			store,
 			userUnacknowledgedQueues,
 			userKey,
-			store,
 		)
 		const userUnacknowledgedUpdates = getFromStore(
-			userUnacknowledgedQueue,
 			store,
+			userUnacknowledgedQueue,
 		)
 		const unsubscribeFunctions: (() => void)[] = []
 
@@ -93,7 +93,7 @@ export function realtimeContinuitySynchronizer({
 			const unsubFns: (() => void)[] = []
 			for (const perspective of continuity.perspectives) {
 				const { viewAtoms } = perspective
-				const userViewState = findInStore(viewAtoms, userKey, store)
+				const userViewState = findInStore(store, viewAtoms, userKey)
 				const unsubscribe = subscribeToState(
 					userViewState,
 					({ oldValue, newValue }) => {
@@ -107,9 +107,9 @@ export function realtimeContinuitySynchronizer({
 							.flatMap((token) => {
 								const resourceToken =
 									token.type === `mutable_atom`
-										? getJsonToken(token, store)
+										? getJsonToken(store, token)
 										: token
-								const resource = getFromStore(resourceToken, store)
+								const resource = getFromStore(store, resourceToken)
 								return [resourceToken, resource]
 							})
 						store.logger.info(
@@ -141,13 +141,13 @@ export function realtimeContinuitySynchronizer({
 			const initialPayload: Json.Serializable[] = []
 			for (const atom of continuity.globals) {
 				const resourceToken =
-					atom.type === `mutable_atom` ? getJsonToken(atom, store) : atom
-				initialPayload.push(resourceToken, getFromStore(atom, store))
+					atom.type === `mutable_atom` ? getJsonToken(store, atom) : atom
+				initialPayload.push(resourceToken, getFromStore(store, atom))
 			}
 			for (const perspective of continuity.perspectives) {
 				const { viewAtoms, resourceAtoms } = perspective
-				const userViewState = findInStore(viewAtoms, userKey, store)
-				const userView = getFromStore(userViewState, store)
+				const userViewState = findInStore(store, viewAtoms, userKey)
+				const userView = getFromStore(store, userViewState)
 				store.logger.info(`👁`, `atom`, resourceAtoms.key, `${userKey} can see`, {
 					viewAtoms,
 					resourceAtoms,
@@ -156,9 +156,9 @@ export function realtimeContinuitySynchronizer({
 				for (const visibleToken of userView) {
 					const resourceToken =
 						visibleToken.type === `mutable_atom`
-							? getJsonToken(visibleToken, store)
+							? getJsonToken(store, visibleToken)
 							: visibleToken
-					const resource = getFromStore(resourceToken, store)
+					const resource = getFromStore(store, resourceToken)
 
 					initialPayload.push(resourceToken, resource)
 				}
@@ -181,13 +181,13 @@ export function realtimeContinuitySynchronizer({
 									continuity.perspectives.flatMap((perspective) => {
 										const { viewAtoms } = perspective
 										const userPerspectiveTokenState = findInStore(
+											store,
 											viewAtoms,
 											userKey,
-											store,
 										)
 										const visibleTokens = getFromStore(
-											userPerspectiveTokenState,
 											store,
+											userPerspectiveTokenState,
 										)
 										return visibleTokens.map((token) => {
 											const key =

package/realtime-server/src/realtime-family-provider.ts

@@ -34,11 +34,11 @@ export function realtimeAtomFamilyProvider({
 		}
 
 		const fillSubRequest = (subKey: K) => {
-			const exposedSubKeys = getFromStore(index, store)
+			const exposedSubKeys = getFromStore(store, index)
 			for (const exposedSubKey of exposedSubKeys) {
 				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-					const token = findInStore(family, subKey, store)
-					socket.emit(`serve:${token.key}`, getFromStore(token, store))
+					const token = findInStore(store, family, subKey)
+					socket.emit(`serve:${token.key}`, getFromStore(store, token))
 					const unsubscribe = subscribeToState(
 						token,
 						({ newValue }) => {

package/realtime-server/src/realtime-mutable-family-provider.ts

@@ -40,14 +40,14 @@ export function realtimeMutableFamilyProvider({
 		}
 
 		const fillSubRequest = (subKey: K) => {
-			const exposedSubKeys = getFromStore(index, store)
+			const exposedSubKeys = getFromStore(store, index)
 			for (const exposedSubKey of exposedSubKeys) {
 				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-					const token = findInStore(family, subKey, store)
-					getFromStore(token, store)
-					const jsonToken = getJsonToken(token, store)
+					const token = findInStore(store, family, subKey)
+					getFromStore(store, token)
+					const jsonToken = getJsonToken(store, token)
 					const updateToken = getUpdateToken(token)
-					socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
+					socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
 					const unsubscribe = subscribeToState(
 						updateToken,
 						({ newValue }) => {

package/realtime-server/src/realtime-mutable-provider.ts

@@ -22,7 +22,7 @@ export function realtimeMutableProvider({
 	>(token: AtomIO.MutableAtomToken<Core, SerializableCore>): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null
 
-		const jsonToken = getJsonToken(token, store)
+		const jsonToken = getJsonToken(store, token)
 		const trackerToken = getUpdateToken(token)
 
 		const fillUnsubRequest = () => {
@@ -32,7 +32,7 @@ export function realtimeMutableProvider({
 		}
 
 		const fillSubRequest = () => {
-			socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
+			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
 			unsubscribeFromStateUpdates = subscribeToState(
 				trackerToken,
 				({ newValue }) => {

package/realtime-server/src/realtime-state-provider.ts

@@ -15,7 +15,7 @@ export function realtimeStateProvider({
 		let unsubscribeFromStateUpdates: (() => void) | undefined
 
 		const fillSubRequest = () => {
-			socket.emit(`serve:${token.key}`, getFromStore(token, store))
+			socket.emit(`serve:${token.key}`, getFromStore(store, token))
 
 			unsubscribeFromStateUpdates = subscribeToState(
 				token,

package/realtime-server/src/realtime-state-receiver.ts

@@ -13,7 +13,7 @@ export function realtimeStateReceiver({
 		token: WritableToken<J>,
 	): () => void {
 		const publish = (newValue: J) => {
-			setIntoStore(token, newValue, store)
+			setIntoStore(store, token, newValue)
 		}
 
 		const fillPubUnclaim = () => {

package/realtime-testing/dist/index.js

@@ -29,8 +29,8 @@ var setupRealtimeTestServer = (options) => {
   const server = new SocketIO.Server(httpServer).use((socket, next) => {
     const { token, username } = socket.handshake.auth;
     if (token === `test` && socket.id) {
-      const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store);
-      setIntoStore(socketState, socket, silo.store);
+      const socketState = findInStore(silo.store, RTS.socketAtoms, socket.id);
+      setIntoStore(silo.store, socketState, socket);
       editRelationsInStore(
         RTS.usersOfSockets,
         (relations) => {
@@ -38,8 +38,8 @@ var setupRealtimeTestServer = (options) => {
         },
         silo.store
       );
-      setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store);
-      setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store);
+      setIntoStore(silo.store, RTS.userIndex, (index) => index.add(username));
+      setIntoStore(silo.store, RTS.socketIndex, (index) => index.add(socket.id));
       console.log(`${username} connected on ${socket.id}`);
       next();
     } else {
@@ -51,10 +51,10 @@ var setupRealtimeTestServer = (options) => {
   });
   const dispose = () => {
     server.close();
-    const roomKeys = getFromStore(RT.roomIndex, silo.store);
+    const roomKeys = getFromStore(silo.store, RT.roomIndex);
     for (const roomKey of roomKeys) {
-      const roomState = findInStore(RTS.roomSelectors, roomKey, silo.store);
-      const room = getFromStore(roomState, silo.store);
+      const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey);
+      const room = getFromStore(silo.store, roomState);
       if (room && !(room instanceof Promise)) {
         room.process.kill();
       }

package/realtime-testing/src/setup-realtime-test.tsx

@@ -89,8 +89,8 @@ export const setupRealtimeTestServer = (
 	const server = new SocketIO.Server(httpServer).use((socket, next) => {
 		const { token, username } = socket.handshake.auth
 		if (token === `test` && socket.id) {
-			const socketState = findInStore(RTS.socketAtoms, socket.id, silo.store)
-			setIntoStore(socketState, socket, silo.store)
+			const socketState = findInStore(silo.store, RTS.socketAtoms, socket.id)
+			setIntoStore(silo.store, socketState, socket)
 			editRelationsInStore(
 				RTS.usersOfSockets,
 				(relations) => {
@@ -98,8 +98,8 @@ export const setupRealtimeTestServer = (
 				},
 				silo.store,
 			)
-			setIntoStore(RTS.userIndex, (index) => index.add(username), silo.store)
-			setIntoStore(RTS.socketIndex, (index) => index.add(socket.id), silo.store)
+			setIntoStore(silo.store, RTS.userIndex, (index) => index.add(username))
+			setIntoStore(silo.store, RTS.socketIndex, (index) => index.add(socket.id))
 			console.log(`${username} connected on ${socket.id}`)
 			next()
 		} else {
@@ -113,10 +113,10 @@ export const setupRealtimeTestServer = (
 
 	const dispose = () => {
 		server.close()
-		const roomKeys = getFromStore(RT.roomIndex, silo.store)
+		const roomKeys = getFromStore(silo.store, RT.roomIndex)
 		for (const roomKey of roomKeys) {
-			const roomState = findInStore(RTS.roomSelectors, roomKey, silo.store)
-			const room = getFromStore(roomState, silo.store)
+			const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
+			const room = getFromStore(silo.store, roomState)
 			if (room && !(room instanceof Promise)) {
 				room.process.kill()
 			}

package/src/atom.ts

@@ -53,7 +53,7 @@ export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
 export function atom(
 	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
 ): AtomToken<any> {
-	return createStandaloneAtom(options, IMPLICIT.STORE)
+	return createStandaloneAtom(IMPLICIT.STORE, options)
 }
 
 export type RegularAtomFamilyOptions<T, K extends Canonical> = {
@@ -112,5 +112,5 @@ export function atomFamily<T, K extends Canonical>(
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
 ): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-	return createAtomFamily(options, IMPLICIT.STORE)
+	return createAtomFamily(IMPLICIT.STORE, options)
 }

package/src/dispose-state.ts

@@ -32,8 +32,8 @@ export function disposeState(
 	key?: Json.Serializable,
 ): void {
 	if (key) {
-		Internal.disposeFromStore(token as any, key, Internal.IMPLICIT.STORE)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any, key)
 	} else {
-		Internal.disposeFromStore(token as any, Internal.IMPLICIT.STORE)
+		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any)
 	}
 }

package/src/get-state.ts

@@ -26,19 +26,15 @@ export function getState<M extends MoleculeConstructor>(
 ): InstanceType<M>
 
 export function getState(
-	token:
-		| MoleculeFamilyToken<any>
-		| MoleculeToken<any>
-		| ReadableFamilyToken<any, any>
-		| ReadableToken<any>,
-	key?: Canonical,
+	...params:
+		| [
+				token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+				key: Canonical,
+		  ]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
 ): any {
-	if (key) {
-		return Internal.getFromStore(
-			token as any,
-			key as any,
-			Internal.IMPLICIT.STORE,
-		)
+	if (params.length === 2) {
+		return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
 	}
-	return Internal.getFromStore(token as any, Internal.IMPLICIT.STORE)
+	return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
 }

package/src/molecule.ts

@@ -101,7 +101,7 @@ export type MoleculeToken<M extends MoleculeConstructor> = {
 export function moleculeFamily<M extends MoleculeConstructor>(
 	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
-	return createMoleculeFamily(options, IMPLICIT.STORE)
+	return createMoleculeFamily(IMPLICIT.STORE, options)
 }
 
 export function makeMolecule<M extends MoleculeConstructor>(

package/src/selector.ts

@@ -27,7 +27,7 @@ export function selector<T>(
 export function selector<T>(
 	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
 ): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
-	return createStandaloneSelector(options, IMPLICIT.STORE)
+	return createStandaloneSelector(IMPLICIT.STORE, options)
 }
 
 export type WritableSelectorFamilyOptions<T, K extends Canonical> = {
@@ -69,5 +69,5 @@ export function selectorFamily<T, K extends Canonical>(
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K> {
-	return createSelectorFamily(options, IMPLICIT.STORE)
+	return createSelectorFamily(IMPLICIT.STORE, options)
 }

package/src/set-state.ts

@@ -1,6 +1,5 @@
 import * as Internal from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Json } from "rel8"
 
 import type { WritableFamilyToken, WritableToken } from "."
 
@@ -32,13 +31,17 @@ export function setState<T, K extends Canonical, New extends T, Key extends K>(
 ): void
 
 export function setState<T, New extends T>(
-	token: WritableFamilyToken<T, Canonical> | WritableToken<T>,
-	p1: Json.Serializable | New | ((oldValue: T) => New),
-	p2?: New | ((oldValue: T) => New),
+	...params:
+		| [
+				token: WritableFamilyToken<T, Canonical>,
+				key: Canonical,
+				value: New | ((oldValue: T) => New),
+		  ]
+		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
-	if (p2) {
-		Internal.setIntoStore(token as any, p1 as any, p2, Internal.IMPLICIT.STORE)
+	if (params.length === 2) {
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	} else {
-		Internal.setIntoStore(token as any, p1 as any, Internal.IMPLICIT.STORE)
+		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
 	}
 }

package/src/silo.ts

@@ -1,5 +1,4 @@
 import type { findState } from "atom.io/ephemeral"
-import type { Transceiver } from "atom.io/internal"
 import {
 	createAtomFamily,
 	createMoleculeFamily,
@@ -14,30 +13,21 @@ import {
 	makeMoleculeInStore,
 	setIntoStore,
 	Store,
+	subscribeInStore,
 	timeTravel,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
 
 import type {
-	AtomToken,
 	disposeState,
 	getState,
 	makeMolecule,
 	moleculeFamily,
-	MutableAtomFamilyOptions,
-	MutableAtomFamilyToken,
-	MutableAtomOptions,
-	MutableAtomToken,
 	redo,
-	RegularAtomFamilyOptions,
-	RegularAtomFamilyToken,
-	RegularAtomOptions,
-	RegularAtomToken,
 	setState,
+	subscribe,
 	timeline,
 	undo,
 } from "."
-import { subscribe } from "."
 import type { atom, atomFamily } from "./atom"
 import type { selector, selectorFamily } from "./selector"
 import type { transaction } from "./transaction"
@@ -61,60 +51,40 @@ export class Silo {
 	public makeMolecule: typeof makeMolecule
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
 		const s = new Store(config, fromStore)
-		function _atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
-		function _atom<T extends Transceiver<any>, J extends Json.Serializable>(
-			options: MutableAtomOptions<T, J>,
-		): MutableAtomToken<T, J>
-		function _atom<T>(
-			options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
-		): AtomToken<T> {
-			return createStandaloneAtom(options, s)
-		}
-		function _atomFamily<
-			T extends Transceiver<any>,
-			J extends Json.Serializable,
-			K extends Canonical,
-		>(
-			options: MutableAtomFamilyOptions<T, J, K>,
-		): MutableAtomFamilyToken<T, J, K>
-		function _atomFamily<T, K extends Canonical>(
-			options: RegularAtomFamilyOptions<T, K>,
-		): RegularAtomFamilyToken<T, K>
-		function _atomFamily<T, K extends Canonical>(
-			options:
-				| MutableAtomFamilyOptions<any, any, any>
-				| RegularAtomFamilyOptions<T, K>,
-		): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
-			return createAtomFamily(options, s)
-		}
 		this.store = s
-		this.atom = _atom
-		this.atomFamily = _atomFamily
-		this.selector = (options) => createStandaloneSelector(options, s) as any
-		this.selectorFamily = (options) => createSelectorFamily(options, s) as any
+		this.atom = ((options: Parameters<typeof atom>[0]) =>
+			createStandaloneAtom(s, options)) as typeof atom
+		this.atomFamily = ((options: Parameters<typeof atomFamily>[0]) =>
+			createAtomFamily(s, options)) as typeof atomFamily
+		this.selector = ((options: Parameters<typeof selector>[0]) =>
+			createStandaloneSelector(s, options)) as typeof selector
+		this.selectorFamily = ((options: Parameters<typeof selectorFamily>[0]) =>
+			createSelectorFamily(s, options)) as typeof selectorFamily
 		this.transaction = (options) => createTransaction(options, s)
 		this.timeline = (options) => createTimeline(options, s)
-		this.findState = (token, key) => findInStore(token, key, s) as any
+		this.findState = ((...params: Parameters<typeof findState>) =>
+			findInStore(s, ...params)) as typeof findState
 		this.getState = ((...params: Parameters<typeof getState>) =>
-			getFromStore(...params, s)) as typeof getState
+			getFromStore(s, ...params)) as typeof getState
 		this.setState = ((...params: Parameters<typeof setState>) => {
-			setIntoStore(...params, s)
+			setIntoStore(s, ...params)
 		}) as typeof setState
 		this.disposeState = ((...params: Parameters<typeof disposeState>) => {
-			disposeFromStore(...params, s)
+			disposeFromStore(s, ...params)
 		}) as typeof disposeState
-		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
+		this.subscribe = ((...params: Parameters<typeof subscribe>) =>
+			subscribeInStore(s, ...params)) as typeof subscribe
 		this.undo = (token) => {
-			timeTravel(`undo`, token, s)
+			timeTravel(s, `undo`, token)
 		}
 		this.redo = (token) => {
-			timeTravel(`redo`, token, s)
+			timeTravel(s, `redo`, token)
 		}
-		this.moleculeFamily = ((...params: Parameters<typeof moleculeFamily>) => {
-			return createMoleculeFamily(...params, s)
-		}) as any
+		this.moleculeFamily = ((options: Parameters<typeof moleculeFamily>[0]) => {
+			return createMoleculeFamily(s, options)
+		}) as typeof moleculeFamily
 		this.makeMolecule = ((...params: Parameters<typeof makeMolecule>) => {
 			return makeMoleculeInStore(s, ...params)
-		}) as any
+		}) as typeof makeMolecule
 	}
 }

package/src/subscribe.ts

@@ -1,11 +1,5 @@
-import type { Flat, Func, Store } from "atom.io/internal"
-import {
-	arbitrary,
-	IMPLICIT,
-	subscribeToState,
-	subscribeToTimeline,
-	subscribeToTransaction,
-} from "atom.io/internal"
+import type { Flat, Func } from "atom.io/internal"
+import { arbitrary, IMPLICIT, subscribeInStore } from "atom.io/internal"
 
 import type {
 	FamilyMetadata,
@@ -35,35 +29,21 @@ export function subscribe<T>(
 	token: ReadableToken<T>,
 	handleUpdate: UpdateHandler<T>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<F extends Func>(
 	token: TransactionToken<F>,
 	handleUpdate: TransactionUpdateHandler<F>,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe<M extends TimelineManageable>(
 	token: TimelineToken<M>,
 	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
 	key?: string,
-	store?: Store,
 ): () => void
 export function subscribe(
 	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
 	handleUpdate: (update: any) => void,
 	key: string = arbitrary(),
-	store = IMPLICIT.STORE,
 ): () => void {
-	switch (token.type) {
-		case `atom`:
-		case `mutable_atom`:
-		case `readonly_selector`:
-		case `selector`:
-			return subscribeToState(token, handleUpdate, key, store)
-		case `transaction`:
-			return subscribeToTransaction(token, handleUpdate, key, store)
-		case `timeline`:
-			return subscribeToTimeline(token, handleUpdate, key, store)
-	}
+	return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key)
 }

package/src/timeline.ts

@@ -54,9 +54,9 @@ export const timeline = <ManagedAtom extends TimelineManageable>(
 }
 
 export const redo = (tl: TimelineToken<any>): void => {
-	timeTravel(`redo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `redo`, tl)
 }
 
 export const undo = (tl: TimelineToken<any>): void => {
-	timeTravel(`undo`, tl, IMPLICIT.STORE)
+	timeTravel(IMPLICIT.STORE, `undo`, tl)
 }

package/internal/src/families/throw-in-case-of-conflicting-family.ts

@@ -1,18 +0,0 @@
-import type { AtomFamilyToken, SelectorFamilyToken } from "atom.io"
-
-import { prettyPrintTokenType } from "../pretty-print"
-import type { Store } from "../store"
-
-export function throwInCaseOfConflictingFamily(
-	family: AtomFamilyToken<any, any> | SelectorFamilyToken<any, any>,
-	store: Store,
-): void {
-	const existingFamily = store.families.get(family.key)
-	if (existingFamily) {
-		throw new Error(
-			`Tried to create ${family.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(family)} with key "${family.key}", but "${family.key}" already exists in store "${store.config.name}" as ${existingFamily.type === `atom_family` ? `an` : `a`} ${prettyPrintTokenType(
-				existingFamily,
-			)}`,
-		)
-	}
-}