atom.io 0.41.1 → 0.42.0

package/src/internal/mutable/transceiver.ts

@@ -1,7 +1,7 @@
 import type { Json } from "atom.io/json"
 
 export interface Transceiver<
-	V,
+	V extends { subscribe: (key: string, fn: (update: S) => void) => () => void },
 	S extends Json.Serializable,
 	J extends Json.Serializable,
 > {
@@ -9,8 +9,6 @@ export interface Transceiver<
 	do: (update: S) => number | `OUT_OF_RANGE` | null
 	undo: (update: S) => void
 	subscribe: (key: string, fn: (update: S) => void) => () => void
-	// cacheUpdateNumber: number
-	// getUpdateNumber: (update: S) => number
 	toJSON: () => J
 }
 
@@ -31,8 +29,6 @@ export function isTransceiver(
 		`do` in value &&
 		`undo` in value &&
 		`subscribe` in value &&
-		// `cacheUpdateNumber` in value &&
-		// `getUpdateNumber` in value &&
 		`READONLY_VIEW` in value &&
 		`toJSON` in value
 	)

package/src/internal/set-state/dispatch-state-update.ts

@@ -127,7 +127,7 @@ export function dispatchOrDeferStateUpdate<T, E>(
 		if (hasRole(state, `tracker:signal`)) {
 			const keyOfMutable = key.slice(1)
 			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
-				Transceiver<unknown, any, any>
+				Transceiver<any, any, any>
 			>
 			const transceiver = readOrComputeValue<Transceiver<any, any, any>, never>(
 				target,

package/src/internal/store/store.ts

@@ -80,7 +80,7 @@ export class Store implements Lineage {
 		| PureSelectorFamily<any, any, any>
 		| RegularAtomFamily<any, any, any>
 	> = new Map()
-	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
+	public joins: Map<string, Join<any, any, any, any, any>> = new Map()
 
 	public transactions: Map<string, Transaction<Fn>> = new Map()
 	public transactionMeta: TransactionEpoch | TransactionProgress<Fn> = {

package/src/main/join.ts

@@ -13,39 +13,36 @@ import {
 	getInternalRelationsFromStore,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import type { SetRTX } from "atom.io/transceivers/set-rtx"
+import type { UList } from "atom.io/transceivers/u-list"
 
 // biome-ignore format: intersection
 export type JoinOptions<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 > =
 	Flat<
-		& JunctionSchemaBase<ASide, BSide>
+		& JunctionSchemaBase<AName, BName>
 		& {
 			/** Unique identifier of the join */
 			readonly key: string
 			/** How many relations are allowed in each direction? */
 			readonly cardinality: Cardinality
 			/** Type guard for the type of the left side */
-			readonly isAType: Refinement<string, AType>
+			readonly isAType: Refinement<string, A>
 			/** Type guard for the type of the right side */
-			readonly isBType: Refinement<string, BType>
+			readonly isBType: Refinement<string, B>
 		}
-	> & Partial<JunctionEntriesBase<AType, BType, Content>>
+	> & Partial<JunctionEntriesBase<A, B, null>>
 
 export type JoinToken<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null = null,
 > = {
 	/** Unique identifier of the join */
 	key: string
@@ -54,15 +51,13 @@ export type JoinToken<
 	/** How many relations are allowed in each direction? */
 	cardinality: Cardinality
 	/** Name of the join's left side */
-	a: ASide
+	a: AName
 	/** Name of the join's right side */
-	b: BSide
+	b: BName
 	/** Never present. This is a marker that preserves the type of the left side's keys */
-	__aType?: AType
+	__aType?: A
 	/** Never present. This is a marker that preserves the type of the right side's keys */
-	__bType?: BType
-	/** Never present. This is a marker that preserves the type of the data present for each relation */
-	__content?: Content
+	__bType?: B
 }
 
 /**
@@ -73,136 +68,61 @@ export type JoinToken<
  * Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
  *
  * @param options - {@link JoinOptions}
- * @param defaultContent - (undefined)
  * @returns
  * A reference to the join created: a {@link JoinToken}
- * @overload No Content
  */
 export function join<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
+	const AName extends string,
+	const A extends string,
+	const BName extends string,
+	const B extends string,
 	const Cardinality extends `1:1` | `1:n` | `n:n`,
 >(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>,
-	defaultContent?: undefined,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, null>
-/**
- * Create a join, an interface for managing relations between two sets of keys.
- *
- * Use joins when it is important to view relationships from either side.
- *
- * Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
- *
- * @param options - {@link JoinOptions}
- * @param defaultContent - The default value for the content of each relation
- * @returns
- * A reference to the join created: a {@link JoinToken}
- * @overload With Content
- */
-export function join<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
-	const Cardinality extends `1:1` | `1:n` | `n:n`,
-	const Content extends Json.Object,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
-	defaultContent: Content,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>
-export function join<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
-	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
-	defaultContent: Content | undefined,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {
-	return createJoin(IMPLICIT.STORE, options, defaultContent)
+	options: JoinOptions<AName, A, BName, B, Cardinality>,
+): JoinToken<AName, A, BName, B, Cardinality> {
+	return createJoin(IMPLICIT.STORE, options)
 }
 
 export type JoinStates<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 > = Cardinality extends `1:1`
-	? (Content extends Json.Object
-			? {
-					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-						[AType, Content] | null,
-						BType
-					>
-				} & {
-					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-						[BType, Content] | null,
-						AType
-					>
-				}
-			: {}) & {
-			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-				AType | null,
-				BType
+	? {
+			readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+				A | null,
+				B
 			>
 		} & {
-			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-				BType | null,
-				AType
+			readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+				B | null,
+				A
 			>
 		}
 	: Cardinality extends `1:n`
-		? (Content extends Json.Object
-				? {
-						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-							[AType, Content] | null,
-							BType
-						>
-					} & {
-						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-							[BType, Content][],
-							AType
-						>
-					}
-				: {}) & {
-				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-					AType | null,
-					BType
+		? {
+				readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+					A | null,
+					B
 				>
 			} & {
-				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-					BType[],
-					AType
+				readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+					B[],
+					A
 				>
 			}
 		: Cardinality extends `n:n`
-			? (Content extends Json.Object
-					? {
-							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-								[AType, Content][],
-								BType
-							>
-						} & {
-							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-								[BType, Content][],
-								AType
-							>
-						}
-					: {}) & {
-					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-						AType[],
-						BType
+			? {
+					readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+						A[],
+						B
 					>
 				} & {
-					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-						BType[],
-						AType
+					readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+						B[],
+						A
 					>
 				}
 			: never
@@ -216,16 +136,15 @@ export type JoinStates<
  * @overload Default
  */
 export function findRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 >(
-	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
-	key: AType | BType,
-): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+	key: A | B,
+): JoinStates<AName, A, BName, B, Cardinality> {
 	return findRelationsInStore(token, key, IMPLICIT.STORE)
 }
 
@@ -235,15 +154,14 @@ export function findRelations<
  * @param change - A function that takes a {@link Junction} interface to edit the relations
  */
 export function editRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 >(
-	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
-	change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void,
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+	change: (relations: Junction<AName, A, BName, B>) => void,
 ): void {
 	editRelationsInStore(token, change, IMPLICIT.STORE)
 }
@@ -254,14 +172,13 @@ export function editRelations<
  * A {@link MutableAtomFamilyToken} to access the internal relations
  */
 export function getInternalRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 >(
-	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
-): MutableAtomFamilyToken<SetRTX<string>, string> {
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+): MutableAtomFamilyToken<UList<A> | UList<B>, string> {
 	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
 }

package/src/main/realm.ts

@@ -164,15 +164,15 @@ export type T$ = typeof T$
 export type TypeTag<T extends string> = `${T$}--${T}`
 export type SingularTypedKey<T extends string = string> = `${T}::${string}`
 export type CompoundTypedKey<
+	T extends string = string,
 	A extends string = string,
 	B extends string = string,
-	C extends string = string,
-> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`
+> = `${TypeTag<T>}==${SingularTypedKey<A>}++${SingularTypedKey<B>}`
 export type TypedKey<
+	T extends string = string,
 	A extends string = string,
 	B extends string = string,
-	C extends string = string,
-> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>
+> = CompoundTypedKey<T, A, B> | SingularTypedKey<T>
 type Scope = SingularTypedKey[]
 type MutualFealty = {
 	above: Scope

package/src/realtime/shared-room-store.ts

@@ -4,7 +4,6 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
-import type { SetRTX } from "atom.io/transceivers/set-rtx"
 import { UList } from "atom.io/transceivers/u-list"
 
 export const usersInThisRoomIndex: MutableAtomToken<UList<string>> = mutableAtom<
@@ -27,28 +26,19 @@ export type UserInRoomMeta = {
 export const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta = {
 	enteredAtEpoch: 0,
 }
-export const usersInRooms: JoinToken<
-	`room`,
-	string,
-	`user`,
-	string,
-	`1:n`,
-	UserInRoomMeta
-> = join(
-	{
+export const usersInRooms: JoinToken<`room`, string, `user`, string, `1:n`> =
+	join({
 		key: `usersInRooms`,
 		between: [`room`, `user`],
 		cardinality: `1:n`,
 		isAType: (input): input is string => typeof input === `string`,
 		isBType: (input): input is string => typeof input === `string`,
-	},
-	DEFAULT_USER_IN_ROOM_META,
-)
+	})
 
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<SetRTX<string>>[],
+	MutableAtomToken<UList<string>>[],
 	string
-> = selectorFamily<MutableAtomToken<SetRTX<string>>[], string>({
+> = selectorFamily<MutableAtomToken<UList<string>>[], string>({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>

package/src/realtime-server/realtime-server-stores/server-room-external-store.ts

@@ -43,7 +43,7 @@ export const joinRoomTX: TransactionToken<
 		editRelationsInStore(
 			usersInRooms,
 			(relations) => {
-				relations.set({ room: roomId, user: userId }, meta)
+				relations.set({ room: roomId, user: userId })
 			},
 			tools.env().store,
 		)

package/src/struct/index.ts

@@ -0,0 +1 @@
+export * from "./micro"

package/src/{internal → struct}/micro.ts

@@ -1,6 +1,6 @@
 import type { primitive } from "atom.io/json"
 
-import type { Flat } from "./utility-types"
+import type { Flat } from "../internal/utility-types"
 
 export type IndexOf<
 	T extends readonly unknown[],

package/src/transceivers/o-list/o-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
 export type ArrayUpdate<P extends primitive> =
@@ -99,16 +96,23 @@ export type ArrayMutationHandler = {
 	[K in Exclude<OListUpdateType, `extend` | `set` | `truncate`>]: Fn
 }
 
+export type OListView<P extends primitive> = ReadonlyArray<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedArrayUpdate<P>) => void,
+	) => () => void
+}
+
 export class OList<P extends primitive>
 	extends Array<P>
 	implements
-		Transceiver<ReadonlyArray<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<OListView<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
 		ArrayMutationHandler
 {
 	public mode: TransceiverMode = `record`
 	public readonly subject: Subject<PackedArrayUpdate<P>> = new Subject()
 
-	public readonly READONLY_VIEW: ReadonlyArray<P> = this
+	public readonly READONLY_VIEW: OListView<P> = this
 
 	public constructor(arrayLength?: number)
 	public constructor(...items: P[])

package/src/transceivers/set-rtx/set-rtx.ts

@@ -12,6 +12,10 @@ export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 	readonly cacheLimit: number
 	readonly cacheIdx: number
 	readonly cacheUpdateNumber: number
+	readonly subscribe: (
+		key: string,
+		fn: (update: NumberedSetUpdateString) => void,
+	) => () => void
 }
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {

package/src/transceivers/u-list/u-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type SetMutations = Exclude<
 	keyof Set<any>,
@@ -34,10 +31,17 @@ export const SET_UPDATE_ENUM: Enumeration<[`add`, `delete`, `clear`]> =
 
 export type SetMutationHandler = { [K in UListUpdateType]: Fn }
 
+export type UListView<P extends primitive> = ReadonlySet<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedSetUpdate<P>) => void,
+	) => () => void
+}
+
 export class UList<P extends primitive>
 	extends Set<P>
 	implements
-		Transceiver<ReadonlySet<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<UListView<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
 		SetMutationHandler
 {
 	public mode: TransceiverMode = `record`
@@ -49,7 +53,7 @@ export class UList<P extends primitive>
 		}
 	}
 
-	public readonly READONLY_VIEW: ReadonlySet<P> = this
+	public readonly READONLY_VIEW: UListView<P> = this
 
 	public toJSON(): ReadonlyArray<P> {
 		return [...this]