atom.io 0.27.5 → 0.28.0

package/introspection/src/refinery.ts

@@ -0,0 +1,100 @@
+import type { Flat } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+export type Refinement<A, B extends A> = (a: A) => a is B
+
+export type ClassSignature = abstract new (...args: any) => any
+
+export type RefinementStrategy = ClassSignature | Refinement<unknown, any>
+
+export type Supported<Refine extends RefinementStrategy> =
+	Refine extends Refinement<unknown, infer T>
+		? T
+		: Refine extends ClassSignature
+			? InstanceType<Refine>
+			: never
+
+export type RefinementSupport = Record<string, RefinementStrategy>
+
+export class Refinery<SupportedTypes extends RefinementSupport> {
+	public supported: SupportedTypes
+
+	public constructor(supported: SupportedTypes) {
+		this.supported = supported
+	}
+
+	public refine<T>(input: T):
+		| Flat<{
+				[K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]>
+					? {
+							type: K
+							data: Supported<SupportedTypes[K]>
+						}
+					: Supported<SupportedTypes[K]> extends T
+						? {
+								type: K
+								data: Supported<SupportedTypes[K]>
+							}
+						: never
+		  }>[keyof SupportedTypes]
+		| (T extends Supported<SupportedTypes[keyof SupportedTypes]>
+				? never
+				: null) {
+		for (const [key, refiner] of Object.entries(this.supported)) {
+			try {
+				if (
+					// @ts-expect-error that's the point
+					refiner(input) === true &&
+					refiner !== Boolean
+				) {
+					return { type: key, data: input } as any
+				}
+			} catch (_) {
+				try {
+					if (input instanceof refiner) {
+						return { type: key, data: input } as any
+					}
+				} catch (__) {}
+			}
+		}
+		return null as any
+	}
+}
+
+export const primitiveRefinery = new Refinery({
+	number: (input: unknown): input is number => typeof input === `number`,
+	string: (input: unknown): input is string => typeof input === `string`,
+	boolean: (input: unknown): input is boolean => typeof input === `boolean`,
+	null: (input: unknown): input is null => input === null,
+})
+
+export const jsonTreeRefinery = new Refinery({
+	object: (input: unknown): input is Json.Tree.Object => {
+		if (!input) {
+			return false
+		}
+		const prototype = Object.getPrototypeOf(input)
+		return prototype === Object.prototype
+	},
+	array: (input: unknown): input is Json.Tree.Array => Array.isArray(input),
+})
+
+export const jsonRefinery = new Refinery({
+	...primitiveRefinery.supported,
+	...jsonTreeRefinery.supported,
+})
+
+export type JsonType = keyof typeof jsonRefinery.supported
+
+export const discoverType = (
+	input: unknown,
+): JsonType | `Map` | `Set` | `undefined` | (string & {}) => {
+	if (input === undefined) {
+		return `undefined`
+	}
+	const refined = jsonRefinery.refine(input)
+	if (refined) {
+		return refined.type
+	}
+	return Object.getPrototypeOf(input).constructor.name
+}

package/json/dist/index.d.ts

@@ -1,31 +1,6 @@
 import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
-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<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-
-type json_Array<Element extends Serializable = Serializable> = Array<Element>;
-type json_Serializable = Serializable;
-declare namespace json {
-  export type { json_Array as Array, Object$1 as Object, json_Serializable as Serializable };
-}
-
-declare const parseJson: <S extends stringified<Serializable>>(str: S | string) => S extends stringified<infer J> ? J : Serializable;
-type stringified<J extends Serializable> = string & {
-    __json: J;
-};
-declare const stringifyJson: <J extends Serializable>(json: J) => stringified<J>;
-
 type Entries<K extends keyof any = keyof any, V = any> = [K, V][];
 type KeyOfEntries<E extends Entries> = E extends [infer K, any][] ? K : never;
 type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
@@ -35,13 +10,39 @@ type FromEntries<E extends Entries> = Flat<{
     [K in KeyOfEntries<E>]: ValueOfEntry<E, K>;
 }>;
 declare function fromEntries<E extends Entries>(entries: E): FromEntries<E>;
+declare function toEntries<T extends object>(obj: T): Entries<keyof T, T[keyof T]>;
 
-declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
+declare const selectJson: <T, J extends Json.Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
 
-declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
-declare function selectJsonFamily<T, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
+declare function selectJsonFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
+declare function selectJsonFamily<T, J extends Json.Serializable, K extends Canonical>(atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
 
+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> = string & {
+    __json: J;
+};
+declare const parseJson: <S extends stringified<Json.Serializable>>(str: S | string) => S extends stringified<infer J> ? J : Json.Serializable;
+declare const stringifyJson: <J extends Json.Serializable>(json: J) => stringified<J>;
 type Canonical = primitive | ReadonlyArray<Canonical>;
-type JsonIO = (...params: Serializable[]) => Serializable | void;
+type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void;
+type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
+declare const isJson: (input: unknown) => input is Json.Tree.Node;
 
-export { type Canonical, type Entries, type FromEntries, json as Json, type JsonIO, type JsonInterface, type KeyOfEntries, type ValueOfEntry, fromEntries, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson };
+export { type Canonical, type Entries, type FromEntries, Json, type JsonIO, type JsonInterface, type KeyOfEntries, type ValueOfEntry, fromEntries, isJson, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson, toEntries };

package/json/dist/index.js

@@ -1,79 +1,4 @@
-import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
-export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
-import { createWritableSelectorFamily } from '../../dist/chunk-6ABWLAGY.js';
+export { fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-EUVKUTW3.js';
+import '../../dist/chunk-BX3MTH2Z.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
-
-// json/src/entries.ts
-function fromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
-  return createStandaloneSelector(store, {
-    key: `${atom.key}:JSON`,
-    get: ({ get }) => transform.toJson(get(atom)),
-    set: ({ set }, newValue) => {
-      set(atom, transform.fromJson(newValue));
-    }
-  });
-};
-function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
-  const jsonFamily = createWritableSelectorFamily(
-    store,
-    {
-      key: `${atomFamilyToken.key}:JSON`,
-      get: (key) => ({ seek, get }) => {
-        const existingState = seek(atomFamilyToken, key);
-        if (existingState) {
-          return transform.toJson(get(existingState));
-        }
-        const stringKey = stringifyJson(key);
-        const molecule = store.molecules.get(stringKey);
-        if (molecule) {
-          const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
-          return transform.toJson(get(atom));
-        }
-        if (store.config.lifespan === `immortal`) {
-          throw new Error(`No molecule found for key "${stringKey}"`);
-        }
-        const newToken = initFamilyMemberInStore(store, atomFamilyToken, key);
-        return transform.toJson(get(newToken));
-      },
-      set: (key) => ({ seek, set }, newValue) => {
-        const existingState = seek(atomFamilyToken, key);
-        if (existingState) {
-          set(existingState, transform.fromJson(newValue));
-        } else {
-          const stringKey = stringifyJson(key);
-          const molecule = store.molecules.get(stringKey);
-          if (molecule) {
-            const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
-            set(atom, transform.fromJson(newValue));
-          } else {
-            if (store.config.lifespan === `immortal`) {
-              throw new Error(`No molecule found for key "${stringKey}"`);
-            }
-            set(
-              initFamilyMemberInStore(store, atomFamilyToken, key),
-              transform.fromJson(newValue)
-            );
-          }
-        }
-      }
-    },
-    [`mutable`, `json`]
-  );
-  const atomFamily = withdraw(atomFamilyToken, store);
-  atomFamily.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (event) => {
-      if (event.token.family) {
-        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
-      }
-    }
-  );
-  return jsonFamily;
-}
-
-export { fromEntries, selectJson, selectJsonFamily };

package/json/src/entries.ts

@@ -17,3 +17,9 @@ export type FromEntries<E extends Entries> = Flat<{
 export function fromEntries<E extends Entries>(entries: E): FromEntries<E> {
 	return Object.fromEntries(entries) as FromEntries<E>
 }
+
+export function toEntries<T extends object>(
+	obj: T,
+): Entries<keyof T, T[keyof T]> {
+	return Object.entries(obj) as Entries<keyof T, T[keyof T]>
+}

package/json/src/index.ts

@@ -1,14 +1,55 @@
-import type { Json, JsonInterface, stringified } from "~/packages/anvl/src/json"
-import { parseJson, stringifyJson } from "~/packages/anvl/src/json"
-import type { primitive } from "~/packages/anvl/src/primitive"
-
 export * from "./entries"
 export * from "./select-json"
 export * from "./select-json-family"
 
-export type { Json, JsonInterface, primitive, stringified }
-export { parseJson, stringifyJson }
+export type primitive = boolean | number | string | null
+
+export namespace Json {
+	export namespace Tree {
+		export type Array<Element = unknown> = ReadonlyArray<Element>
+		export type Object<K extends string = string, V = unknown> = Record<K, V>
+		export type Fork = Array | Object
+		export type Leaf = primitive
+		export type Node = Fork | Leaf
+	}
+
+	export type Serializable =
+		| primitive
+		| Readonly<{ [key: string]: Serializable }>
+		| ReadonlyArray<Serializable>
+
+	export type Object<
+		Key extends string = string,
+		Value extends Serializable = Serializable,
+	> = Record<Key, Value>
+
+	export type Array<Element extends Serializable = Serializable> =
+		ReadonlyArray<Element>
+}
+
+export type stringified<J extends Json.Serializable> = string & { __json: J }
+
+export const parseJson = <S extends stringified<Json.Serializable>>(
+	str: S | string,
+): S extends stringified<infer J> ? J : Json.Serializable => JSON.parse(str)
+
+export const stringifyJson = <J extends Json.Serializable>(
+	json: J,
+): stringified<J> => JSON.stringify(json) as stringified<J>
 
 export type Canonical = primitive | ReadonlyArray<Canonical>
 
 export type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void
+
+export type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+	toJson: (t: T) => J
+	fromJson: (json: J) => T
+}
+
+const JSON_PROTOTYPES = [Array, Boolean, Number, Object, String] as const
+export const isJson = (input: unknown): input is Json.Tree.Node => {
+	if (input === null) return true
+	if (input === undefined) return false
+	const prototype = Object.getPrototypeOf(input)
+	return JSON_PROTOTYPES.includes(prototype)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.27.5",
+  "version": "0.28.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -57,18 +57,18 @@
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.3",
+    "@types/react": "18.3.4",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.1.0",
-    "@typescript-eslint/rule-tester": "8.1.0",
+    "@typescript-eslint/parser": "8.2.0",
+    "@typescript-eslint/rule-tester": "8.2.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
     "drizzle-kit": "0.24.0",
     "drizzle-orm": "0.33.0",
     "eslint": "9.9.0",
-    "framer-motion": "11.3.28",
-    "happy-dom": "14.12.3",
+    "framer-motion": "11.3.29",
+    "happy-dom": "15.0.0",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
@@ -82,7 +82,7 @@
     "tsup": "8.2.4",
     "tsx": "4.17.0",
     "typescript": "5.5.4",
-    "vite": "5.4.1",
+    "vite": "5.4.2",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },
@@ -135,7 +135,10 @@
     "realtime-testing/src",
     "transceivers/set-rtx/dist",
     "transceivers/set-rtx/package.json",
-    "transceivers/set-rtx/src"
+    "transceivers/set-rtx/src",
+    "web/dist",
+    "web/package.json",
+    "web/src"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -217,6 +220,11 @@
     "./transceivers/set-rtx": {
       "import": "./transceivers/set-rtx/dist/index.js",
       "types": "./transceivers/set-rtx/dist/index.d.ts"
+    },
+    "./web/package.json": "./web/package.json",
+    "./web": {
+      "import": "./web/dist/index.js",
+      "types": "./web/dist/index.d.ts"
     }
   },
   "scripts": {
@@ -240,6 +248,7 @@
     "build:realtime-server": "cd realtime-server && tsup",
     "build:realtime-testing": "cd realtime-testing && tsup",
     "build:transceivers:set-rtx": "cd transceivers/set-rtx && tsup",
+    "build:web": "cd web && tsup",
     "lint:biome": "biome check -- .",
     "lint:eslint": "eslint --flag unstable_ts_config -- .",
     "lint:eslint:build": "bun run build:main",

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

@@ -1,93 +1,3 @@
-import * as Internal from 'atom.io/internal';
-import * as atom_io from 'atom.io';
-import { AtomToken, ReadableToken, SelectorToken } from 'atom.io';
-
-type ClassSignature = abstract new (...args: any) => any;
-
-type Refinement<A, B extends A> = (a: A) => a is B;
-
-type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
-type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
-type RefinementSupport = Record<string, RefinementStrategy>;
-declare class Refinery<SupportedTypes extends RefinementSupport> {
-    supported: SupportedTypes;
-    constructor(supported: SupportedTypes);
-    refine(input: unknown): {
-        [K in keyof SupportedTypes]: {
-            type: K;
-            data: Supported<SupportedTypes[K]>;
-        };
-    }[keyof SupportedTypes] | null;
-}
-
-type PlainObject = Record<keyof any, unknown>;
-
-type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
-
-type FamilyNode<Token extends ReadableToken<unknown>> = {
-    key: string;
-    familyMembers: Map<string, Token>;
-};
-type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
-
-type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
-
-type Delta = {
-    summary: string;
-    added?: [path: string, addedStringifiedValue: string][];
-    removed?: [path: string, removedStringifiedValue: string][];
-    changed?: [path: string, delta: Delta][];
-};
-type Diff<T> = (a: T, b: T) => Delta;
-type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
-declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
-    leafRefinery: Refinery<Leaf>;
-    treeRefinery: Refinery<Tree>;
-    leafDiffers: {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    };
-    treeDiffers: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    };
-    constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    } & {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    });
-    diff(a: unknown, b: unknown): Delta;
-}
-
 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<Internal.Func>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<Internal.Func>[], string>;
-declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken<any>[]>;
-declare const findTimelineState: atom_io.ReadonlySelectorFamilyToken<Internal.Timeline<any>, string>;
-declare const devtoolsAreOpenState: atom_io.RegularAtomToken<boolean>;
-type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
-declare const devtoolsViewSelectionState: atom_io.RegularAtomToken<DevtoolsView>;
-declare const devtoolsViewOptionsState: atom_io.RegularAtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: atom_io.RegularAtomFamilyToken<boolean, string>;
-declare const primitiveRefinery: Refinery<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}>;
-declare const jsonTreeRefinery: Refinery<{
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-declare const prettyJson: Differ<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}, {
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-
-export { AtomIODevtools, atomIndex, devtoolsAreOpenState, devtoolsViewOptionsState, devtoolsViewSelectionState, findTimelineState, findTransactionLogState, findViewIsOpenState, jsonTreeRefinery, prettyJson, primitiveRefinery, selectorIndex, timelineIndex, transactionIndex };
+export { AtomIODevtools };