atom.io 0.32.3 → 0.33.0

package/{realtime-server/src → src/realtime-server}/realtime-server-stores/server-sync-store.ts

@@ -1,4 +1,8 @@
-import type { TransactionUpdate, TransactionUpdateContent } from "atom.io"
+import type {
+	RegularAtomFamilyToken,
+	TransactionUpdate,
+	TransactionUpdateContent,
+} from "atom.io"
 import { atomFamily } from "atom.io"
 
 import type { UserKey } from "./server-user-store"
@@ -52,7 +56,12 @@ export function redactTransactionUpdateContent(
 		})
 }
 
-export const redactorAtoms = atomFamily<
+export const redactorAtoms: RegularAtomFamilyToken<
+	{
+		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+	},
+	UserKey
+> = atomFamily<
 	{
 		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
 	},
@@ -83,10 +92,10 @@ export type ContinuitySyncTransactionUpdate = Pick<
 	TransactionUpdate<any>,
 	`epoch` | `id` | `key` | `output` | `updates`
 >
-export const userUnacknowledgedQueues = atomFamily<
+export const userUnacknowledgedQueues: RegularAtomFamilyToken<
 	ContinuitySyncTransactionUpdate[],
 	UserKey
->({
+> = atomFamily<ContinuitySyncTransactionUpdate[], UserKey>({
 	key: `unacknowledgedUpdates`,
 	default: () => [],
 })

package/{realtime-server/src → src/realtime-server}/realtime-server-stores/server-user-store.ts

@@ -1,4 +1,9 @@
-import type { Hierarchy } from "atom.io"
+import type {
+	Hierarchy,
+	JoinToken,
+	MutableAtomToken,
+	RegularAtomFamilyToken,
+} from "atom.io"
 import { atom, atomFamily, join } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
@@ -18,26 +23,39 @@ export type SocketSystemHierarchy = Hierarchy<
 	]
 >
 
-export const socketAtoms = atomFamily<Socket | null, SocketKey>({
-	key: `sockets`,
-	default: null,
-})
+export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
+	atomFamily<Socket | null, SocketKey>({
+		key: `sockets`,
+		default: null,
+	})
 
-export const socketIndex = atom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
+export const socketIndex: MutableAtomToken<
+	SetRTX<SocketKey>,
+	SetRTXJson<SocketKey>
+> = atom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
 	key: `socketsIndex`,
 	mutable: true,
 	default: () => new SetRTX(),
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),
 })
-export const userIndex = atom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
+export const userIndex: MutableAtomToken<
+	SetRTX<UserKey>,
+	SetRTXJson<UserKey>
+> = atom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
 	key: `usersIndex`,
 	mutable: true,
 	default: () => new SetRTX(),
 	toJson: (set) => set.toJSON(),
 	fromJson: (json) => SetRTX.fromJSON(json),
 })
-export const usersOfSockets = join({
+export const usersOfSockets: JoinToken<
+	`user`,
+	UserKey,
+	`socket`,
+	SocketKey,
+	`1:1`
+> = join({
 	key: `usersOfSockets`,
 	between: [`user`, `socket`],
 	cardinality: `1:1`,

package/{transceivers/set-rtx/src → src/transceivers/set-rtx}/set-rtx.ts

@@ -19,7 +19,7 @@ export class SetRTX<P extends primitive>
 	implements Transceiver<NumberedSetUpdate>, Lineage
 {
 	public mode: TransceiverMode = `record`
-	public readonly subject = new Subject<SetUpdate>()
+	public readonly subject: Subject<SetUpdate> = new Subject<SetUpdate>()
 	public cacheLimit = 0
 	public cache: (NumberedSetUpdate | null)[] = []
 	public cacheIdx = -1
@@ -87,7 +87,7 @@ export class SetRTX<P extends primitive>
 		return result
 	}
 
-	public readonly parent: SetRTX<P> | null
+	public readonly parent: SetRTX<P> | null = null
 	public child: SetRTX<P> | null = null
 	public transactionUpdates: SetUpdate[] | null = null
 	public transaction(run: (child: SetRTX<P>) => boolean): void {

package/data/dist/index.d.ts

@@ -1,31 +0,0 @@
-import * as AtomIO from 'atom.io';
-import { Store } from 'atom.io/internal';
-import { Canonical, stringified } from 'atom.io/json';
-
-declare function dict<State, Key extends Canonical>(family: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamilyToken<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
-    [K in stringified<Key>]: State;
-}>;
-
-declare function struct<Struct extends {
-    [key: string]: unknown;
-}, Key extends string>(options: {
-    key: Key;
-    default: Struct;
-}, store?: Store): [
-    {
-        [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomIO.RegularAtomToken<Struct[K]>;
-    },
-    AtomIO.ReadonlySelectorToken<Struct>
-];
-
-declare function structFamily<Struct extends object, Key extends string>(options: {
-    key: Key;
-    default: Struct;
-}): [
-    {
-        [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>;
-    },
-    AtomIO.ReadonlySelectorFamilyToken<Struct, string>
-];
-
-export { dict, struct, structFamily };

package/data/dist/index.js

@@ -1,69 +0,0 @@
-import { IMPLICIT, createStandaloneSelector, findInStore, capitalize, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from '../../dist/chunk-35NB2XZU.js';
-import '../../dist/chunk-XWL6SNVU.js';
-
-// data/src/dict.ts
-function dict(family, index, store = IMPLICIT.STORE) {
-  return createStandaloneSelector(store, {
-    key: `${family.key}Dict`,
-    get: ({ get }) => {
-      const keys = get(index);
-      return keys.reduce((acc, key) => {
-        acc[key] = get(findInStore(store, family, key));
-        return acc;
-      }, {});
-    }
-  });
-}
-
-// data/src/struct.ts
-function struct(options, store = IMPLICIT.STORE) {
-  const atoms = Object.keys(options.default).reduce((acc, key) => {
-    const atomName = options.key + capitalize(key) + `State`;
-    acc[atomName] = createRegularAtom(
-      store,
-      {
-        key: `${options.key}.${key}`,
-        default: options.default[key]
-      },
-      void 0
-    );
-    return acc;
-  }, {});
-  const structState = createStandaloneSelector(store, {
-    key: options.key,
-    get: ({ get }) => {
-      return Object.keys(options.default).reduce((acc, key) => {
-        acc[key] = get(atoms[options.key + capitalize(key) + `State`]);
-        return acc;
-      }, {});
-    }
-  });
-  return [atoms, structState];
-}
-
-// data/src/struct-family.ts
-var nameFamily = (topKey, subKey) => `find` + capitalize(topKey) + capitalize(subKey) + `State`;
-function structFamily(options) {
-  const atoms = Object.keys(options.default).reduce((acc, subKey) => {
-    const atomFamilyName = nameFamily(options.key, subKey);
-    acc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {
-      key: `${options.key}.${subKey}`,
-      default: options.default[subKey]
-    });
-    return acc;
-  }, {});
-  const findStructState = createSelectorFamily(IMPLICIT.STORE, {
-    key: options.key,
-    get: (id) => ({ find, get }) => {
-      return Object.keys(options.default).reduce((acc, subKey) => {
-        acc[subKey] = get(
-          find(atoms[nameFamily(options.key, subKey)], id)
-        );
-        return acc;
-      }, {});
-    }
-  });
-  return [atoms, findStructState];
-}
-
-export { dict, struct, structFamily };

package/data/package.json

@@ -1,13 +0,0 @@
-{
-	"name": "atom.io-data",
-	"type": "module",
-	"private": true,
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	}
-}

package/dist/chunk-2XDFCXGB.js

@@ -1,109 +0,0 @@
-import { atom, SetRTX, join, selectorFamily, getInternalRelations, assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity } from './chunk-35NB2XZU.js';
-
-// realtime/src/realtime-continuity.ts
-var InvariantMap = class extends Map {
-  set(key, value) {
-    if (this.has(key)) {
-      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
-        key,
-        value
-      });
-      return this;
-    }
-    return super.set(key, value);
-  }
-  clear() {
-    throw new Error(`Cannot clear an InvariantMap`);
-  }
-};
-var SyncGroup = class _SyncGroup {
-  type = `continuity`;
-  globals = [];
-  actions = [];
-  perspectives = [];
-  key;
-  constructor(key) {
-    this.key = key;
-  }
-  static existing = new InvariantMap();
-  static create(key, builder) {
-    const group = new _SyncGroup(key);
-    const { type, globals, actions, perspectives } = builder(group);
-    const token = { type, key, globals, actions, perspectives };
-    _SyncGroup.existing.set(key, token);
-    return token;
-  }
-  add(...args) {
-    const zeroth = args[0];
-    switch (zeroth.type) {
-      case `atom`:
-      case `mutable_atom`:
-        this.globals.push(...args);
-        break;
-      case `transaction`:
-        this.actions.push(...args);
-        break;
-      case `atom_family`:
-      case `mutable_atom_family`:
-        {
-          const [family, index] = args;
-          this.perspectives.push({
-            type: `realtime_perspective`,
-            resourceAtoms: family,
-            viewAtoms: index
-          });
-        }
-        break;
-    }
-    return this;
-  }
-};
-function continuity(options) {
-  const { key, config } = options;
-  const token = SyncGroup.create(key, config);
-  const { actions } = token;
-  for (const action of actions) {
-    assignTransactionToContinuity(IMPLICIT.STORE, key, action.key);
-  }
-  setEpochNumberOfContinuity(IMPLICIT.STORE, key, -1);
-  return token;
-}
-
-// realtime/src/shared-room-store.ts
-var usersInThisRoomIndex = atom({
-  key: `usersInRoomIndex`,
-  mutable: true,
-  default: () => new SetRTX(),
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var roomIndex = atom({
-  key: `roomIndex`,
-  default: () => new SetRTX(),
-  mutable: true,
-  toJson: (set) => set.toJSON(),
-  fromJson: (json) => SetRTX.fromJSON(json)
-});
-var DEFAULT_USER_IN_ROOM_META = {
-  enteredAtEpoch: 0
-};
-var usersInRooms = join(
-  {
-    key: `usersInRooms`,
-    between: [`room`, `user`],
-    cardinality: `1:n`,
-    isAType: (input) => typeof input === `string`,
-    isBType: (input) => typeof input === `string`
-  },
-  DEFAULT_USER_IN_ROOM_META
-);
-var usersInMyRoomView = selectorFamily({
-  key: `usersInMyRoomView`,
-  get: (myUsername) => ({ find }) => {
-    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
-    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
-    return [myRoomIndex];
-  }
-});
-
-export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };