atom.io 0.31.0 → 0.32.0

package/react/dist/index.js

@@ -1,83 +1,3 @@
+export { StoreContext, StoreProvider, useI, useJSON, useO, useTL } from '../../dist/chunk-5F2V7S3B.js';
+import '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { IMPLICIT, setIntoStore, subscribeToState, getFromStore, findInStore, getJsonToken, withdraw, subscribeToTimeline } from 'atom.io/internal';
-import * as React5 from 'react';
-import { jsx } from 'react/jsx-runtime';
-import { undo, redo } from 'atom.io';
-
-var StoreContext = React5.createContext(IMPLICIT.STORE);
-var StoreProvider = ({ children, store = IMPLICIT.STORE }) => /* @__PURE__ */ jsx(StoreContext.Provider, { value: store, children });
-function parseStateOverloads(store, ...rest) {
-  let token;
-  if (rest.length === 2) {
-    const family = rest[0];
-    const key = rest[1];
-    token = findInStore(store, family, key);
-  } else {
-    token = rest[0];
-  }
-  return token;
-}
-
-// react/src/use-i.ts
-function useI(...params) {
-  const store = React5.useContext(StoreContext);
-  const token = parseStateOverloads(store, ...params);
-  const setter = React5.useRef(null);
-  if (setter.current === null) {
-    setter.current = (next) => {
-      setIntoStore(store, token, next);
-    };
-  }
-  return setter.current;
-}
-function useO(...params) {
-  const store = React5.useContext(StoreContext);
-  const token = parseStateOverloads(store, ...params);
-  const id = React5.useId();
-  return React5.useSyncExternalStore(
-    (dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
-    () => getFromStore(store, token),
-    () => getFromStore(store, token)
-  );
-}
-
-// react/src/use-json.ts
-function useJSON(token, key) {
-  const store = React5.useContext(StoreContext);
-  const stateToken = token.type === `mutable_atom_family` ? findInStore(store, token, key) : token;
-  const jsonToken = getJsonToken(store, stateToken);
-  return useO(jsonToken);
-}
-function useTL(token) {
-  const store = React5.useContext(StoreContext);
-  const id = React5.useId();
-  const timeline = withdraw(token, store);
-  const tokenRef = React5.useRef(token);
-  const rebuildMeta = () => {
-    return {
-      at: timeline.at,
-      length: timeline.history.length,
-      undo: () => {
-        undo(token);
-      },
-      redo: () => {
-        redo(token);
-      }
-    };
-  };
-  const meta = React5.useRef(rebuildMeta());
-  const retrieve = () => {
-    if (meta.current.at !== timeline?.at || meta.current.length !== timeline?.history.length || tokenRef.current !== token) {
-      tokenRef.current = token;
-      meta.current = rebuildMeta();
-    }
-    return meta.current;
-  };
-  return React5.useSyncExternalStore(
-    (dispatch) => subscribeToTimeline(token, dispatch, `use-tl:${id}`, store),
-    retrieve,
-    retrieve
-  );
-}
-
-export { StoreContext, StoreProvider, useI, useJSON, useO, useTL };

package/react/src/use-o.ts

@@ -20,7 +20,7 @@ export function useO<T, K extends Canonical>(
 	const token = parseStateOverloads(store, ...params)
 	const id = React.useId()
 	return React.useSyncExternalStore<T>(
-		(dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
+		(dispatch) => subscribeToState(store, token, `use-o:${id}`, dispatch),
 		() => getFromStore(store, token),
 		() => getFromStore(store, token),
 	)

package/react/src/use-tl.ts

@@ -15,7 +15,7 @@ export type TimelineMeta = {
 export function useTL(token: TimelineToken<any>): TimelineMeta {
 	const store = React.useContext(StoreContext)
 	const id = React.useId()
-	const timeline = withdraw(token, store)
+	const timeline = withdraw(store, token)
 	const tokenRef = React.useRef(token)
 	const rebuildMeta = () => {
 		return {
@@ -42,7 +42,7 @@ export function useTL(token: TimelineToken<any>): TimelineMeta {
 		return meta.current
 	}
 	return React.useSyncExternalStore<TimelineMeta>(
-		(dispatch) => subscribeToTimeline(token, dispatch, `use-tl:${id}`, store),
+		(dispatch) => subscribeToTimeline(store, token, `use-tl:${id}`, dispatch),
 		retrieve,
 		retrieve,
 	)

package/react-devtools/dist/index.css

@@ -9,20 +9,22 @@ main[data-css=atom_io_devtools] {
     --bg-color: #ddd;
     --bg-tint1: #e3e3e3;
   }
-  box-sizing: border-box;
-  color: var(--fg-color);
-  background-color: var(--bg-color);
-  border: 2px solid var(--fg-color);
-  position: fixed;
-  right: 0;
-  bottom: 0;
-  height: 100%;
-  display: flex;
-  flex-flow: column;
-  max-height: 800px;
-  width: 100%;
-  max-width: 500px;
-  overflow-y: scroll;
+  & {
+    box-sizing: border-box;
+    color: var(--fg-color);
+    background-color: var(--bg-color);
+    border: 2px solid var(--fg-color);
+    position: fixed;
+    right: 0;
+    bottom: 0;
+    height: 100%;
+    display: flex;
+    flex-flow: column;
+    max-height: 800px;
+    width: 100%;
+    max-width: 500px;
+    overflow-y: scroll;
+  }
   * {
     font-size: 16px;
     font-family: theia, monospace;

package/react-devtools/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { DetailedHTMLProps, InputHTMLAttributes, ForwardRefExoticComponent, FC, ErrorInfo, ReactNode, Component, CSSProperties, ReactElement } from 'react';
-import { JsonTypes, Json } from 'atom.io/json';
 
 declare const AtomIODevtools: React.FC;
 
@@ -76,6 +75,32 @@ declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryS
     render(): ReactNode;
 }
 
+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 const JSON_TYPE_NAMES: readonly ["array", "boolean", "null", "number", "object", "string"];
+type JsonTypeName = (typeof JSON_TYPE_NAMES)[number];
+interface JsonTypes extends Record<JsonTypeName, Json.Serializable> {
+    array: Json.Array;
+    boolean: boolean;
+    null: null;
+    number: number;
+    object: Json.Object;
+    string: string;
+}
+
 type Dict<T> = Record<string, T>;
 type WrapperComponent<T extends Dict<unknown> = Dict<unknown>> = FC<T & {
     children: ReactNode;

package/react-devtools/dist/index.js

@@ -1,13 +1,11 @@
+import { persistSync } from '../../dist/chunk-4LWKCEW3.js';
+import { jsonRefinery, attachIntrospectionStates, primitiveRefinery, prettyJson, discoverType } from '../../dist/chunk-ECOMOMUN.js';
+import { StoreContext, useI, useO } from '../../dist/chunk-5F2V7S3B.js';
+import { IMPLICIT, createStandaloneAtom, createAtomFamily, isJson, findInStore, become, fromEntries, toEntries, undo, redo, JSON_DEFAULTS, getState, stringifyJson } from '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { StoreContext, useI, useO } from 'atom.io/react';
 import { motion, spring, LayoutGroup } from 'motion/react';
 import { forwardRef, useRef, useState, useImperativeHandle, useLayoutEffect, createContext, useId, Component, useContext, Fragment as Fragment$1 } from 'react';
-import { undo, redo, getState } from 'atom.io';
-import { IMPLICIT, createStandaloneAtom, createAtomFamily, findInStore, become } from 'atom.io/internal';
-import { jsonRefinery, attachIntrospectionStates, primitiveRefinery, prettyJson, discoverType } from 'atom.io/introspection';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { isJson, fromEntries, toEntries, JSON_DEFAULTS, stringifyJson } from 'atom.io/json';
-import { persistSync } from 'atom.io/web';
 
 var OpenClose = ({ isOpen, setIsOpen, disabled, testid }) => {
   return /* @__PURE__ */ jsx(
@@ -353,6 +351,8 @@ var JsonEditor_INTERNAL = ({
     }
   ) });
 };
+
+// react-devtools/src/json-editor/editors-by-type/utilities/array-elements.ts
 var makeElementSetters = (data, set) => data.map((value, index) => (newValue) => {
   set(() => {
     const newData = [...data];

package/react-devtools/src/devtools.scss

@@ -8,20 +8,22 @@ main[data-css="atom_io_devtools"] {
     --bg-color: #ddd;
     --bg-tint1: #e3e3e3;
   }
-  box-sizing: border-box;
-  color: var(--fg-color);
-  background-color: var(--bg-color);
-  border: 2px solid var(--fg-color);
-  position: fixed;
-  right: 0;
-  bottom: 0;
-  height: 100%;
-  display: flex;
-  flex-flow: column;
-  max-height: 800px;
-  width: 100%;
-  max-width: 500px;
-  overflow-y: scroll;
+  & {
+    box-sizing: border-box;
+    color: var(--fg-color);
+    background-color: var(--bg-color);
+    border: 2px solid var(--fg-color);
+    position: fixed;
+    right: 0;
+    bottom: 0;
+    height: 100%;
+    display: flex;
+    flex-flow: column;
+    max-height: 800px;
+    width: 100%;
+    max-width: 500px;
+    overflow-y: scroll;
+  }
   * {
     font-size: 16px;
     font-family: theia, monospace;

package/realtime/dist/index.d.ts

@@ -1,9 +1,203 @@
-import * as atom_io from 'atom.io';
-import { AtomFamilyToken, ReadableFamilyToken, ReadableToken, TokenType, AtomToken, TransactionToken, MutableAtomToken } from 'atom.io';
-import { Canonical } from 'atom.io/json';
-import { UserKey } from 'atom.io/realtime-server';
-import * as atom_io_data from 'atom.io/data';
-import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
+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>;
+}
+type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
+    __json?: J;
+};
+type Canonical = primitive | ReadonlyArray<Canonical>;
+
+type Func = (...parameters: any[]) => any;
+
+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;
+}
+
+type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
+type NumberedSetUpdate = `${number}=${SetUpdate}`;
+interface SetRTXJson<P extends primitive> extends Json.Object {
+    members: P[];
+    cache: (NumberedSetUpdate | null)[];
+    cacheLimit: number;
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+}
+declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
+    mode: TransceiverMode;
+    readonly subject: Subject<SetUpdate>;
+    cacheLimit: number;
+    cache: (NumberedSetUpdate | null)[];
+    cacheIdx: number;
+    cacheUpdateNumber: number;
+    constructor(values?: Iterable<P>, cacheLimit?: number);
+    toJSON(): SetRTXJson<P>;
+    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
+    add(value: P): this;
+    clear(): void;
+    delete(value: P): boolean;
+    readonly parent: SetRTX<P> | null;
+    child: SetRTX<P> | null;
+    transactionUpdates: SetUpdate[] | null;
+    transaction(run: (child: SetRTX<P>) => boolean): void;
+    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
+    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
+    emit(update: SetUpdate): void;
+    private doStep;
+    getUpdateNumber(update: NumberedSetUpdate): number;
+    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
+    undoStep(update: SetUpdate): void;
+    undo(update: NumberedSetUpdate): number | null;
+}
+
+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 RegularAtomFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `atom_family`;
+    __T?: T;
+    __K?: K;
+};
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
+    key: string;
+    type: `mutable_atom_family`;
+    __T?: T;
+    __J?: J;
+    __K?: K;
+};
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
+
+type TransactionToken<F extends Func> = {
+    key: string;
+    type: `transaction`;
+    __F?: F;
+};
+
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
+    key: string;
+    type: `readonly_selector_family`;
+    __T?: T;
+    __K?: K;
+};
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+
+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;
+};
+
+type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
+
+/** @public */
+type RegularAtomToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the atom's value. */
+    __T?: T;
+};
+/** @public */
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+    /** The unique identifier of the atom. */
+    key: string;
+    /** Discriminator. */
+    type: `mutable_atom`;
+    /** Present if the atom belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+    __J?: J;
+    /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+    __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+/** @public */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
+type WritableSelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
+    /** The unique identifier of the selector. */
+    key: string;
+    /** Discriminator. */
+    type: `readonly_selector`;
+    /** Present if the selector belongs to a family. */
+    family?: FamilyMetadata<K>;
+    /** Never present. This is a marker that preserves the type of the selector's value. */
+    __T?: T;
+};
+/** @public */
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+ * @public
+ * These states cannot be set.
+ */
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+ * @public
+ * States belonging to this family cannot be set.
+ */
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+ * @public
+ * Identifies a state's connection to its family.
+ */
+type FamilyMetadata<K extends Canonical = any> = {
+    /** The family's unique key. */
+    key: string;
+    /** The family member's unique identifier, in the form of a string. */
+    subKey: stringified<K>;
+};
+
+type UserKey = `user::${string}`;
 
 declare class InvariantMap<K, V> extends Map<K, V> {
     set(key: K, value: V): this;
@@ -46,7 +240,7 @@ type UserInRoomMeta = {
     enteredAtEpoch: number;
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: atom_io_data.JoinToken<"room", string, "user", string, "1:n", UserInRoomMeta>;
-declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyToken<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
+declare const usersInRooms: JoinToken<"room", string, "user", string, "1:n", UserInRoomMeta>;
+declare const usersInMyRoomView: ReadonlySelectorFamilyToken<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,108 +1,3 @@
+export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex } from '../../dist/chunk-NF7FJKJD.js';
+import '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity } from 'atom.io/internal';
-import { atom, selectorFamily } from 'atom.io';
-import { join, getInternalRelations } from 'atom.io/data';
-import { SetRTX } from 'atom.io/transceivers/set-rtx';
-
-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 {
-  constructor(key) {
-    this.key = key;
-  }
-  type = `continuity`;
-  globals = [];
-  actions = [];
-  perspectives = [];
-  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`:
-        {
-          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(key, action.key, IMPLICIT.STORE);
-  }
-  setEpochNumberOfContinuity(key, -1, IMPLICIT.STORE);
-  return token;
-}
-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 };

package/realtime/src/realtime-continuity.ts

@@ -122,9 +122,9 @@ export function continuity(options: ContinuityOptions): ContinuityToken {
 	const token = SyncGroup.create(key, config)
 	const { actions } = token
 	for (const action of actions) {
-		assignTransactionToContinuity(key, action.key, IMPLICIT.STORE)
+		assignTransactionToContinuity(IMPLICIT.STORE, key, action.key)
 	}
-	setEpochNumberOfContinuity(key, -1, IMPLICIT.STORE)
+	setEpochNumberOfContinuity(IMPLICIT.STORE, key, -1)
 	return token
 }
 

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

@@ -1,6 +1,5 @@
 import type { MutableAtomToken } from "atom.io"
-import { atom, selectorFamily } from "atom.io"
-import { getInternalRelations, join } from "atom.io/data"
+import { atom, getInternalRelations, join, selectorFamily } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"