atom.io 0.6.6 → 0.6.8

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

@@ -1,24 +1,21 @@
-import { Hamt } from 'hamt_plus';
 import { Refinement } from 'fp-ts/Refinement';
 import { AtomToken as AtomToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, SelectorToken as SelectorToken$1 } from 'atom.io';
-import { FC } from 'react';
 
 type PlainObject = Record<keyof any, unknown>;
 
 type ƒn = (...parameters: any[]) => any;
 
-type JsonInterface<T, J extends Json = Json> = {
+type JsonInterface<T, J extends Serializable = Serializable> = {
     toJson: (t: T) => J;
     fromJson: (json: J) => T;
 };
 
-type Primitive = boolean | number | string | null;
-type Serializable = Primitive | Readonly<{
+type primitive = boolean | number | string | null;
+
+type Serializable = primitive | Readonly<{
     [key: string]: Serializable;
 }> | ReadonlyArray<Serializable>;
-type JsonObj<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type JsonArr<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-type Json = JsonArr | JsonObj | Primitive;
+type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
 
 type Identified = {
     id: string;
@@ -26,23 +23,23 @@ type Identified = {
 
 declare const RELATION_TYPES: readonly ["1:1", "1:n", "n:n"];
 type RelationType = typeof RELATION_TYPES[number];
-type RelationData<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
-    contents: JsonObj<string, CONTENT>;
-    relations: JsonObj<string, string[]>;
+type RelationData<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
+    contents: Object$1<string, CONTENT>;
+    relations: Object$1<string, string[]>;
     relationType: RelationType;
     a: A;
     b: B;
 };
-type IsRelationDataOptions<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> = {
+type IsRelationDataOptions<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> = {
     from?: A;
     to?: B;
-    isContent?: (json: Json) => json is CONTENT;
+    isContent?: (json: Serializable) => json is CONTENT;
 };
 
 type NullSafeUnion<Base, Extension> = Extension extends null ? Base : Base & Extension;
-type NullSafeRest<MaybeArg> = MaybeArg extends null ? [] | [undefined] : [MaybeArg];
+type NullSafeRest<MaybeArg, IfArg = MaybeArg> = MaybeArg extends null ? [] | [undefined] : [IfArg];
 
-declare class Join<CONTENT extends JsonObj | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
+declare class Join<CONTENT extends Object$1 | null = null, A extends string = `from`, B extends string = `to`> implements RelationData<CONTENT, A, B> {
     readonly relationType: `1:1` | `1:n` | `n:n`;
     readonly a: A;
     readonly b: B;
@@ -50,7 +47,7 @@ declare class Join<CONTENT extends JsonObj | null = null, A extends string = `fr
     readonly contents: Record<string, CONTENT>;
     constructor(json?: Partial<RelationData<CONTENT, A, B>>);
     toJSON(): RelationData<CONTENT, A, B>;
-    static fromJSON<CONTENT extends JsonObj | null, A extends string, B extends string>(json: Json, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
+    static fromJSON<CONTENT extends Object$1 | null, A extends string, B extends string>(json: Serializable, options?: IsRelationDataOptions<CONTENT, A, B>): Join<CONTENT, A, B>;
     from<AA extends string>(newA: AA): Join<CONTENT, AA, B>;
     to<BB extends string>(newB: BB): Join<CONTENT, A, BB>;
     makeJsonInterface: (...params: CONTENT extends null ? [
@@ -139,18 +136,18 @@ type FamilyMetadata = {
 
 type StoreCore = Pick<Store, `atoms` | `atomsThatAreDefault` | `operation` | `readonlySelectors` | `selectorAtoms` | `selectorGraph` | `selectors` | `timelineAtoms` | `timelines` | `transactions` | `valueMap`>;
 interface Store {
-    atoms: Hamt<Atom<any>, string>;
+    atoms: Map<string, Atom<any>>;
     atomsThatAreDefault: Set<string>;
-    readonlySelectors: Hamt<ReadonlySelector<any>, string>;
+    readonlySelectors: Map<string, ReadonlySelector<any>>;
     selectorAtoms: Join<null, `selectorKey`, `atomKey`>;
     selectorGraph: Join<{
         source: string;
     }>;
-    selectors: Hamt<Selector<any>, string>;
+    selectors: Map<string, Selector<any>>;
     timelineAtoms: Join<null, `timelineKey`, `atomKey`>;
-    timelines: Hamt<Timeline, string>;
-    transactions: Hamt<Transaction<any>, string>;
-    valueMap: Hamt<any, string>;
+    timelines: Map<string, Timeline>;
+    transactions: Map<string, Transaction<any>>;
+    valueMap: Map<string, any>;
     subject: {
         atomCreation: Subject<AtomToken<unknown>>;
         selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
@@ -183,7 +180,7 @@ type OperationProgress = {
 } | {
     open: true;
     done: Set<string>;
-    prev: Hamt<any, string>;
+    prev: Map<string, any>;
     time: number;
     token: StateToken<any>;
 };
@@ -241,7 +238,7 @@ type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 type Timeline = {
     key: string;
     at: number;
-    timeTraveling: boolean;
+    timeTraveling: `into_future` | `into_past` | null;
     history: TimelineUpdate[];
     selectorTime: number | null;
     transactionKey: string | null;
@@ -318,7 +315,7 @@ declare class Differ<Leaf extends Record<string, any>, Tree extends Record<strin
     diff(a: unknown, b: unknown): Delta;
 }
 
-declare const AtomIODevtools: FC;
+declare const AtomIODevtools: () => JSX.Element;
 
 declare const atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
 declare const selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;