atom.io 0.18.3 → 0.19.1

package/react-devtools/src/AtomIODevtools.tsx

@@ -53,7 +53,7 @@ export const AtomIODevtools = (): JSX.Element => {
 								borderColor: `#0000`,
 								maxHeight: 28,
 								maxWidth: 33,
-						  }
+							}
 				}
 			>
 				{devtoolsAreOpen ? (
@@ -65,6 +65,7 @@ export const AtomIODevtools = (): JSX.Element => {
 									<button
 										key={viewOption}
 										type="button"
+										data-testid={`view-${viewOption}`}
 										className={viewOption === devtoolsView ? `active` : ``}
 										onClick={() => setDevtoolsView(viewOption)}
 										disabled={viewOption === devtoolsView}

package/react-devtools/src/Button.tsx

@@ -5,10 +5,12 @@ export const OpenClose: FC<{
 	isOpen: boolean
 	setIsOpen: (next: Modify<boolean> | boolean) => void
 	disabled?: boolean
-}> = ({ isOpen, setIsOpen, disabled }) => {
+	testid: string
+}> = ({ isOpen, setIsOpen, disabled, testid }) => {
 	return (
 		<button
 			type="button"
+			data-testid={testid}
 			className={`carat ${isOpen ? `open` : `closed`}`}
 			onClick={() => setIsOpen((isOpen) => !isOpen)}
 			disabled={disabled}

package/react-devtools/src/StateEditor.tsx

@@ -3,9 +3,7 @@ import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 
 import { fallback } from "~/packages/anvl/src/function"
-import { Join } from "~/packages/anvl/src/join"
 import { isJson } from "~/packages/anvl/src/refinement"
-import { RelationEditor } from "~/packages/hamr/react-data-designer/src"
 import { ElasticInput } from "~/packages/hamr/react-elastic-input/src"
 import { JsonEditor } from "~/packages/hamr/react-json-editor/src"
 
@@ -16,19 +14,20 @@ export const StateEditor: FC<{
 	const data = useO(token)
 	return isJson(data) ? (
 		<JsonEditor data={data} set={set} schema={true} />
-	) : data instanceof Join ? (
-		<RelationEditor data={data} set={set} />
 	) : (
 		<div className="json_editor">
 			<ElasticInput
 				value={
-					data instanceof Set
-						? `Set { ${JSON.stringify([...data]).slice(1, -1)} }`
-						: data instanceof Map
-						  ? `Map ` + JSON.stringify([...data])
-						  : Object.getPrototypeOf(data).constructor.name +
-							  ` ` +
-							  fallback(() => JSON.stringify(data), `?`)
+					data !== null &&
+					typeof data === `object` &&
+					`toJson` in data &&
+					typeof data.toJson === `function`
+						? JSON.stringify(data.toJson())
+						: data instanceof Set
+							? `Set { ${JSON.stringify([...data]).slice(1, -1)} }`
+							: Object.getPrototypeOf(data).constructor.name +
+								` ` +
+								fallback(() => JSON.stringify(data), `?`)
 				}
 				disabled={true}
 			/>
@@ -53,11 +52,9 @@ export const ReadonlySelectorViewer: FC<{
 				value={
 					data instanceof Set
 						? `Set ` + JSON.stringify([...data])
-						: data instanceof Map
-						  ? `Map ` + JSON.stringify([...data])
-						  : Object.getPrototypeOf(data).constructor.name +
-							  ` ` +
-							  JSON.stringify(data)
+						: Object.getPrototypeOf(data).constructor.name +
+							` ` +
+							JSON.stringify(data)
 				}
 				disabled={true}
 			/>

package/react-devtools/src/StateIndex.tsx

@@ -1,9 +1,10 @@
 import type {
+	AtomToken,
 	ReadonlySelectorToken,
 	RegularAtomToken,
 	WritableSelectorToken,
 } from "atom.io"
-import { getState, selectorFamily } from "atom.io"
+import { findState, getState, selectorFamily } from "atom.io"
 import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
@@ -34,8 +35,8 @@ const findStateTypeState = selectorFamily<string, { key: string }>({
 
 export const StateIndexLeafNode: FC<{
 	node:
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
@@ -53,6 +54,7 @@ export const StateIndexLeafNode: FC<{
 			<header>
 				<button.OpenClose
 					isOpen={isOpen && !isPrimitive}
+					testid={`open-close-state-${node.key}`}
 					setIsOpen={setIsOpen}
 					disabled={isPrimitive}
 				/>
@@ -63,7 +65,7 @@ export const StateIndexLeafNode: FC<{
 					<h2>{node.family?.subKey ?? node.key}</h2>
 					<span className="type detail">({stateType})</span>
 				</label>
-				{isPrimitive ? <StoreEditor token={node} /> : null}
+				<StoreEditor token={node} />
 			</header>
 			{isOpen && !isPrimitive ? (
 				<main>
@@ -75,8 +77,8 @@ export const StateIndexLeafNode: FC<{
 }
 export const StateIndexTreeNode: FC<{
 	node: FamilyNode<
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	>
 	isOpenState: RegularAtomToken<boolean>
@@ -84,13 +86,17 @@ export const StateIndexTreeNode: FC<{
 	const setIsOpen = useI(isOpenState)
 	const isOpen = useO(isOpenState)
 	for (const [key, childNode] of recordToEntries(node.familyMembers)) {
-		findViewIsOpenState(key)
-		findStateTypeState(childNode)
+		findState(findViewIsOpenState, key)
+		findState(findStateTypeState, childNode)
 	}
 	return (
 		<>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-state-family-${node.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{node.key}</h2>
 					<span className="type detail"> (family)</span>
@@ -101,10 +107,10 @@ export const StateIndexTreeNode: FC<{
 						<StateIndexNode
 							key={key}
 							node={childNode}
-							isOpenState={findViewIsOpenState(childNode.key)}
-							typeState={findStateTypeState(childNode)}
+							isOpenState={findState(findViewIsOpenState, childNode.key)}
+							typeState={findState(findStateTypeState, childNode)}
 						/>
-				  ))
+					))
 				: null}
 		</>
 	)
@@ -112,18 +118,15 @@ export const StateIndexTreeNode: FC<{
 
 export const StateIndexNode: FC<{
 	node: WritableTokenIndex<
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>
 	>[string]
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
 }> = ({ node, isOpenState, typeState }) => {
-	if (node.key.startsWith(`👁‍🗨`)) {
-		return null
-	}
 	return (
-		<section className="node state">
+		<section className="node state" data-testid={`state-${node.key}`}>
 			{`type` in node ? (
 				<StateIndexLeafNode
 					node={node}
@@ -140,15 +143,15 @@ export const StateIndexNode: FC<{
 export const StateIndex: FC<{
 	tokenIndex: ReadonlySelectorToken<
 		WritableTokenIndex<
+			| AtomToken<unknown>
 			| ReadonlySelectorToken<unknown>
-			| RegularAtomToken<unknown>
 			| WritableSelectorToken<unknown>
 		>
 	>
 }> = ({ tokenIndex }) => {
 	const tokenIds = useO(tokenIndex)
 	return (
-		<article className="index state_index">
+		<article className="index state_index" data-testid="state-index">
 			{Object.entries(tokenIds)
 				.filter(([key]) => !key.startsWith(`👁‍🗨`))
 				.sort()
@@ -157,8 +160,8 @@ export const StateIndex: FC<{
 						<StateIndexNode
 							key={key}
 							node={node}
-							isOpenState={findViewIsOpenState(node.key)}
-							typeState={findStateTypeState(node)}
+							isOpenState={findState(findViewIsOpenState, node.key)}
+							typeState={findState(findStateTypeState, node)}
 						/>
 					)
 				})}

package/react-devtools/src/TimelineIndex.tsx

@@ -26,9 +26,13 @@ export const TimelineLog: FC<{
 	const setIsOpen = useI(isOpenState)
 
 	return (
-		<section className="node timeline_log">
+		<section className="node timeline_log" data-testid={`timeline-${token.key}`}>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-timeline-${token.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{token.key}</h2>
 					<span className="detail length">
@@ -58,7 +62,10 @@ export const TimelineLog: FC<{
 					{timeline.history.map((update, index) => (
 						<Fragment key={update.key + index + timeline.at}>
 							{index === timeline.at ? <YouAreHere /> : null}
-							<article.TimelineUpdate timelineUpdate={update} />
+							<article.TimelineUpdate
+								timelineUpdate={update}
+								serialNumber={index}
+							/>
 							{index === timeline.history.length - 1 &&
 							timeline.at === timeline.history.length ? (
 								<YouAreHere />
@@ -74,7 +81,7 @@ export const TimelineLog: FC<{
 export const TimelineIndex: FC = () => {
 	const tokenIds = useO(timelineIndex)
 	return (
-		<article className="index timeline_index">
+		<article className="index timeline_index" data-testid="timeline-index">
 			{tokenIds
 				.filter((token) => !token.key.startsWith(`👁‍🗨`))
 				.map((token) => {

package/react-devtools/src/TransactionIndex.tsx

@@ -27,9 +27,16 @@ export const TransactionLog: FC<{
 	const setIsOpen = useI(isOpenState)
 
 	return (
-		<section className="node transaction_log">
+		<section
+			className="node transaction_log"
+			data-testid={`transaction-${token.key}`}
+		>
 			<header>
-				<button.OpenClose isOpen={isOpen} setIsOpen={setIsOpen} />
+				<button.OpenClose
+					isOpen={isOpen}
+					testid={`open-close-transaction-${token.key}`}
+					setIsOpen={setIsOpen}
+				/>
 				<label>
 					<h2>{token.key}</h2>
 					<span className="detail length">({log.length})</span>
@@ -53,7 +60,7 @@ export const TransactionLog: FC<{
 export const TransactionIndex: FC = () => {
 	const tokenIds = useO(transactionIndex)
 	return (
-		<article className="index transaction_index">
+		<article className="index transaction_index" data-testid="transaction-index">
 			{tokenIds
 				.filter((token) => !token.key.startsWith(`👁‍🗨`))
 				.map((token) => {

package/react-devtools/src/Updates.tsx

@@ -36,7 +36,10 @@ const TransactionUpdateFC: React.FC<{
 	transactionUpdate: TransactionUpdate<ƒn>
 }> = ({ serialNumber, transactionUpdate }) => {
 	return (
-		<article className="node transaction_update">
+		<article
+			className="node transaction_update"
+			data-testid={`transaction-update-${transactionUpdate.key}-${serialNumber}`}
+		>
 			<header>
 				<h4>{serialNumber}</h4>
 			</header>
@@ -104,9 +107,13 @@ const TransactionUpdateFC: React.FC<{
 
 export const TimelineUpdateFC: React.FC<{
 	timelineUpdate: TimelineUpdate<any>
-}> = ({ timelineUpdate }) => {
+	serialNumber: number
+}> = ({ timelineUpdate, serialNumber }) => {
 	return (
-		<article className="node timeline_update">
+		<article
+			className="node timeline_update"
+			data-testid={`timeline-update-${timelineUpdate.key}-${serialNumber}`}
+		>
 			<header>
 				<h4>
 					{timelineUpdate.timestamp}: {timelineUpdate.type} ({timelineUpdate.key}

package/realtime/dist/index.cjs

@@ -103,8 +103,10 @@ var usersInRooms = data.join(
 );
 var usersInMyRoomView = atom_io.selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = data.getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 

package/realtime/dist/index.d.ts

@@ -2,7 +2,6 @@ import * as atom_io from 'atom.io';
 import { AtomFamilyToken, ReadableFamilyToken, ReadableToken, AtomToken, TransactionToken, MutableAtomToken } from 'atom.io';
 import { Json } from 'atom.io/json';
 import * as atom_io_data from 'atom.io/data';
-import * as atom_io_internal from 'atom.io/internal';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare class InvariantMap<K, V> extends Map<K, V> {
@@ -40,107 +39,13 @@ type ContinuityOptions = {
 };
 declare function continuity(options: ContinuityOptions): ContinuityToken;
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
-    readonly relations: [string, string[]][];
-    readonly contents: [string, Content][];
-}
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: Cardinality;
-}
-type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
-};
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: Cardinality;
-    readonly relations: Map<string, Set<string>>;
-    readonly contents: Map<string, Content>;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
-    set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
 declare const usersInThisRoomIndex: MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const roomIndex: MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 type UserInRoomMeta = {
     enteredAtEpoch: number;
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: {
-    readonly relations: Junction<"room", "user", UserInRoomMeta>;
-    readonly states: {
-        readonly roomEntryOfUser: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta] | null, string>;
-    } & {
-        readonly userEntriesOfRoom: atom_io.ReadonlySelectorFamily<[string, UserInRoomMeta][], string>;
-    } & {
-        readonly roomKeyOfUser: atom_io.ReadonlySelectorFamily<string | null, string>;
-    } & {
-        readonly userKeysOfRoom: atom_io.ReadonlySelectorFamily<string[], string>;
-    };
-    readonly in: (store: atom_io_internal.Store) => atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>;
-    readonly transact: (transactors: Readonly<{
-        get: <S>(state: atom_io.ReadonlySelectorToken<S> | atom_io.WritableToken<S>) => S;
-        set: <S_1, New extends S_1>(state: atom_io.WritableToken<S_1>, newValue: New | ((oldValue: S_1) => New)) => void;
-        find: typeof atom_io.findState;
-    }>, run: (join: atom_io_data.Join<"room", "user", "1:n", UserInRoomMeta>) => void) => void;
-    readonly core: {
-        readonly findRelatedKeysState: atom_io.MutableAtomFamily<SetRTX<string>, SetRTXJson<string>, string>;
-    };
-};
+declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
 declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyTokenWithCall<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
 
 export { type ContinuityOptions, type ContinuityToken, DEFAULT_USER_IN_ROOM_META, InvariantMap, type PerspectiveToken, SyncGroup, type UserInRoomMeta, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/realtime/dist/index.js

@@ -1,7 +1,7 @@
 import '../../dist/chunk-U2IICNHQ.js';
 import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity, getUpdateToken } from 'atom.io/internal';
 import { atom, selectorFamily } from 'atom.io';
-import { join } from 'atom.io/data';
+import { join, getInternalRelations } from 'atom.io/data';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 var InvariantMap = class extends Map {
@@ -101,8 +101,10 @@ var usersInRooms = join(
 );
 var usersInMyRoomView = selectorFamily({
   key: `usersInMyRoomView`,
-  get: (username) => ({ find }) => {
-    return [find(usersInRooms.core.findRelatedKeysState, username)];
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
   }
 });
 

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

@@ -1,6 +1,6 @@
 import type { MutableAtomToken } from "atom.io"
 import { atom, selectorFamily } from "atom.io"
-import { join } from "atom.io/data"
+import { getInternalRelations, join } from "atom.io/data"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -41,8 +41,10 @@ export const usersInMyRoomView = selectorFamily<
 >({
 	key: `usersInMyRoomView`,
 	get:
-		(username) =>
+		(myUsername) =>
 		({ find }) => {
-			return [find(usersInRooms.core.findRelatedKeysState, username)]
+			const usersInRoomsAtoms = getInternalRelations(usersInRooms)
+			const myRoomIndex = find(usersInRoomsAtoms, myUsername)
+			return [myRoomIndex]
 		},
 })

package/realtime-react/dist/index.cjs

@@ -47,7 +47,7 @@ var RealtimeProvider = ({ children, socket }) => {
   return /* @__PURE__ */ jsxRuntime.jsx(RealtimeContext.Provider, { value: { socket, services }, children });
 };
 var { NODE_ENV } = process.env;
-var IN_DEV = NODE_ENV === `development` || NODE_ENV === `test`;
+var IN_DEV = NODE_ENV === `development`;
 function noop() {
 }
 function useSingleEffect(effect, deps) {

package/realtime-react/dist/index.js

@@ -25,7 +25,7 @@ var RealtimeProvider = ({ children, socket }) => {
   return /* @__PURE__ */ jsx(RealtimeContext.Provider, { value: { socket, services }, children });
 };
 var { NODE_ENV } = process.env;
-var IN_DEV = NODE_ENV === `development` || NODE_ENV === `test`;
+var IN_DEV = NODE_ENV === `development`;
 function noop() {
 }
 function useSingleEffect(effect, deps) {

package/realtime-react/src/use-single-effect.ts

@@ -1,7 +1,7 @@
 import * as React from "react"
 
 const { NODE_ENV } = process.env
-const IN_DEV = NODE_ENV === `development` || NODE_ENV === `test`
+const IN_DEV = NODE_ENV === `development`
 
 function noop() {}