atom.io 0.23.4 → 0.24.0

package/realtime-testing/dist/index.cjs

@@ -3,17 +3,16 @@
 var http = require('http');
 var react = require('@testing-library/react');
 var AtomIO = require('atom.io');
+var data = require('atom.io/data');
 var internal = require('atom.io/internal');
 var AR = require('atom.io/react');
 var RT = require('atom.io/realtime');
+var realtimeClient = require('atom.io/realtime-client');
 var RTR = require('atom.io/realtime-react');
 var RTS = require('atom.io/realtime-server');
 var Happy = require('happy-dom');
 var SocketIO = require('socket.io');
 var socket_ioClient = require('socket.io-client');
-require('atom.io/immortal');
-require('atom.io/json');
-require('atom.io/transceivers/set-rtx');
 var jsxRuntime = require('react/jsx-runtime');
 
 function _interopNamespace(e) {
@@ -65,83 +64,6 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
 // ../anvl/src/object/entries.ts
 var recordToEntries = (obj) => Object.entries(obj);
-function getJoinMap(store) {
-  if (`joins` in store && store.joins instanceof Map) {
-    return store.joins;
-  }
-  const joins = /* @__PURE__ */ new Map();
-  store.joins = joins;
-  return joins;
-}
-function getJoin(token, store) {
-  var _a;
-  const joinMap = getJoinMap(store);
-  let myJoin = joinMap.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
-    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (myJoin === void 0) {
-      throw new Error(
-        `Join "${token.key}" not found in store "${store.config.name}"`
-      );
-    }
-    joinMap.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-function editRelationsInStore(token, change, store) {
-  const myJoin = getJoin(token, store);
-  const target = internal.newest(store);
-  if (internal.isChildStore(target)) {
-    const { transactors } = target.transactionMeta;
-    myJoin.transact(transactors, ({ relations }) => {
-      change(relations);
-    });
-  } else {
-    change(myJoin.relations);
-  }
-}
-
-// __unstable__/web-effects/src/storage.ts
-var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
-  const savedValue = storage.getItem(key);
-  if (savedValue != null)
-    setSelf(parse(savedValue));
-  onSet(({ newValue }) => {
-    if (newValue == null) {
-      storage.removeItem(key);
-      return;
-    }
-    storage.setItem(key, stringify(newValue));
-  });
-};
-var lazyLocalStorageEffect = persistAtom(window.localStorage)(JSON);
-
-// realtime-client/src/realtime-client-stores/client-main-store.ts
-var myIdState__INTERNAL = AtomIO__namespace.atom({
-  key: `mySocketId__INTERNAL`,
-  default: void 0
-});
-AtomIO__namespace.selector({
-  key: `mySocketId`,
-  get: ({ get }) => get(myIdState__INTERNAL)
-});
-var usernameEffects = typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)];
-var myUsernameState = AtomIO__namespace.atom({
-  key: `myUsername`,
-  default: null,
-  effects: usernameEffects
-});
-AtomIO__namespace.atom({
-  key: `updateQueue`,
-  default: []
-});
-AtomIO__namespace.atom(
-  {
-    key: `serverConfirmedUpdateQueue`,
-    default: []
-  }
-);
 var testNumber = 0;
 var setupRealtimeTestServer = (options) => {
   ++testNumber;
@@ -159,7 +81,7 @@ var setupRealtimeTestServer = (options) => {
     if (token === `test` && socket.id) {
       const socketState = internal.findInStore(RTS__namespace.socketAtoms, socket.id, silo.store);
       internal.setIntoStore(socketState, socket, silo.store);
-      editRelationsInStore(
+      data.editRelationsInStore(
         RTS__namespace.usersOfSockets,
         (relations) => {
           relations.set(socket.id, username);
@@ -209,7 +131,7 @@ var setupRealtimeTestClient = (options, name, port) => {
         silo.store.valueMap.set(key, [...value]);
       }
     }
-    silo.setState(myUsernameState, `${name}-${testNumber}`);
+    silo.setState(realtimeClient.myUsernameState, `${name}-${testNumber}`);
     const { document } = new Happy__namespace.Window();
     document.body.innerHTML = `<div id="app"></div>`;
     const renderResult = react.render(

package/realtime-testing/dist/index.js

@@ -1,15 +1,13 @@
 import { recordToEntries } from '../../dist/chunk-3V3VWQ7X.js';
-import { myUsernameState } from '../../dist/chunk-O47EQUM6.js';
-import '../../dist/chunk-BWWVY5O5.js';
-import { editRelationsInStore } from '../../dist/chunk-7DT3PVS3.js';
-import '../../dist/chunk-FTONNX2R.js';
 import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
 import * as http from 'http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
+import { editRelationsInStore } from 'atom.io/data';
 import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
 import * as AR from 'atom.io/react';
 import * as RT from 'atom.io/realtime';
+import { myUsernameState } 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';

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

@@ -3,6 +3,7 @@ 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 } from "atom.io/data"
 import {
 	clearStore,
 	findInStore,
@@ -12,6 +13,7 @@ import {
 } from "atom.io/internal"
 import * as AR from "atom.io/react"
 import * as RT from "atom.io/realtime"
+import { myUsernameState } 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"
@@ -22,9 +24,6 @@ import { io } from "socket.io-client"
 
 import { recordToEntries } from "~/packages/anvl/src/object"
 
-import { editRelationsInStore } from "../../data/src/join"
-import { myUsernameState } from "../../realtime-client/src/realtime-client-stores"
-
 let testNumber = 0
 
 export type TestSetupOptions = {

package/src/dispose-state.ts

@@ -1,10 +1,10 @@
-import type { MoleculeToken } from "atom.io/immortal"
 import * as Internal from "atom.io/internal"
 
 import type { ReadableToken } from "."
+import type { MoleculeToken } from "./molecule"
 
 export function disposeState(
-	token: MoleculeToken<any, any, any> | ReadableToken<any>,
+	token: MoleculeToken<any> | ReadableToken<any>,
 ): void {
 	Internal.disposeFromStore(token, Internal.IMPLICIT.STORE)
 }

package/src/index.ts

@@ -13,6 +13,7 @@ export * from "./atom"
 export * from "./dispose-state"
 export * from "./get-state"
 export * from "./logger"
+export * from "./molecule"
 export * from "./selector"
 export * from "./set-state"
 export * from "./silo"

package/src/logger.ts

@@ -54,6 +54,8 @@ export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
 	| `atom`
 	| `continuity`
+	| `molecule_family`
+	| `molecule`
 	| `mutable_atom`
 	| `readonly_selector`
 	| `selector`

package/src/molecule.ts

@@ -0,0 +1,133 @@
+import type {
+	Flat,
+	MoleculeCreation,
+	MoleculeDisposal,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	TransactorsWithRunAndEnv,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { JoinToken } from "atom.io/data"
+import type { Store, Subject, Transceiver } from "atom.io/internal"
+import {
+	createMoleculeFamily,
+	IMPLICIT,
+	makeMoleculeInStore,
+	Molecule,
+} from "atom.io/internal"
+import { type Json, stringifyJson } from "atom.io/json"
+
+export type MoleculeTransactors<K extends Json.Serializable> = Flat<
+	Omit<TransactorsWithRunAndEnv, `find`> & {
+		bond<T extends Transceiver<any>, J extends Json.Serializable>(
+			family: MutableAtomFamilyToken<T, J, K>,
+		): MutableAtomToken<T, J>
+		bond<T>(family: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>
+		bond<T>(family: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>
+		bond<T>(family: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>
+		bond<T>(family: WritableFamilyToken<T, K>): WritableToken<T>
+		bond<T>(family: ReadableFamilyToken<T, K>): ReadableToken<T>
+
+		join(joinToken: JoinToken<any, any, any, any>): void
+
+		spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(
+			family: MoleculeFamilyToken<Ctor>,
+			key: Key,
+			...params: MoleculeParams<Ctor>
+		): MoleculeToken<Ctor>
+	}
+>
+export type MoleculeConstructor = new (
+	transactors: MoleculeTransactors<any>,
+	key: Json.Serializable,
+	...params: any
+) => any
+
+type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[]
+
+export type MoleculeParams<M extends MoleculeConstructor> = Tail<
+	Tail<ConstructorParameters<M>>
+>
+
+export type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
+	key: string
+	dependsOn?: `all` | `any`
+	new: M
+}
+export type MoleculeFamilyToken<M extends MoleculeConstructor> = {
+	key: string
+	type: `molecule_family`
+	dependsOn: `all` | `any`
+	__M?: M
+}
+export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
+	MoleculeFamilyToken<M> & {
+		subject: Subject<MoleculeCreation<M> | MoleculeDisposal>
+		dependsOn: `all` | `any`
+		new: M
+	}
+>
+export type MoleculeToken<M extends MoleculeConstructor> = {
+	key: MK<M>
+	type: `molecule`
+	family?: MoleculeFamilyToken<M>
+	__M?: M
+}
+
+export function moleculeFamily<M extends MoleculeConstructor>(
+	options: MoleculeFamilyOptions<M>,
+): MoleculeFamilyToken<M> {
+	return createMoleculeFamily(options, IMPLICIT.STORE)
+}
+
+export function makeMolecule<M extends MoleculeConstructor>(
+	context: MoleculeToken<any> | MoleculeToken<any>[],
+	family: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+	...params: MoleculeParams<M>
+): MoleculeToken<M> {
+	return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params)
+}
+
+export function useMoleculeFromStore<M extends MoleculeConstructor>(
+	token: MoleculeToken<M>,
+	store: Store,
+): InstanceType<M> | undefined {
+	const molecule = store.molecules.get(stringifyJson(token.key))
+	return molecule?.instance
+}
+export function useMolecule<M extends MoleculeConstructor>(
+	token: MoleculeToken<M>,
+): InstanceType<M> | undefined {
+	return useMoleculeFromStore(token, IMPLICIT.STORE)
+}
+
+export type MoleculeType<T extends MoleculeFamilyToken<any>> =
+	T extends MoleculeFamilyToken<infer M>
+		? M
+		: T extends MoleculeToken<infer M>
+			? M
+			: never
+export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
+export type MK<M extends MoleculeConstructor> = MoleculeKey<M>
+
+export function makeRootMolecule(
+	key: string,
+	store: Store = IMPLICIT.STORE,
+): MoleculeToken<ObjectConstructor> {
+	const molecule = new Molecule(undefined, key)
+	store.molecules.set(stringifyJson(key), molecule)
+	return {
+		key,
+		type: `molecule`,
+	} as const
+}

package/src/timeline.ts

@@ -1,4 +1,4 @@
-import type { MoleculeFamilyToken } from "atom.io/immortal"
+import type { MoleculeFamilyToken } from "atom.io"
 import type {
 	Timeline,
 	TimelineAtomUpdate,
@@ -31,7 +31,7 @@ export type TimelineToken<M> = {
 
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 	key: string
-	scope: (ManagedAtom | MoleculeFamilyToken<any, any, any>)[]
+	scope: (ManagedAtom | MoleculeFamilyToken<any>)[]
 	shouldCapture?: (
 		update: TimelineUpdate<ManagedAtom>,
 		timeline: Timeline<TimelineManageable>,
@@ -41,7 +41,7 @@ export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 	| TimelineAtomUpdate<ManagedAtom>
 	| TimelineMoleculeCreation<any>
-	| TimelineMoleculeDisposal<any>
+	| TimelineMoleculeDisposal
 	| TimelineSelectorUpdate<ManagedAtom>
 	| TimelineStateCreation<AtomOnly<ManagedAtom>>
 	| TimelineStateDisposal<AtomOnly<ManagedAtom>>

package/src/transaction.ts

@@ -1,10 +1,12 @@
-import type { findState } from "atom.io/ephemeral"
 import type {
 	makeMolecule,
+	MoleculeConstructor,
 	MoleculeFamilyToken,
+	MoleculeParams,
 	MoleculeToken,
-	seekState,
-} from "atom.io/immortal"
+} from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 import type { EnvironmentData, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
@@ -42,25 +44,25 @@ export type StateDisposal<Token extends ReadableToken<any>> = {
 	value?: TokenType<Token>
 }
 
-export type MoleculeCreation<Key extends Json.Serializable> = {
+export type MoleculeCreation<M extends MoleculeConstructor> = {
 	type: `molecule_creation`
-	token: MoleculeToken<Key, any, any>
-	family: MoleculeFamilyToken<Key, any, any>
-	context: MoleculeToken<any, any, any>[]
-	params: any[]
+	token: MoleculeToken<M>
+	family: MoleculeFamilyToken<M>
+	context: MoleculeToken<any>[]
+	params: MoleculeParams<M>
 }
-export type MoleculeDisposal<Key extends Json.Serializable> = {
+export type MoleculeDisposal = {
 	type: `molecule_disposal`
-	token: MoleculeToken<Key, any, any>
-	family: MoleculeFamilyToken<any, any, any>
-	context: MoleculeToken<any, any, any>[]
+	token: MoleculeToken<any>
+	family: MoleculeFamilyToken<any>
+	context: MoleculeToken<any>[]
 	familyKeys: string[]
 }
 
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
 	| MoleculeCreation<any>
-	| MoleculeDisposal<any>
+	| MoleculeDisposal
 	| StateCreation<ReadableToken<unknown>>
 	| StateDisposal<ReadableToken<unknown>>
 	| TransactionUpdate<Func>

package/dist/chunk-6MLFYN32.js

@@ -1,18 +0,0 @@
-// ../anvl/src/primitive/index.ts
-var isString = (input) => {
-  return typeof input === `string`;
-};
-var isNumber = (input) => {
-  return typeof input === `number`;
-};
-var isBoolean = (input) => {
-  return typeof input === `boolean`;
-};
-var isNull = (input) => {
-  return input === null;
-};
-var isPrimitive = (input) => {
-  return isString(input) || isNumber(input) || isBoolean(input) || isNull(input);
-};
-
-export { isBoolean, isNull, isNumber, isPrimitive, isString };