atom.io 0.6.1 → 0.6.3

package/realtime-testing/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/realtime-testing/setup-realtime-test.tsx"],"sourcesContent":["import * as http from \"http\"\n\nimport * as React from \"react\"\n\nimport { prettyDOM, render, type RenderResult } from \"@testing-library/react\"\nimport * as AtomIO from \"atom.io\"\nimport * as AR from \"atom.io/react\"\nimport * as RTC from \"atom.io/realtime-react\"\nimport * as RR from \"fp-ts/ReadonlyRecord\"\nimport * as Happy from \"happy-dom\"\nimport * as SocketIO from \"socket.io\"\nimport type { Socket as ClientSocket } from \"socket.io-client\"\nimport { io } from \"socket.io-client\"\n\nexport type TestSetupOptions = {\n\tserver: (tools: { socket: SocketIO.Socket; silo: AtomIO.Silo }) => void\n}\nexport type TestSetupOptions__SingleClient = TestSetupOptions & {\n\tclient: React.FC\n}\nexport type TestSetupOptions__MultiClient<ClientNames extends string> =\n\tTestSetupOptions & {\n\t\tclients: {\n\t\t\t[K in ClientNames]: React.FC\n\t\t}\n\t}\n\nexport type RealtimeTestTools = {\n\tname: string\n\tsilo: AtomIO.Silo\n\tdispose: () => void\n}\nexport type RealtimeTestClient = RealtimeTestTools & {\n\trenderResult: RenderResult\n\tprettyPrint: () => void\n\treconnect: () => void\n\tdisconnect: () => void\n}\nexport type RealtimeTestServer = RealtimeTestTools & {\n\tport: number\n}\n\nexport type RealtimeTestAPI = {\n\tserver: RealtimeTestServer\n\tteardown: () => void\n}\nexport type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {\n\tclient: RealtimeTestClient\n}\nexport type RealtimeTestAPI__MultiClient<ClientNames extends string> =\n\tRealtimeTestAPI & {\n\t\tclients: Record<ClientNames, RealtimeTestClient>\n\t}\n\nexport const setupRealtimeTestServer = (\n\toptions: TestSetupOptions,\n): RealtimeTestServer => {\n\tconst httpServer = http.createServer((_, res) => res.end(`Hello World!`))\n\tconst address = httpServer.listen().address()\n\tconst port =\n\t\ttypeof address === `string` ? 80 : address === null ? null : address.port\n\tif (port === null) throw new Error(`Could not determine port for test server`)\n\tconst server = new SocketIO.Server(httpServer)\n\tconst silo = AtomIO.silo(`SERVER`, AtomIO.__INTERNAL__.IMPLICIT.STORE)\n\n\tserver.on(`connection`, (socket: SocketIO.Socket) => {\n\t\toptions.server({ socket, silo })\n\t})\n\n\tconst dispose = () => {\n\t\tserver.close()\n\t\tAtomIO.__INTERNAL__.clearStore(silo.store)\n\t}\n\n\treturn {\n\t\tname: `SERVER`,\n\t\tsilo,\n\t\tdispose,\n\t\tport,\n\t}\n}\nexport const setupRealtimeTestClient = (\n\toptions: TestSetupOptions__SingleClient,\n\tname: string,\n\tport: number,\n): RealtimeTestClient => {\n\tconst socket: ClientSocket = io(`http://localhost:${port}/`)\n\tconst silo = AtomIO.silo(name, AtomIO.__INTERNAL__.IMPLICIT.STORE)\n\n\tconst { document } = new Happy.Window()\n\tdocument.body.innerHTML = `<div id=\"app\"></div>`\n\tconst renderResult = render(\n\t\t<AR.StoreProvider store={silo.store}>\n\t\t\t<RTC.RealtimeProvider socket={socket}>\n\t\t\t\t<options.client />\n\t\t\t</RTC.RealtimeProvider>\n\t\t</AR.StoreProvider>,\n\t\t{\n\t\t\tcontainer: document.querySelector(`#app`) as unknown as HTMLElement,\n\t\t},\n\t)\n\n\tconst prettyPrint = () => console.log(prettyDOM(renderResult.container))\n\n\tconst disconnect = () => socket.disconnect()\n\tconst reconnect = () => socket.connect()\n\n\tconst dispose = () => {\n\t\tsocket.disconnect()\n\t\tAtomIO.__INTERNAL__.clearStore(silo.store)\n\t}\n\n\treturn {\n\t\tname,\n\t\tsilo,\n\t\trenderResult,\n\t\tprettyPrint,\n\t\tdisconnect,\n\t\treconnect,\n\t\tdispose,\n\t}\n}\n\nexport const singleClient = (\n\toptions: TestSetupOptions__SingleClient,\n): RealtimeTestAPI__SingleClient => {\n\tconst server = setupRealtimeTestServer(options)\n\tconst client = setupRealtimeTestClient(options, `CLIENT`, server.port)\n\n\treturn {\n\t\tclient,\n\t\tserver,\n\t\tteardown: () => {\n\t\t\tclient.dispose()\n\t\t\tserver.dispose()\n\t\t},\n\t}\n}\n\nexport const multiClient = <ClientNames extends string>(\n\toptions: TestSetupOptions__MultiClient<ClientNames>,\n): RealtimeTestAPI__MultiClient<ClientNames> => {\n\tconst server = setupRealtimeTestServer(options)\n\tconst clients = RR.toEntries(options.clients).reduce(\n\t\t(clients, [name, client]) => ({\n\t\t\t...clients,\n\t\t\t[name]: setupRealtimeTestClient({ ...options, client }, name, server.port),\n\t\t}),\n\t\t{} as Record<ClientNames, RealtimeTestClient>,\n\t)\n\n\treturn {\n\t\tclients,\n\t\tserver,\n\t\tteardown: () => {\n\t\t\tRR.toEntries(clients).forEach(([, client]) => client.dispose())\n\t\t\tserver.dispose()\n\t\t},\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,YAAY,UAAU;AAItB,SAAS,WAAW,cAAiC;AACrD,YAAY,YAAY;AACxB,YAAY,QAAQ;AACpB,YAAY,SAAS;AACrB,YAAY,QAAQ;AACpB,YAAY,WAAW;AACvB,YAAY,cAAc;AAE1B,SAAS,UAAU;AAkFf;AAxCG,IAAM,0BAA0B,CACtC,YACwB;AACxB,QAAM,aAAkB,kBAAa,CAAC,GAAG,QAAQ,IAAI,IAAI,cAAc,CAAC;AACxE,QAAM,UAAU,WAAW,OAAO,EAAE,QAAQ;AAC5C,QAAM,OACL,OAAO,YAAY,WAAW,KAAK,YAAY,OAAO,OAAO,QAAQ;AACtE,MAAI,SAAS;AAAM,UAAM,IAAI,MAAM,0CAA0C;AAC7E,QAAM,SAAS,IAAa,gBAAO,UAAU;AAC7C,QAAMA,QAAc,YAAK,UAAiB,oBAAa,SAAS,KAAK;AAErE,SAAO,GAAG,cAAc,CAAC,WAA4B;AACpD,YAAQ,OAAO,EAAE,QAAQ,MAAAA,MAAK,CAAC;AAAA,EAChC,CAAC;AAED,QAAM,UAAU,MAAM;AACrB,WAAO,MAAM;AACb,IAAO,oBAAa,WAAWA,MAAK,KAAK;AAAA,EAC1C;AAEA,SAAO;AAAA,IACN,MAAM;AAAA,IACN,MAAAA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;AACO,IAAM,0BAA0B,CACtC,SACA,MACA,SACwB;AACxB,QAAM,SAAuB,GAAG,oBAAoB,IAAI,GAAG;AAC3D,QAAMA,QAAc,YAAK,MAAa,oBAAa,SAAS,KAAK;AAEjE,QAAM,EAAE,SAAS,IAAI,IAAU,aAAO;AACtC,WAAS,KAAK,YAAY;AAC1B,QAAM,eAAe;AAAA,IACpB,oBAAI,kBAAH,EAAiB,OAAOA,MAAK,OAC7B,8BAAK,sBAAJ,EAAqB,QACrB,8BAAC,QAAQ,QAAR,EAAe,GACjB,GACD;AAAA,IACA;AAAA,MACC,WAAW,SAAS,cAAc,MAAM;AAAA,IACzC;AAAA,EACD;AAEA,QAAM,cAAc,MAAM,QAAQ,IAAI,UAAU,aAAa,SAAS,CAAC;AAEvE,QAAM,aAAa,MAAM,OAAO,WAAW;AAC3C,QAAM,YAAY,MAAM,OAAO,QAAQ;AAEvC,QAAM,UAAU,MAAM;AACrB,WAAO,WAAW;AAClB,IAAO,oBAAa,WAAWA,MAAK,KAAK;AAAA,EAC1C;AAEA,SAAO;AAAA,IACN;AAAA,IACA,MAAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACD;AACD;AAEO,IAAM,eAAe,CAC3B,YACmC;AACnC,QAAM,SAAS,wBAAwB,OAAO;AAC9C,QAAM,SAAS,wBAAwB,SAAS,UAAU,OAAO,IAAI;AAErE,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA,UAAU,MAAM;AACf,aAAO,QAAQ;AACf,aAAO,QAAQ;AAAA,IAChB;AAAA,EACD;AACD;AAEO,IAAM,cAAc,CAC1B,YAC+C;AAC/C,QAAM,SAAS,wBAAwB,OAAO;AAC9C,QAAM,UAAa,aAAU,QAAQ,OAAO,EAAE;AAAA,IAC7C,CAACC,UAAS,CAAC,MAAM,MAAM,MAAO,iCAC1BA,WAD0B;AAAA,MAE7B,CAAC,IAAI,GAAG,wBAAwB,iCAAK,UAAL,EAAc,OAAO,IAAG,MAAM,OAAO,IAAI;AAAA,IAC1E;AAAA,IACA,CAAC;AAAA,EACF;AAEA,SAAO;AAAA,IACN;AAAA,IACA;AAAA,IACA,UAAU,MAAM;AACf,MAAG,aAAU,OAAO,EAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,MAAM,OAAO,QAAQ,CAAC;AAC9D,aAAO,QAAQ;AAAA,IAChB;AAAA,EACD;AACD;","names":["silo","clients"]}

package/realtime-testing/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "atom.io-realtime-testing",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": "./dist/index.mjs",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  }
+}

package/src/atom.ts

@@ -6,38 +6,38 @@ import type { AtomToken } from "."
 import { atomFamily__INTERNAL, atom__INTERNAL } from "./internal"
 
 export type Effectors<T> = {
-  setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
-  onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
+	setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
+	onSet: (callback: (options: { newValue: T; oldValue: T }) => void) => void
 }
 
 export type AtomEffect<T> = (tools: Effectors<T>) => void
 
 export type AtomOptions<T> = {
-  key: string
-  default: T | (() => T)
-  effects?: AtomEffect<T>[]
+	key: string
+	default: T | (() => T)
+	effects?: AtomEffect<T>[]
 }
 
 export function atom<T>(options: AtomOptions<T>): AtomToken<T> {
-  return atom__INTERNAL<T>(options)
+	return atom__INTERNAL<T>(options)
 }
 
 export type AtomFamilyOptions<T, K extends Serializable> = {
-  key: string
-  default: T | ((key: K) => T)
-  effects?: (key: K) => AtomEffect<T>[]
+	key: string
+	default: T | ((key: K) => T)
+	effects?: (key: K) => AtomEffect<T>[]
 }
 
 export type AtomFamily<T, K extends Serializable = Serializable> = ((
-  key: K
+	key: K,
 ) => AtomToken<T>) & {
-  key: string
-  type: `atom_family`
-  subject: Rx.Subject<AtomToken<T>>
+	key: string
+	type: `atom_family`
+	subject: Rx.Subject<AtomToken<T>>
 }
 
 export function atomFamily<T, K extends Serializable>(
-  options: AtomFamilyOptions<T, K>
+	options: AtomFamilyOptions<T, K>,
 ): AtomFamily<T, K> {
-  return atomFamily__INTERNAL<T, K>(options)
+	return atomFamily__INTERNAL<T, K>(options)
 }

package/src/index.ts

@@ -1,14 +1,14 @@
 import { capitalize } from "~/packages/anvl/src/string/capitalize"
 
 import {
-  IMPLICIT,
-  closeOperation,
-  openOperation,
-  getState__INTERNAL,
-  setState__INTERNAL,
-  isAtomDefault,
-  isSelectorDefault,
-  withdraw,
+	IMPLICIT,
+	closeOperation,
+	openOperation,
+	getState__INTERNAL,
+	setState__INTERNAL,
+	isAtomDefault,
+	isSelectorDefault,
+	withdraw,
 } from "./internal"
 import * as __INTERNAL__ from "./internal"
 import type { Store } from "./internal/store"
@@ -25,75 +25,75 @@ export type { Store } from "./internal/store"
 export type { Serializable } from "~/packages/anvl/src/json"
 
 export type AtomToken<_> = {
-  key: string
-  type: `atom`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `atom`
+	family?: FamilyMetadata
+	__brand?: _
 }
 export type SelectorToken<_> = {
-  key: string
-  type: `selector`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `selector`
+	family?: FamilyMetadata
+	__brand?: _
 }
 export type StateToken<T> = AtomToken<T> | SelectorToken<T>
 
 export type ReadonlySelectorToken<_> = {
-  key: string
-  type: `readonly_selector`
-  family?: FamilyMetadata
-  __brand?: _
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	__brand?: _
 }
 
 export type FamilyMetadata = {
-  key: string
-  subKey: string
+	key: string
+	subKey: string
 }
 
 export const getState = <T>(
-  token: ReadonlySelectorToken<T> | StateToken<T>,
-  store: Store = IMPLICIT.STORE
+	token: ReadonlySelectorToken<T> | StateToken<T>,
+	store: Store = IMPLICIT.STORE,
 ): T => {
-  const state = withdraw<T>(token, store)
-  if (state === null) {
-    throw new Error(
-      `${capitalize(token.type)} "${token.key}" not found in store "${
-        store.config.name
-      }".`
-    )
-  }
-  return getState__INTERNAL(state, store)
+	const state = withdraw<T>(token, store)
+	if (state === null) {
+		throw new Error(
+			`${capitalize(token.type)} "${token.key}" not found in store "${
+				store.config.name
+			}".`,
+		)
+	}
+	return getState__INTERNAL(state, store)
 }
 
 export const setState = <T, New extends T>(
-  token: StateToken<T>,
-  value: New | ((oldValue: T) => New),
-  store: Store = IMPLICIT.STORE
+	token: StateToken<T>,
+	value: New | ((oldValue: T) => New),
+	store: Store = IMPLICIT.STORE,
 ): void => {
-  try {
-    openOperation(token, store)
-  } catch (thrown) {
-    if (!(typeof thrown === `symbol`)) {
-      throw thrown
-    }
-    return
-  }
-  const state = withdraw(token, store)
-  if (state === null) {
-    throw new Error(
-      `${capitalize(token.type)} "${token.key}" not found in store "${
-        store.config.name
-      }".`
-    )
-  }
-  setState__INTERNAL(state, value, store)
-  closeOperation(store)
+	try {
+		openOperation(token, store)
+	} catch (thrown) {
+		if (!(typeof thrown === `symbol`)) {
+			throw thrown
+		}
+		return
+	}
+	const state = withdraw(token, store)
+	if (state === null) {
+		throw new Error(
+			`${capitalize(token.type)} "${token.key}" not found in store "${
+				store.config.name
+			}".`,
+		)
+	}
+	setState__INTERNAL(state, value, store)
+	closeOperation(store)
 }
 
 export const isDefault = (
-  token: ReadonlySelectorToken<unknown> | StateToken<unknown>,
-  store: Store = IMPLICIT.STORE
+	token: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	store: Store = IMPLICIT.STORE,
 ): boolean =>
-  token.type === `atom`
-    ? isAtomDefault(token.key, store)
-    : isSelectorDefault(token.key, store)
+	token.type === `atom`
+		? isAtomDefault(token.key, store)
+		: isSelectorDefault(token.key, store)

package/src/internal/atom-internal.ts

@@ -12,44 +12,44 @@ import { setState, subscribe } from ".."
 import type { AtomOptions } from "../atom"
 
 export type Atom<T> = {
-  key: string
-  type: `atom`
-  family?: FamilyMetadata
-  subject: Rx.Subject<{ newValue: T; oldValue: T }>
-  default: T
+	key: string
+	type: `atom`
+	family?: FamilyMetadata
+	subject: Rx.Subject<{ newValue: T; oldValue: T }>
+	default: T
 }
 
 export function atom__INTERNAL<T>(
-  options: AtomOptions<T>,
-  family?: FamilyMetadata,
-  store: Store = IMPLICIT.STORE
+	options: AtomOptions<T>,
+	family?: FamilyMetadata,
+	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
-  const core = target(store)
-  if (hasKeyBeenUsed(options.key, store)) {
-    store.config.logger?.error?.(
-      `Key "${options.key}" already exists in the store.`
-    )
-    return deposit(core.atoms.get(options.key))
-  }
-  const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
-  const newAtom = {
-    ...options,
-    subject,
-    type: `atom`,
-    ...(family && { family }),
-  } as const
-  const initialValue =
-    options.default instanceof Function ? options.default() : options.default
-  core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
-  markAtomAsDefault(options.key, store)
-  cacheValue(options.key, initialValue, store)
-  const token = deposit(newAtom)
-  options.effects?.forEach((effect) =>
-    effect({
-      setSelf: (next) => setState(token, next, store),
-      onSet: (handle: UpdateHandler<T>) => subscribe(token, handle, store),
-    })
-  )
-  store.subject.atomCreation.next(token)
-  return token as AtomToken<T>
+	const core = target(store)
+	if (hasKeyBeenUsed(options.key, store)) {
+		store.config.logger?.error?.(
+			`Key "${options.key}" already exists in the store.`,
+		)
+		return deposit(core.atoms.get(options.key))
+	}
+	const subject = new Rx.Subject<{ newValue: T; oldValue: T }>()
+	const newAtom = {
+		...options,
+		subject,
+		type: `atom`,
+		...(family && { family }),
+	} as const
+	const initialValue =
+		options.default instanceof Function ? options.default() : options.default
+	core.atoms = HAMT.set(newAtom.key, newAtom, core.atoms)
+	markAtomAsDefault(options.key, store)
+	cacheValue(options.key, initialValue, store)
+	const token = deposit(newAtom)
+	options.effects?.forEach((effect) =>
+		effect({
+			setSelf: (next) => setState(token, next, store),
+			onSet: (handle: UpdateHandler<T>) => subscribe(token, handle, store),
+		}),
+	)
+	store.subject.atomCreation.next(token)
+	return token as AtomToken<T>
 }

package/src/internal/families-internal.ts

@@ -5,138 +5,138 @@ import { stringifyJson } from "~/packages/anvl/src/json"
 
 import type { Store } from "."
 import {
-  atom__INTERNAL,
-  withdraw,
-  selector__INTERNAL,
-  target,
-  deposit,
-  IMPLICIT,
+	atom__INTERNAL,
+	withdraw,
+	selector__INTERNAL,
+	target,
+	deposit,
+	IMPLICIT,
 } from "."
 import type {
-  AtomFamily,
-  AtomFamilyOptions,
-  AtomToken,
-  FamilyMetadata,
-  ReadonlySelectorFamily,
-  ReadonlySelectorFamilyOptions,
-  ReadonlySelectorToken,
-  SelectorFamily,
-  SelectorFamilyOptions,
-  SelectorToken,
+	AtomFamily,
+	AtomFamilyOptions,
+	AtomToken,
+	FamilyMetadata,
+	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyOptions,
+	ReadonlySelectorToken,
+	SelectorFamily,
+	SelectorFamilyOptions,
+	SelectorToken,
 } from ".."
 
 export function atomFamily__INTERNAL<T, K extends Serializable>(
-  options: AtomFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
+	options: AtomFamilyOptions<T, K>,
+	store: Store = IMPLICIT.STORE,
 ): AtomFamily<T, K> {
-  const subject = new Rx.Subject<AtomToken<T>>()
-  return Object.assign(
-    (key: K): AtomToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = withdraw({ key: fullKey, type: `atom` }, store)
-      const token: AtomToken<any> = existing
-        ? deposit(existing)
-        : atom__INTERNAL<T>(
-            {
-              key: fullKey,
-              default:
-                options.default instanceof Function
-                  ? options.default(key)
-                  : options.default,
-              effects: options.effects?.(key),
-            },
-            family,
-            store
-          )
-      subject.next(token)
-      return token
-    },
-    {
-      key: options.key,
-      type: `atom_family`,
-      subject,
-    } as const
-  )
+	const subject = new Rx.Subject<AtomToken<T>>()
+	return Object.assign(
+		(key: K): AtomToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = withdraw({ key: fullKey, type: `atom` }, store)
+			const token: AtomToken<any> = existing
+				? deposit(existing)
+				: atom__INTERNAL<T>(
+						{
+							key: fullKey,
+							default:
+								options.default instanceof Function
+									? options.default(key)
+									: options.default,
+							effects: options.effects?.(key),
+						},
+						family,
+						store,
+				  )
+			subject.next(token)
+			return token
+		},
+		{
+			key: options.key,
+			type: `atom_family`,
+			subject,
+		} as const,
+	)
 }
 
 export function readonlySelectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
+	options: ReadonlySelectorFamilyOptions<T, K>,
+	store?: Store,
 ): ReadonlySelectorFamily<T, K> {
-  const core = target(store)
-  const subject = new Rx.Subject<ReadonlySelectorToken<T>>()
-  return Object.assign(
-    (key: K): ReadonlySelectorToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = core.readonlySelectors.get(fullKey)
-      if (existing) {
-        return deposit(existing)
-      }
-      return selector__INTERNAL<T>(
-        {
-          key: fullKey,
-          get: options.get(key),
-        },
-        family,
-        store
-      ) as ReadonlySelectorToken<T>
-    },
-    {
-      key: options.key,
-      type: `readonly_selector_family`,
-      subject,
-    } as const
-  ) as ReadonlySelectorFamily<T, K>
+	const core = target(store)
+	const subject = new Rx.Subject<ReadonlySelectorToken<T>>()
+	return Object.assign(
+		(key: K): ReadonlySelectorToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = core.readonlySelectors.get(fullKey)
+			if (existing) {
+				return deposit(existing)
+			}
+			return selector__INTERNAL<T>(
+				{
+					key: fullKey,
+					get: options.get(key),
+				},
+				family,
+				store,
+			) as ReadonlySelectorToken<T>
+		},
+		{
+			key: options.key,
+			type: `readonly_selector_family`,
+			subject,
+		} as const,
+	) as ReadonlySelectorFamily<T, K>
 }
 
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: SelectorFamilyOptions<T, K>,
-  store?: Store
+	options: SelectorFamilyOptions<T, K>,
+	store?: Store,
 ): SelectorFamily<T, K>
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K>,
-  store?: Store
+	options: ReadonlySelectorFamilyOptions<T, K>,
+	store?: Store,
 ): ReadonlySelectorFamily<T, K>
 export function selectorFamily__INTERNAL<T, K extends Serializable>(
-  options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-  store: Store = IMPLICIT.STORE
+	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
+	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
-  const isReadonly = !(`set` in options)
+	const isReadonly = !(`set` in options)
 
-  if (isReadonly) {
-    return readonlySelectorFamily__INTERNAL(options, store)
-  }
-  const core = target(store)
-  const subject = new Rx.Subject<SelectorToken<T>>()
+	if (isReadonly) {
+		return readonlySelectorFamily__INTERNAL(options, store)
+	}
+	const core = target(store)
+	const subject = new Rx.Subject<SelectorToken<T>>()
 
-  return Object.assign(
-    (key: K): SelectorToken<T> => {
-      const subKey = stringifyJson(key)
-      const family: FamilyMetadata = { key: options.key, subKey }
-      const fullKey = `${options.key}(${subKey})`
-      const existing = core.selectors.get(fullKey)
-      if (existing) {
-        return deposit(existing)
-      }
-      const token = selector__INTERNAL<T>(
-        {
-          key: fullKey,
-          get: options.get(key),
-          set: options.set(key),
-        },
-        family,
-        store
-      )
-      subject.next(token)
-      return token
-    },
-    {
-      key: options.key,
-      type: `selector_family`,
-    } as const
-  ) as SelectorFamily<T, K>
+	return Object.assign(
+		(key: K): SelectorToken<T> => {
+			const subKey = stringifyJson(key)
+			const family: FamilyMetadata = { key: options.key, subKey }
+			const fullKey = `${options.key}(${subKey})`
+			const existing = core.selectors.get(fullKey)
+			if (existing) {
+				return deposit(existing)
+			}
+			const token = selector__INTERNAL<T>(
+				{
+					key: fullKey,
+					get: options.get(key),
+					set: options.set(key),
+				},
+				family,
+				store,
+			)
+			subject.next(token)
+			return token
+		},
+		{
+			key: options.key,
+			type: `selector_family`,
+		} as const,
+	) as SelectorFamily<T, K>
 }