atom.io 0.19.1 → 0.19.2

package/internal/src/timeline/create-timeline.ts

@@ -1,5 +1,4 @@
 import type {
-	AtomFamily,
 	AtomFamilyToken,
 	FamilyMetadata,
 	StateUpdate,
@@ -9,7 +8,7 @@ import type {
 	TimelineUpdate,
 	TokenType,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
@@ -31,7 +30,7 @@ export type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
 	timestamp: number
 	atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[]
 }
-export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+export type TimelineTransactionUpdate = TransactionUpdate<Func> & {
 	key: string
 	type: `transaction_update`
 	timestamp: number
@@ -73,7 +72,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 		transactionKey: null,
 		...data,
 		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (store) => createTimeline(options, store, tl),
+		install: (s) => createTimeline(options, s, tl),
 		subject: new Subject(),
 	}
 	if (options.shouldCapture) {

package/internal/src/transaction/act-upon-store.ts

@@ -1,15 +1,15 @@
-import type { TransactionToken, ƒn } from "atom.io"
+import type { TransactionToken, Func } from "atom.io"
 
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 
-export function actUponStore<ƒ extends ƒn>(
-	token: TransactionToken<ƒ>,
+export function actUponStore<F extends Func>(
+	token: TransactionToken<F>,
 	id: string,
 	store: Store,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
-	return (...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
+): (...parameters: Parameters<F>) => ReturnType<F> {
+	return (...parameters: Parameters<F>): ReturnType<F> => {
 		const tx = withdraw(token, store)
 		if (tx) {
 			return tx.run(parameters, id)

package/internal/src/transaction/apply-transaction.ts

@@ -1,4 +1,4 @@
-import type { ƒn } from "atom.io"
+import type { Func } from "atom.io"
 
 import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
@@ -7,8 +7,8 @@ import type { Store } from "../store"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
-export const applyTransaction = <ƒ extends ƒn>(
-	output: ReturnType<ƒ>,
+export const applyTransaction = <F extends Func>(
+	output: ReturnType<F>,
 	store: Store,
 ): void => {
 	const child = newest(store)
@@ -65,7 +65,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 			child.transactionMeta.update.epoch,
 			parent,
 		)
-		const myTransaction = withdraw<ƒ>(
+		const myTransaction = withdraw<F>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },
 			store,
 		)

package/internal/src/transaction/build-transaction.ts

@@ -1,4 +1,4 @@
-import type { findState, ƒn } from "atom.io"
+import type { findState, Func } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
@@ -45,8 +45,8 @@ export const buildTransaction = (
 		valueMap: new LazyMap(parent.valueMap),
 	}
 	const epoch = getEpochNumberOfAction(key, store)
-	const transactionMeta: TransactionProgress<ƒn> = {
-		phase: `building` as const,
+	const transactionMeta: TransactionProgress<Func> = {
+		phase: `building`,
 		update: {
 			key,
 			id,
@@ -57,9 +57,12 @@ export const buildTransaction = (
 		},
 		transactors: {
 			get: (token) => getFromStore(token, child),
-			set: (token, value) => setIntoStore(token, value, child),
-			run: (token, id = arbitrary()) => actUponStore(token, id, child),
-			find: ((token, key) => findInStore(token, key, child)) as typeof findState,
+			set: (token, value) => {
+				setIntoStore(token, value, child)
+			},
+			run: (token, identifier = arbitrary()) =>
+				actUponStore(token, identifier, child),
+			find: ((token, k) => findInStore(token, k, child)) as typeof findState,
 			env: () => getEnvironmentData(child),
 		},
 	}

package/internal/src/transaction/create-transaction.ts

@@ -2,7 +2,7 @@ import type {
 	TransactionOptions,
 	TransactionToken,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
@@ -13,22 +13,22 @@ import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"
 
-export type Transaction<ƒ extends ƒn> = {
+export type Transaction<F extends Func> = {
 	key: string
 	type: `transaction`
 	install: (store: Store) => void
-	subject: Subject<TransactionUpdate<ƒ>>
-	run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>
+	subject: Subject<TransactionUpdate<F>>
+	run: (parameters: Parameters<F>, id?: string) => ReturnType<F>
 }
 
-export function createTransaction<ƒ extends ƒn>(
-	options: TransactionOptions<ƒ>,
+export function createTransaction<F extends Func>(
+	options: TransactionOptions<F>,
 	store: Store,
-): TransactionToken<ƒ> {
-	const newTransaction: Transaction<ƒ> = {
+): TransactionToken<F> {
+	const newTransaction: Transaction<F> = {
 		key: options.key,
 		type: `transaction`,
-		run: (params: Parameters<ƒ>, id: string) => {
+		run: (params: Parameters<F>, id: string) => {
 			const childStore = buildTransaction(options.key, params, store, id)
 			try {
 				const target = newest(store)
@@ -42,7 +42,7 @@ export function createTransaction<ƒ extends ƒn>(
 				throw thrown
 			}
 		},
-		install: (store) => createTransaction(options, store),
+		install: (s) => createTransaction(options, s),
 		subject: new Subject(),
 	}
 	const target = newest(store)

package/internal/src/transaction/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate, TransactorsWithRunAndEnv, ƒn } from "atom.io"
+import type { TransactionUpdate, TransactorsWithRunAndEnv, Func } from "atom.io"
 import type { Junction } from "rel8/junction"
 
 export * from "./abort-transaction"
@@ -14,9 +14,9 @@ export * from "./set-epoch-number"
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
 
-export type TransactionProgress<ƒ extends ƒn> = {
+export type TransactionProgress<F extends Func> = {
 	phase: `applying` | `building`
-	update: TransactionUpdate<ƒ>
+	update: TransactionUpdate<F>
 	transactors: TransactorsWithRunAndEnv
 }
 

package/internal/src/transaction/is-root-store.ts

@@ -1,4 +1,4 @@
-import type { ƒn } from "atom.io"
+import type { Func } from "atom.io"
 
 import type { TransactionEpoch, TransactionProgress } from "."
 import type { Store } from "../store"
@@ -9,7 +9,7 @@ export interface RootStore extends Store {
 	child: ChildStore | null
 }
 export interface ChildStore extends Store {
-	transactionMeta: TransactionProgress<ƒn>
+	transactionMeta: TransactionProgress<Func>
 	parent: ChildStore | RootStore
 	child: ChildStore | null
 }

package/introspection/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, ƒn as _n, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
+import { AtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, Func, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
 import { Timeline } from 'atom.io/internal';
 
@@ -9,8 +9,8 @@ type SelectorTokenIndex = WritableTokenIndex<ReadonlySelectorToken<unknown> | Wr
 declare const attachIntrospectionStates: (store?: Internal.Store) => {
     atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
     selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
-    transactionIndex: ReadonlySelectorToken<TransactionToken<_n>[]>;
-    findTransactionLogState: ReadonlySelectorFamilyToken<TransactionUpdate<_n>[], string>;
+    transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
+    findTransactionLogState: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
     timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>;
     findTimelineState: ReadonlySelectorFamilyToken<Timeline<any>, string>;
 };

package/introspection/src/attach-introspection-states.ts

@@ -5,7 +5,7 @@ import type {
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Timeline } from "atom.io/internal"
@@ -23,9 +23,9 @@ export const attachIntrospectionStates = (
 ): {
 	atomIndex: ReadonlySelectorToken<AtomTokenIndex>
 	selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>
+	transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>
 	findTransactionLogState: ReadonlySelectorFamilyToken<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>
 	timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>

package/introspection/src/attach-transaction-index.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorToken, TransactionToken, ƒn } from "atom.io"
+import type { ReadonlySelectorToken, TransactionToken, Func } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
@@ -8,14 +8,14 @@ import {
 
 export const attachTransactionIndex = (
 	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorToken<TransactionToken<ƒn>[]> => {
+): ReadonlySelectorToken<TransactionToken<Func>[]> => {
 	const transactionTokenIndexState__INTERNAL = createRegularAtom<
-		TransactionToken<ƒn>[]
+		TransactionToken<Func>[]
 	>(
 		{
 			key: `👁‍🗨 Transaction Token Index (Internal)`,
 			default: () =>
-				[...store.transactions].map(([key]): TransactionToken<ƒn> => {
+				[...store.transactions].map(([key]): TransactionToken<Func> => {
 					return { key, type: `transaction` }
 				}),
 			effects: [

package/introspection/src/attach-transaction-logs.ts

@@ -1,4 +1,8 @@
-import type { ReadonlySelectorFamilyToken, TransactionUpdate, ƒn } from "atom.io"
+import type {
+	ReadonlySelectorFamilyToken,
+	TransactionUpdate,
+	Func,
+} from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
@@ -8,9 +12,9 @@ import {
 
 export const attachTransactionLogs = (
 	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorFamilyToken<TransactionUpdate<ƒn>[], string> => {
+): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
 	const findTransactionUpdateLog = createRegularAtomFamily<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>(
 		{
@@ -30,7 +34,7 @@ export const attachTransactionLogs = (
 		store,
 	)
 	const findTransactionUpdateLogState = createSelectorFamily<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>(
 		{

package/json/dist/index.cjs

@@ -49,7 +49,9 @@ var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
     {
       key: `${atom.key}:JSON`,
       get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue))
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
     },
     store
   );
@@ -59,7 +61,9 @@ function selectJsonFamily(atomFamily, transform, store = internal.IMPLICIT.STORE
     {
       key: `${atomFamily.key}:JSON`,
       get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
-      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+      set: (key) => ({ set }, newValue) => {
+        set(atomFamily(key), transform.fromJson(newValue));
+      }
     },
     store
   );

package/json/dist/index.js

@@ -8,7 +8,9 @@ var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
     {
       key: `${atom.key}:JSON`,
       get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue))
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
     },
     store
   );
@@ -18,7 +20,9 @@ function selectJsonFamily(atomFamily, transform, store = IMPLICIT.STORE) {
     {
       key: `${atomFamily.key}:JSON`,
       get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
-      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+      set: (key) => ({ set }, newValue) => {
+        set(atomFamily(key), transform.fromJson(newValue));
+      }
     },
     store
   );

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

@@ -43,8 +43,9 @@ export function selectJsonFamily<
 					transform.toJson(get(atomFamily(key))),
 			set:
 				(key) =>
-				({ set }, newValue) =>
-					set(atomFamily(key), transform.fromJson(newValue)),
+				({ set }, newValue) => {
+					set(atomFamily(key), transform.fromJson(newValue))
+				},
 		},
 		store,
 	)

package/json/src/select-json.ts

@@ -14,7 +14,9 @@ export const selectJson = <T, J extends Json.Serializable>(
 		{
 			key: `${atom.key}:JSON`,
 			get: ({ get }) => transform.toJson(get(atom)),
-			set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
+			set: ({ set }, newValue) => {
+				set(atom, transform.fromJson(newValue))
+			},
 		},
 		store,
 	)