atom.io 0.24.4 → 0.24.6

package/realtime-server/dist/index.js

@@ -1,11 +1,11 @@
 import { __spreadProps, __spreadValues } from '../../dist/chunk-S4N6XNPH.js';
 import { parseJson, stringifyJson } from 'atom.io/json';
-import { getUpdateToken, IMPLICIT, Subject, getFromStore, subscribeToState, findInStore, getJsonToken, actUponStore, isRootStore, subscribeToTransaction, setIntoStore } from 'atom.io/internal';
+import { Subject, IMPLICIT, getFromStore, subscribeToState, findInStore, getJsonToken, getUpdateToken, actUponStore, isRootStore, subscribeToTransaction, setIntoStore } from 'atom.io/internal';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 import { editRelationsInStore, join, findRelationsInStore } from 'atom.io/data';
 import * as AtomIO from 'atom.io';
-import { selectorFamily, atomFamily, atom } from 'atom.io';
-import { SyncGroup, roomIndex, usersInRooms } from 'atom.io/realtime';
+import { atomFamily, selectorFamily, atom } from 'atom.io';
+import { roomIndex, usersInRooms } from 'atom.io/realtime';
 import { spawn } from 'child_process';
 
 // realtime-server/src/ipc-sockets/custom-socket.ts
@@ -329,67 +329,6 @@ function realtimeActionReceiver({
     };
   };
 }
-selectorFamily({
-  key: `perspectiveRedactor`,
-  get: ({ userId, syncGroupKey }) => ({ get, find }) => {
-    const syncGroup = SyncGroup.existing.get(syncGroupKey);
-    if (!syncGroup) {
-      throw new Error(
-        `Tried to create a synchronizer for a sync group that does not exist.`
-      );
-    }
-    const userPerspectiveTokens = syncGroup.perspectives.flatMap(
-      ({ viewAtoms }) => {
-        const userPerspectiveToken = find(viewAtoms, userId);
-        const userPerspective = get(userPerspectiveToken);
-        const visibleTokens = [...userPerspective].map((token) => {
-          return token.type === `mutable_atom` ? getUpdateToken(token).key : token.key;
-        });
-        IMPLICIT.STORE.logger.info(
-          `\u{1F52D}`,
-          `continuity`,
-          syncGroupKey,
-          `${userId} can see ${visibleTokens.length} tokens in ${viewAtoms.key}`,
-          visibleTokens
-        );
-        return visibleTokens;
-      }
-    );
-    const filterTransactionUpdate = (visible, transactionUpdate) => {
-      IMPLICIT.STORE.logger.info(
-        `\u{1F58C}`,
-        `continuity`,
-        syncGroupKey,
-        `redacting updates from ${transactionUpdate.epoch}:${transactionUpdate.key}:${transactionUpdate.id}`,
-        visible,
-        transactionUpdate.updates
-      );
-      const updates = transactionUpdate.updates.filter((update) => {
-        if (`newValue` in update) {
-          return visible.includes(update.key);
-        }
-        return true;
-      }).map((update) => {
-        if (`updates` in update) {
-          return filterTransactionUpdate(visible, update);
-        }
-        return update;
-      });
-      const filtered = __spreadProps(__spreadValues({}, transactionUpdate), {
-        updates
-      });
-      return filtered;
-    };
-    const filter = (update) => {
-      const visibleKeys = syncGroup.globals.map(
-        (atomToken) => atomToken.type === `mutable_atom` ? getUpdateToken(atomToken).key : atomToken.key
-      );
-      visibleKeys.push(...userPerspectiveTokens);
-      return filterTransactionUpdate(visibleKeys, update);
-    };
-    return filter;
-  }
-});
 var roomArgumentsAtoms = atomFamily({
   key: `roomArguments`,
   default: [`echo`, [`Hello World!`]]

package/realtime-server/src/realtime-server-stores/index.ts

@@ -1,4 +1,3 @@
-export * from "./realtime-continuity-store"
 export * from "./server-room-external-actions"
 export * from "./server-room-external-store"
 export * from "./server-sync-store"

package/src/transaction.ts

@@ -57,7 +57,7 @@ export type MoleculeDisposal = {
 	token: MoleculeToken<any>
 	family: MoleculeFamilyToken<any>
 	context: MoleculeToken<any>[]
-	familyKeys: string[]
+	values: [key: string, value: any][]
 }
 
 export type TransactionUpdateContent =

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -1,265 +0,0 @@
-import type {
-	AtomToken,
-	Func,
-	TimelineUpdate,
-	TransactionToken,
-	TransactionUpdate,
-} from "atom.io"
-
-import { newest } from "../lineage"
-import { getUpdateToken } from "../mutable"
-import type { Store } from "../store"
-import { withdraw } from "../store"
-import type {
-	Timeline,
-	TimelineAtomUpdate,
-	TimelineTransactionUpdate,
-} from "./create-timeline"
-
-export const addAtomToTimeline = (
-	atomToken: AtomToken<any>,
-	tl: Timeline<any>,
-	store: Store,
-): void => {
-	let maybeAtom = withdraw(atomToken, store)
-	if (maybeAtom.type === `mutable_atom`) {
-		const updateToken = getUpdateToken(maybeAtom)
-		maybeAtom = withdraw(updateToken, store)
-	}
-	const atom = maybeAtom
-	store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key })
-
-	tl.subscriptions.set(
-		atom.key,
-		atom.subject.subscribe(`timeline`, (update) => {
-			const target = newest(store)
-			const currentSelectorKey =
-				store.operation.open && store.operation.token.type === `selector`
-					? store.operation.token.key
-					: null
-			const currentSelectorTime =
-				store.operation.open && store.operation.token.type === `selector`
-					? store.operation.time
-					: null
-			const { transactionApplying } = target.on
-			const currentTransactionKey = transactionApplying.state?.update.key
-			const currentTransactionInstanceId = transactionApplying.state?.update.id
-
-			store.logger.info(
-				`⏳`,
-				`timeline`,
-				tl.key,
-				`atom`,
-				atomToken.key,
-				`went`,
-				update.oldValue,
-				`->`,
-				update.newValue,
-				currentTransactionKey
-					? `in transaction "${currentTransactionKey}"`
-					: currentSelectorKey
-						? `in selector "${currentSelectorKey}"`
-						: ``,
-			)
-			if (tl.timeTraveling === null) {
-				if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
-					const mostRecentUpdate: TimelineUpdate<any> | undefined =
-						tl.history.at(-1)
-					if (mostRecentUpdate === undefined) {
-						throw new Error(
-							`Timeline "${tl.key}" has a selectorTime, but no history. This is most likely a bug in AtomIO.`,
-						)
-					}
-				}
-				if (currentTransactionKey) {
-					const txToken: TransactionToken<any> = {
-						key: currentTransactionKey,
-						type: `transaction`,
-					}
-					const currentTransaction = withdraw(txToken, store)
-					if (tl.transactionKey !== currentTransactionKey) {
-						if (tl.transactionKey) {
-							store.logger.error(
-								`🐞`,
-								`timeline`,
-								tl.key,
-								`unable to resolve transaction "${tl.transactionKey}. This is probably a bug in AtomIO.`,
-							)
-						}
-						tl.transactionKey = currentTransactionKey
-						const unsubscribe = currentTransaction.subject.subscribe(
-							`timeline:${tl.key}`,
-							(transactionUpdate) => {
-								unsubscribe()
-								if (tl.timeTraveling === null && currentTransactionInstanceId) {
-									if (tl.at !== tl.history.length) {
-										tl.history.splice(tl.at)
-									}
-
-									const filterUpdates = (
-										updates: TransactionUpdate<Func>[`updates`],
-									) =>
-										updates
-											.filter((updateFromTx) => {
-												const newestStore = newest(store)
-												if (`updates` in updateFromTx) {
-													return true
-												}
-												const atomOrFamilyKeys =
-													newestStore.timelineAtoms.getRelatedKeys(tl.key)
-
-												if (!atomOrFamilyKeys) {
-													return false
-												}
-												let key: string | undefined
-												let familyKey: string | undefined
-												switch (updateFromTx.type) {
-													case `state_creation`:
-													case `state_disposal`:
-														key = updateFromTx.token.key
-														familyKey = updateFromTx.token.family?.key
-														break
-													case `molecule_creation`:
-													case `molecule_disposal`:
-														break
-													default:
-														key = updateFromTx.key
-														familyKey = updateFromTx.family?.key
-														break
-												}
-												if (key === undefined) {
-													return false
-												}
-												if (atomOrFamilyKeys.has(key)) {
-													return true
-												}
-												if (familyKey !== undefined) {
-													return atomOrFamilyKeys.has(familyKey)
-												}
-												return false
-											})
-											.map((updateFromTx) => {
-												if (`updates` in updateFromTx) {
-													return {
-														...updateFromTx,
-														updates: filterUpdates(updateFromTx.updates),
-													}
-												}
-												return updateFromTx
-											})
-
-									const updates = filterUpdates(transactionUpdate.updates)
-
-									const timelineTransactionUpdate: TimelineTransactionUpdate = {
-										timestamp: Date.now(),
-										...transactionUpdate,
-										updates,
-									}
-									const willCapture =
-										tl.shouldCapture?.(timelineTransactionUpdate, tl) ?? true
-									if (willCapture) {
-										tl.history.push(timelineTransactionUpdate)
-										tl.at = tl.history.length
-										tl.subject.next(timelineTransactionUpdate)
-									}
-								}
-								tl.transactionKey = null
-								store.logger.info(
-									`⌛`,
-									`timeline`,
-									tl.key,
-									`got a transaction_update "${transactionUpdate.key}"`,
-								)
-							},
-						)
-					}
-				} else if (currentSelectorKey && currentSelectorTime) {
-					let latestUpdate: TimelineUpdate<any> | undefined = tl.history.at(-1)
-
-					if (currentSelectorTime !== tl.selectorTime) {
-						latestUpdate = {
-							type: `selector_update`,
-							timestamp: currentSelectorTime,
-							key: currentSelectorKey,
-							atomUpdates: [],
-						}
-						latestUpdate.atomUpdates.push({
-							key: atom.key,
-							type: `atom_update`,
-							...update,
-						})
-						if (tl.at !== tl.history.length) {
-							tl.history.splice(tl.at)
-						}
-
-						tl.history.push(latestUpdate)
-
-						store.logger.info(
-							`⌛`,
-							`timeline`,
-							tl.key,
-							`got a selector_update "${currentSelectorKey}" with`,
-							latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
-						)
-
-						tl.at = tl.history.length
-						tl.selectorTime = currentSelectorTime
-					} else {
-						if (latestUpdate?.type === `selector_update`) {
-							latestUpdate.atomUpdates.push({
-								key: atom.key,
-								type: `atom_update`,
-								...update,
-							})
-							store.logger.info(
-								`⌛`,
-								`timeline`,
-								tl.key,
-								`set selector_update "${currentSelectorKey}" to`,
-								latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
-							)
-						}
-					}
-					if (latestUpdate) {
-						const willCaptureSelectorUpdate =
-							tl.shouldCapture?.(latestUpdate, tl) ?? true
-						if (willCaptureSelectorUpdate) {
-							tl.subject.next(latestUpdate)
-						} else {
-							tl.history.pop()
-							tl.at = tl.history.length
-						}
-					}
-				} else {
-					const timestamp = Date.now()
-					tl.selectorTime = null
-					if (tl.at !== tl.history.length) {
-						tl.history.splice(tl.at)
-					}
-					const atomUpdate: TimelineAtomUpdate<any> = {
-						type: `atom_update`,
-						timestamp,
-						key: atom.key,
-						oldValue: update.oldValue,
-						newValue: update.newValue,
-					}
-					if (atom.family) {
-						atomUpdate.family = atom.family
-					}
-					const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true
-					store.logger.info(
-						`⌛`,
-						`timeline`,
-						tl.key,
-						`got an atom_update to "${atom.key}"`,
-					)
-					if (willCapture) {
-						tl.history.push(atomUpdate)
-						tl.at = tl.history.length
-						tl.subject.next(atomUpdate)
-					}
-				}
-			}
-		}),
-	)
-}

package/realtime-server/src/realtime-server-stores/realtime-continuity-store.ts

@@ -1,109 +0,0 @@
-import type { TransactionUpdate } from "atom.io"
-import { selectorFamily } from "atom.io"
-import { getJsonToken, getUpdateToken, IMPLICIT } from "atom.io/internal"
-import type { JsonIO } from "atom.io/json"
-import { SyncGroup } from "atom.io/realtime"
-// import { completeUpdateAtoms } from "atom.io/realtime-server"
-
-const redactorAtoms = selectorFamily<
-	(update: TransactionUpdate<any>) => TransactionUpdate<any>,
-	{ userId: string; syncGroupKey: string }
->({
-	key: `perspectiveRedactor`,
-	get:
-		({ userId, syncGroupKey }) =>
-		({ get, find }) => {
-			const syncGroup = SyncGroup.existing.get(syncGroupKey)
-			if (!syncGroup) {
-				throw new Error(
-					`Tried to create a synchronizer for a sync group that does not exist.`,
-				)
-			}
-
-			const userPerspectiveTokens = syncGroup.perspectives.flatMap(
-				({ viewAtoms }) => {
-					const userPerspectiveToken = find(viewAtoms, userId)
-					const userPerspective = get(userPerspectiveToken)
-					const visibleTokens = [...userPerspective].map((token) => {
-						return token.type === `mutable_atom`
-							? getUpdateToken(token).key
-							: token.key
-					})
-					IMPLICIT.STORE.logger.info(
-						`🔭`,
-						`continuity`,
-						syncGroupKey,
-						`${userId} can see ${visibleTokens.length} tokens in ${viewAtoms.key}`,
-						visibleTokens,
-					)
-					return visibleTokens
-				},
-			)
-
-			const filterTransactionUpdate = (
-				visible: string[],
-				transactionUpdate: TransactionUpdate<any>,
-			): TransactionUpdate<any> => {
-				IMPLICIT.STORE.logger.info(
-					`🖌`,
-					`continuity`,
-					syncGroupKey,
-					`redacting updates from ${transactionUpdate.epoch}:${transactionUpdate.key}:${transactionUpdate.id}`,
-					visible,
-					transactionUpdate.updates,
-				)
-				const updates = transactionUpdate.updates
-					.filter((update) => {
-						if (`newValue` in update) {
-							return visible.includes(update.key)
-						}
-						return true
-					})
-					.map((update) => {
-						if (`updates` in update) {
-							return filterTransactionUpdate(visible, update)
-						}
-						return update
-					})
-				const filtered: TransactionUpdate<any> = {
-					...transactionUpdate,
-					updates,
-				}
-				return filtered
-			}
-			const filter: (updates: TransactionUpdate<any>) => TransactionUpdate<any> =
-				(update) => {
-					const visibleKeys: string[] = syncGroup.globals.map((atomToken) =>
-						atomToken.type === `mutable_atom`
-							? getUpdateToken(atomToken).key
-							: atomToken.key,
-					)
-					visibleKeys.push(...userPerspectiveTokens)
-					return filterTransactionUpdate(visibleKeys, update)
-				}
-			return filter
-		},
-})
-// export const occludedUpdateSelectors = selectorFamily<
-// 	Pick<
-// 		TransactionUpdate<JsonIO>,
-// 		`epoch` | `id` | `key` | `output` | `updates`
-// 	> | null,
-// 	{ userId: string; syncGroupKey: string; updateId: string }
-// >({
-// 	key: `occludedUpdate`,
-// 	get:
-// 		({ userId, syncGroupKey, updateId }) =>
-// 		({ get, find }) => {
-// 			const updateState = find(completeUpdateAtoms, updateId)
-// 			const update = get(updateState)
-// 			const redactorKey = { userId, syncGroupKey }
-// 			const redactorState = find(redactorAtoms, redactorKey)
-// 			const redact = get(redactorState)
-// 			if (update) {
-// 				// return redact(update)
-// 				return update
-// 			}
-// 			return null
-// 		},
-// })