atom.io 0.31.1 → 0.32.0

package/realtime-testing/dist/index.js

@@ -1,15 +1,13 @@
+import { RealtimeProvider } from '../../dist/chunk-354XQWHH.js';
+import { myUsernameState } from '../../dist/chunk-Z2UJW4NQ.js';
+import { socketAtoms, usersOfSockets, userIndex, socketIndex, roomSelectors } from '../../dist/chunk-R3ZUK5EH.js';
+import { roomIndex } from '../../dist/chunk-NF7FJKJD.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import { StoreProvider } from '../../dist/chunk-5F2V7S3B.js';
+import { Silo, IMPLICIT, Realm, findInStore, setIntoStore, editRelationsInStore, toEntries, findRelationsInStore, getFromStore, AtomIOLogger, clearStore } from '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import * as http from 'node:http';
 import { render, prettyDOM } from '@testing-library/react';
-import * as AtomIO from 'atom.io';
-import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';
-import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
-import { toEntries } from 'atom.io/json';
-import * as AR from 'atom.io/react';
-import * as RT from 'atom.io/realtime';
-import * as RTC from 'atom.io/realtime-client';
-import * as RTR from 'atom.io/realtime-react';
-import * as RTS from 'atom.io/realtime-server';
 import * as Happy from 'happy-dom';
 import * as SocketIO from 'socket.io';
 import { io } from 'socket.io-client';
@@ -17,7 +15,7 @@ import { jsx } from 'react/jsx-runtime';
 
 var testNumber = 0;
 function prefixLogger(store, prefix) {
-  store.loggers[0] = new AtomIO.AtomIOLogger(`info`, undefined, {
+  store.loggers[0] = new AtomIOLogger(`info`, undefined, {
     info: (...args) => {
       console.info(prefix, ...args);
     },
@@ -31,14 +29,14 @@ function prefixLogger(store, prefix) {
 }
 var setupRealtimeTestServer = (options) => {
   ++testNumber;
-  const silo = new AtomIO.Silo(
+  const silo = new Silo(
     {
       name: `SERVER-${testNumber}`,
       lifespan: options.immortal?.server ? `immortal` : `ephemeral`
     },
     IMPLICIT.STORE
   );
-  const socketRealm = new AtomIO.Realm(silo.store);
+  const socketRealm = new Realm(silo.store);
   const httpServer = http.createServer((_, res) => res.end(`Hello World!`));
   const address = httpServer.listen(options.port).address();
   const port = typeof address === `string` ? null : address === null ? null : address.port;
@@ -48,19 +46,19 @@ var setupRealtimeTestServer = (options) => {
     if (token === `test` && socket.id) {
       const userClaim = socketRealm.allocate(`root`, `user::${username}`);
       const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`);
-      const socketState = findInStore(silo.store, RTS.socketAtoms, socketClaim);
+      const socketState = findInStore(silo.store, socketAtoms, socketClaim);
       setIntoStore(silo.store, socketState, socket);
       editRelationsInStore(
-        RTS.usersOfSockets,
+        usersOfSockets,
         (relations) => {
           relations.set(userClaim, socketClaim);
         },
         silo.store
       );
-      setIntoStore(silo.store, RTS.userIndex, (index) => index.add(userClaim));
+      setIntoStore(silo.store, userIndex, (index) => index.add(userClaim));
       setIntoStore(
         silo.store,
-        RTS.socketIndex,
+        socketIndex,
         (index) => index.add(socketClaim)
       );
       next();
@@ -72,7 +70,7 @@ var setupRealtimeTestServer = (options) => {
     let userKey = null;
     function enableLogging() {
       const userKeyState = findRelationsInStore(
-        RTS.usersOfSockets,
+        usersOfSockets,
         `socket::${socket.id}`,
         silo.store
       ).userKeyOfSocket;
@@ -92,9 +90,9 @@ var setupRealtimeTestServer = (options) => {
   });
   const dispose = async () => {
     await server.close();
-    const roomKeys = getFromStore(silo.store, RT.roomIndex);
+    const roomKeys = getFromStore(silo.store, roomIndex);
     for (const roomKey of roomKeys) {
-      const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey);
+      const roomState = findInStore(silo.store, roomSelectors, roomKey);
       const room = getFromStore(silo.store, roomState);
       if (room && !(room instanceof Promise)) {
         room.process.kill();
@@ -116,17 +114,17 @@ var setupRealtimeTestClient = (options, name, port) => {
     const socket = io(`http://localhost:${port}/`, {
       auth: { token: `test`, username: `${name}-${testNumber}` }
     });
-    const silo = new AtomIO.Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE);
+    const silo = new Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE);
     for (const [key, value] of silo.store.valueMap.entries()) {
       if (Array.isArray(value)) {
         silo.store.valueMap.set(key, [...value]);
       }
     }
-    silo.setState(RTC.myUsernameState, `${name}-${testNumber}`);
+    silo.setState(myUsernameState, `${name}-${testNumber}`);
     const { document } = new Happy.Window();
     document.body.innerHTML = `<div id="app"></div>`;
     const renderResult = render(
-      /* @__PURE__ */ jsx(AR.StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsx(RTR.RealtimeProvider, { socket, children: /* @__PURE__ */ jsx(options.client, {}) }) }),
+      /* @__PURE__ */ jsx(StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsx(RealtimeProvider, { socket, children: /* @__PURE__ */ jsx(options.client, {}) }) }),
       {
         container: document.querySelector(`#app`)
       }

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

@@ -3,11 +3,12 @@ import * as http from "node:http"
 import type { RenderResult } from "@testing-library/react"
 import { prettyDOM, render } from "@testing-library/react"
 import * as AtomIO from "atom.io"
-import { editRelationsInStore, findRelationsInStore } from "atom.io/data"
 import type { Store } from "atom.io/internal"
 import {
 	clearStore,
+	editRelationsInStore,
 	findInStore,
+	findRelationsInStore,
 	getFromStore,
 	IMPLICIT,
 	setIntoStore,

package/src/index.ts

@@ -17,7 +17,9 @@ import type {
 
 export * from "./atom"
 export * from "./dispose-state"
+export * from "./find-state"
 export * from "./get-state"
+export * from "./join"
 export * from "./logger"
 export * from "./realm"
 export * from "./selector"
@@ -146,3 +148,5 @@ export type FamilyMetadata<K extends Canonical = any> = {
 	/** The family member's unique identifier, in the form of a string. */
 	subKey: stringified<K>
 }
+
+export type Loadable<T> = Promise<T> | T

package/src/join.ts

@@ -0,0 +1,218 @@
+import type { MutableAtomFamilyToken, ReadonlySelectorToken } from "atom.io"
+import type {
+	Junction,
+	JunctionEntriesBase,
+	JunctionSchemaBase,
+	Refinement,
+	Store,
+} from "atom.io/internal"
+import {
+	editRelationsInStore,
+	findRelationsInStore,
+	getInternalRelationsFromStore,
+	IMPLICIT,
+	Join,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+
+export interface JoinOptions<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+> extends JunctionSchemaBase<ASide, BSide>,
+		Partial<JunctionEntriesBase<AType, BType, Content>> {
+	readonly key: string
+	readonly cardinality: Cardinality
+	readonly isAType: Refinement<string, AType>
+	readonly isBType: Refinement<string, BType>
+}
+
+export type JoinToken<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null = null,
+> = {
+	key: string
+	type: `join`
+	cardinality: Cardinality
+	a: ASide
+	b: BSide
+	__aType?: AType
+	__bType?: BType
+	__content?: 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`,
+>(
+	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>,
+	defaultContent?: undefined,
+	store?: Store,
+): JoinToken<ASide, AType, BSide, BType, Cardinality, null>
+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,
+	store?: Store,
+): 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,
+	store: Store = IMPLICIT.STORE,
+): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {
+	store.joins.set(options.key, new Join(options, defaultContent, store))
+	const token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content> = {
+		key: options.key,
+		type: `join`,
+		a: options.between[0],
+		b: options.between[1],
+		cardinality: options.cardinality,
+	}
+	return token
+}
+
+export type JoinStates<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType 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>}`]: ReadonlySelectorToken<
+						[AType, Content] | null,
+						BType
+					>
+				} & {
+					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+						[BType, Content] | null,
+						AType
+					>
+				}
+			: {}) & {
+			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+				AType | null,
+				BType
+			>
+		} & {
+			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+				BType | null,
+				AType
+			>
+		}
+	: Cardinality extends `1:n`
+		? (Content extends Json.Object
+				? {
+						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+							[AType, Content] | null,
+							BType
+						>
+					} & {
+						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+							[BType, Content][],
+							AType
+						>
+					}
+				: {}) & {
+				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+					AType | null,
+					BType
+				>
+			} & {
+				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+					BType[],
+					AType
+				>
+			}
+		: Cardinality extends `n:n`
+			? (Content extends Json.Object
+					? {
+							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+								[AType, Content][],
+								BType
+							>
+						} & {
+							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+								[BType, Content][],
+								AType
+							>
+						}
+					: {}) & {
+					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+						AType[],
+						BType
+					>
+				} & {
+					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+						BType[],
+						AType
+					>
+				}
+			: never
+
+export function findRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType 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> {
+	return findRelationsInStore(token, key, IMPLICIT.STORE)
+}
+
+export function editRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType 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,
+): void {
+	editRelationsInStore(token, change, IMPLICIT.STORE)
+}
+
+export function getInternalRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType 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>, SetRTXJson<string>, string> {
+	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
+}

package/src/silo.ts

@@ -1,4 +1,4 @@
-import type { findState } from "atom.io/ephemeral"
+import type { findState } from "atom.io"
 import {
 	actUponStore,
 	arbitrary,
@@ -61,8 +61,8 @@ export class Silo {
 			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.transaction = (options) => createTransaction(s, options)
+		this.timeline = (options) => createTimeline(s, options)
 		this.findState = ((...params: Parameters<typeof findState>) =>
 			findInStore(s, ...params)) as typeof findState
 		this.getState = ((...params: Parameters<typeof getState>) =>
@@ -81,7 +81,7 @@ export class Silo {
 		this.redo = (token) => {
 			timeTravel(s, `redo`, token)
 		}
-		this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s)
+		this.runTransaction = (token, id = arbitrary()) => actUponStore(s, token, id)
 		this.install = (tokens, source = IMPLICIT.STORE) => {
 			installIntoStore(tokens, s, source)
 		}

package/src/timeline.ts

@@ -49,7 +49,7 @@ export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 export const timeline = <ManagedAtom extends TimelineManageable>(
 	options: TimelineOptions<ManagedAtom>,
 ): TimelineToken<ManagedAtom> => {
-	return createTimeline(options, IMPLICIT.STORE)
+	return createTimeline(IMPLICIT.STORE, options)
 }
 
 export const redo = (tl: TimelineToken<any>): void => {

package/src/transaction.ts

@@ -1,6 +1,4 @@
-import type { getState, setState } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
+import type { findState, getState, setState } from "atom.io"
 import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
@@ -83,12 +81,11 @@ export type TransactionUpdate<F extends Func> = {
 	output: ReturnType<F>
 }
 
-export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json` | `seek`>
+export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>
 export type SetterToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
 	find: typeof findState
-	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
@@ -97,7 +94,6 @@ export type ActorToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
 	find: typeof findState
-	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
@@ -132,12 +128,12 @@ export type TransactionIO<Token extends TransactionToken<any>> =
 export function transaction<F extends Func>(
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
-	return createTransaction(options, IMPLICIT.STORE)
+	return createTransaction(IMPLICIT.STORE, options)
 }
 
 export function runTransaction<F extends Func>(
 	token: TransactionToken<F>,
 	id = arbitrary(),
 ): (...parameters: Parameters<F>) => ReturnType<F> {
-	return actUponStore(token, id, IMPLICIT.STORE)
+	return actUponStore(IMPLICIT.STORE, token, id)
 }

package/transceivers/set-rtx/dist/index.d.ts

@@ -1,5 +1,40 @@
-import { Transceiver, Lineage, TransceiverMode, Subject } from 'atom.io/internal';
-import { primitive, Json } from 'atom.io/json';
+type primitive = boolean | number | string | null;
+declare namespace Json {
+    namespace Tree {
+        type Array<Element = unknown> = ReadonlyArray<Element>;
+        type Object<K extends string = string, V = unknown> = Record<K, V>;
+        type Fork = Array | Object;
+        type Leaf = primitive;
+        type Node = Fork | Leaf;
+    }
+    type Serializable = primitive | Readonly<{
+        [key: string]: Serializable;
+    }> | ReadonlyArray<Serializable>;
+    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
+
+declare class Subject<T> {
+    Subscriber: (value: T) => void;
+    subscribers: Map<string, this[`Subscriber`]>;
+    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
+
+interface Lineage {
+    parent: typeof this | null;
+    child: typeof this | null;
+}
+
+interface Transceiver<S extends Json.Serializable> {
+    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;
+}
+type TransceiverMode = `playback` | `record` | `transaction`;
 
 type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
 type NumberedSetUpdate = `${number}=${SetUpdate}`;