atom.io 0.14.0 → 0.14.2

package/react-devtools/dist/index.css

@@ -1,4 +1,4 @@
-/* ../../hamr/src/react-data-designer/RelationEditor.module.scss */
+/* ../hamr/src/react-data-designer/RelationEditor.module.scss */
 .class {
   display: flex;
   flex-flow: row wrap;
@@ -16,7 +16,7 @@
   }
 }
 
-/* src/devtools.scss */
+/* react-devtools/src/devtools.scss */
 main.atom_io_devtools {
   --fg-color: #eee;
   --bg-color: #111;

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

@@ -1,7 +1,3 @@
-import * as atom_io from 'atom.io';
-import { FamilyMetadata, ƒn, TransactionUpdate, MutableAtomToken, AtomToken, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, AtomIOLogger, Logger } from 'atom.io';
-import { Json } from 'atom.io/json';
-
 type ClassSignature = abstract new (...args: any) => any;
 
 type RefinementStrategy = ClassSignature | Refinement$1<unknown, any>;
@@ -24,6 +20,142 @@ interface Refinement$1<A, B extends A> {
 
 type PlainObject = Record<keyof any, unknown>;
 
+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 AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Subject<AtomToken<T>>;
+    mutable?: boolean;
+};
+
+declare const LoggerIconDictionary: {
+    readonly "\u231B": "Timeline event fully captured";
+    readonly "\u23E9": "Timeline redo";
+    readonly "\u23EA": "Timeline undo";
+    readonly "\u23ED\uFE0F": "Transaction redo";
+    readonly "\u23EE\uFE0F": "Transaction undo";
+    readonly "\u23F3": "Timeline event partially captured";
+    readonly "\u23F9\uFE0F": "Time-travel complete";
+    readonly "\uD83D\uDC81": "Notice";
+    readonly "\uD83D\uDD04": "Realtime transaction synchronized";
+    readonly "\u2705": "Realtime transaction success";
+    readonly "\u2728": "Computation complete";
+    readonly "\u274C": "Conflict prevents attempted action";
+    readonly "\u2B55": "Operation start";
+    readonly "\uD83D\uDC1E": "Possible bug in AtomIO";
+    readonly "\uD83D\uDC40": "Subscription added";
+    readonly "\uD83D\uDC6A": "Family member added";
+    readonly "\uD83D\uDCC1": "Stow update";
+    readonly "\uD83D\uDCC3": "Copy mutable";
+    readonly "\uD83D\uDCD6": "Read state";
+    readonly "\uD83D\uDCDD": "Write state";
+    readonly "\uD83D\uDCE2": "Notify subscribers";
+    readonly "\uD83D\uDD0C": "Register dependency";
+    readonly "\uD83D\uDD0D": "Discover root";
+    readonly "\uD83D\uDD25": "Delete state";
+    readonly "\uD83D\uDD27": "Create mutable atom";
+    readonly "\uD83D\uDD28": "Create immutable atom";
+    readonly "\uD83D\uDD34": "Operation complete";
+    readonly "\uD83D\uDDD1": "Evict cached value";
+    readonly "\uD83D\uDCA5": "Caught";
+    readonly "\uD83D\uDE48": "Subscription canceled";
+    readonly "\uD83D\uDEC4": "Apply transaction";
+    readonly "\uD83D\uDEE0\uFE0F": "Install atom into store";
+    readonly "\uD83D\uDEEB": "Begin transaction";
+    readonly "\uD83D\uDEEC": "Complete transaction";
+    readonly "\uD83E\uDDEE": "Computing selector";
+    readonly "\uD83E\uDDF9": "Prepare to evict";
+    readonly "\uD83E\uDE82": "Abort transaction";
+};
+type LoggerIcon = keyof typeof LoggerIconDictionary;
+declare const LOG_LEVELS: readonly ["info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn = (icon: LoggerIcon, tokenType: `atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`, tokenKey: string, message: string, ...rest: unknown[]) => void;
+type LogFilter = (...params: Parameters<LogFn>) => boolean;
+type Logger = Record<LogLevel, LogFn>;
+declare class AtomIOLogger implements Logger {
+    logLevel: `error` | `info` | `warn` | null;
+    private readonly filter?;
+    private readonly logger;
+    constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter | undefined, logger?: Logger);
+    error: LogFn;
+    info: LogFn;
+    warn: LogFn;
+}
+
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+    __brand?: _;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    updates: (KeyedStateUpdate<unknown> | TransactionUpdate<ƒn>)[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+
+type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
+    key: string;
+    type: `selector_family`;
+    subject: Subject<SelectorToken<T>>;
+};
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
+    key: string;
+    type: `readonly_selector_family`;
+    subject: Subject<ReadonlySelectorToken<T>>;
+};
+
+type StateUpdate<T> = {
+    newValue: T;
+    oldValue: T;
+};
+type KeyedStateUpdate<T> = StateUpdate<T> & {
+    key: string;
+    family?: FamilyMetadata;
+};
+
+type TimelineToken = {
+    key: string;
+    type: `timeline`;
+};
+type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
+
+type ƒn = (...parameters: any[]) => any;
+type AtomToken<_> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+interface MutableAtomToken<T extends Transceiver<any>, J extends Serializable> extends AtomToken<T> {
+    __asJSON?: J;
+    __update?: T extends Transceiver<infer Update> ? Update : never;
+}
+type SelectorToken<_> = {
+    key: string;
+    type: `selector`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+type StateToken<T> = AtomToken<T> | SelectorToken<T>;
+type ReadonlySelectorToken<_> = {
+    key: string;
+    type: `readonly_selector`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+type FamilyMetadata = {
+    key: string;
+    subKey: string;
+};
+
 declare class Subject<T> {
     Subscriber: (value: T) => void;
     subscribers: Map<string, this[`Subscriber`]>;
@@ -75,13 +207,6 @@ type TransactionMeta<ƒ extends ƒn> = {
     update: TransactionUpdate<ƒ>;
 };
 
-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`;
 
@@ -154,7 +279,7 @@ interface Lineage {
     child: typeof this | null;
 }
 
-interface Transceiver<Signal extends Json.Serializable> {
+interface Transceiver<Signal extends Serializable> {
     do: (update: Signal) => void;
     undo: (update: Signal) => void;
     subscribe: (key: string, fn: (update: Signal) => void) => () => void;
@@ -173,9 +298,9 @@ declare class Tracker<Mutable extends Transceiver<any>> {
     private unsubscribeFromInnerValue;
     private observeCore;
     private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+    mutableState: MutableAtomToken<Mutable, Serializable>;
     latestUpdateState: AtomToken<typeof this.Update | null>;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+    constructor(mutableState: MutableAtomToken<Mutable, Serializable>, store: Store);
 }
 
 interface MutableAtom<T> extends Atom<T> {
@@ -260,6 +385,7 @@ declare class Store implements Lineage {
 type Atom<T> = {
     key: string;
     type: `atom`;
+    mutable?: boolean;
     family?: FamilyMetadata;
     install: (store: Store) => void;
     subject: Subject<{
@@ -307,17 +433,17 @@ declare class Differ<Leaf extends Record<string, any>, Tree extends Record<strin
 
 declare const AtomIODevtools: () => JSX.Element;
 
-declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
-declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<atom_io.ƒn>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamily<atom_io.TransactionUpdate<atom_io.ƒn>[]>;
-declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken[]>;
-declare const findTimelineState: atom_io.ReadonlySelectorFamily<Timeline>;
-declare const devtoolsAreOpenState: atom_io.AtomToken<boolean>;
+declare const atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
+declare const selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
+declare const transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>;
+declare const findTransactionLogState: ReadonlySelectorFamily<TransactionUpdate<ƒn>[]>;
+declare const timelineIndex: ReadonlySelectorToken<TimelineToken[]>;
+declare const findTimelineState: ReadonlySelectorFamily<Timeline>;
+declare const devtoolsAreOpenState: AtomToken<boolean>;
 type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
-declare const devtoolsViewSelectionState: atom_io.AtomToken<DevtoolsView>;
-declare const devtoolsViewOptionsState: atom_io.AtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: atom_io.AtomFamily<boolean, string>;
+declare const devtoolsViewSelectionState: AtomToken<DevtoolsView>;
+declare const devtoolsViewOptionsState: AtomToken<DevtoolsView[]>;
+declare const findViewIsOpenState: AtomFamily<boolean, string>;
 declare const primitiveRefinery: Refinery<{
     number: (input: unknown) => input is number;
     string: (input: unknown) => input is string;