atom.io 0.28.1 → 0.29.0

package/introspection/src/attach-selector-index.ts

@@ -4,7 +4,6 @@ import {
 	createRegularAtom,
 	createStandaloneSelector,
 	deposit,
-	IMPLICIT,
 } from "atom.io/internal"
 
 import type { WritableTokenIndex } from "."
@@ -12,19 +11,19 @@ import type { WritableTokenIndex } from "."
 export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
 
 export const attachSelectorIndex = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorToken<SelectorTokenIndex> => {
 	const readonlySelectorTokenIndexState__INTERNAL =
 		createRegularAtom<SelectorTokenIndex>(
 			store,
 
 			{
-				key: `👁‍🗨 Selector Token Index (Internal)`,
+				key: `🔍 Selector Token Index (Internal)`,
 				default: () => {
 					const base: SelectorTokenIndex = new Map()
 					for (const map of [store.readonlySelectors, store.selectors]) {
 						for (const [key, val] of map) {
-							if (!key.includes(`👁‍🗨`)) {
+							if (!key.includes(`🔍`)) {
 								const token = deposit(val)
 								if (val.family) {
 									let familyNode = base.get(val.family.key)
@@ -49,7 +48,7 @@ export const attachSelectorIndex = (
 						store.on.selectorCreation.subscribe(
 							`introspection`,
 							(selectorToken) => {
-								if (selectorToken.key.includes(`👁‍🗨`)) {
+								if (selectorToken.key.includes(`🔍`)) {
 									return
 								}
 
@@ -101,8 +100,8 @@ export const attachSelectorIndex = (
 			},
 			undefined,
 		)
-	return createStandaloneSelector(IMPLICIT.STORE, {
-		key: `👁‍🗨 Selector Token Index`,
+	return createStandaloneSelector(store, {
+		key: `🔍 Selector Token Index`,
 		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL),
 	})
 }

package/introspection/src/attach-timeline-family.ts

@@ -3,18 +3,17 @@ import type { Store, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
 	createSelectorFamily,
-	IMPLICIT,
 	Subject,
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorFamilyToken<Timeline<any>, string> => {
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,
 		string
 	>(store, {
-		key: `👁‍🗨 Timeline Update Log (Internal)`,
+		key: `🔍 Timeline Update Log (Internal)`,
 		default: (key) =>
 			store.timelines.get(key) ?? {
 				type: `timeline`,
@@ -40,7 +39,7 @@ export const attachTimelineFamily = (
 	const findTimelineLogState = createSelectorFamily<Timeline<any>, string>(
 		store,
 		{
-			key: `👁‍🗨 Timeline Update Log`,
+			key: `🔍 Timeline Update Log`,
 			get:
 				(key) =>
 				({ get }) =>

package/introspection/src/attach-timeline-index.ts

@@ -1,20 +1,16 @@
 import type { ReadonlySelectorToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import {
-	createRegularAtom,
-	createStandaloneSelector,
-	IMPLICIT,
-} from "atom.io/internal"
+import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
 
 export const attachTimelineIndex = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorToken<TimelineToken<any>[]> => {
 	const timelineTokenIndexState__INTERNAL = createRegularAtom<
 		TimelineToken<any>[]
 	>(
 		store,
 		{
-			key: `👁‍🗨 Timeline Token Index (Internal)`,
+			key: `🔍 Timeline Token Index (Internal)`,
 			default: () =>
 				[...store.timelines].map(([key]): TimelineToken<any> => {
 					return { key, type: `timeline` }
@@ -33,7 +29,7 @@ export const attachTimelineIndex = (
 		undefined,
 	)
 	const timelineTokenIndex = createStandaloneSelector(store, {
-		key: `👁‍🗨 Timeline Token Index`,
+		key: `🔍 Timeline Token Index`,
 		get: ({ get }) => get(timelineTokenIndexState__INTERNAL),
 	})
 	return timelineTokenIndex

package/introspection/src/attach-transaction-index.ts

@@ -1,20 +1,16 @@
 import type { ReadonlySelectorToken, TransactionToken } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
-import {
-	createRegularAtom,
-	createStandaloneSelector,
-	IMPLICIT,
-} from "atom.io/internal"
+import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
 
 export const attachTransactionIndex = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorToken<TransactionToken<Func>[]> => {
 	const transactionTokenIndexState__INTERNAL = createRegularAtom<
 		TransactionToken<Func>[]
 	>(
 		store,
 		{
-			key: `👁‍🗨 Transaction Token Index (Internal)`,
+			key: `🔍 Transaction Token Index (Internal)`,
 			default: () =>
 				[...store.transactions].map(([key]): TransactionToken<Func> => {
 					return { key, type: `transaction` }
@@ -33,7 +29,7 @@ export const attachTransactionIndex = (
 		undefined,
 	)
 	const transactionTokenIndex = createStandaloneSelector(store, {
-		key: `👁‍🗨 Transaction Token Index`,
+		key: `🔍 Transaction Token Index`,
 		get: ({ get }) => get(transactionTokenIndexState__INTERNAL),
 	})
 	return transactionTokenIndex

package/introspection/src/attach-transaction-logs.ts

@@ -1,19 +1,15 @@
 import type { ReadonlySelectorFamilyToken, TransactionUpdate } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
-import {
-	createRegularAtomFamily,
-	createSelectorFamily,
-	IMPLICIT,
-} from "atom.io/internal"
+import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
 	const transactionUpdateLogAtoms = createRegularAtomFamily<
 		TransactionUpdate<Func>[],
 		string
 	>(store, {
-		key: `👁‍🗨 Transaction Update Log (Internal)`,
+		key: `🔍 Transaction Update Log (Internal)`,
 		default: () => [],
 		effects: (key) => [
 			({ setSelf }) => {
@@ -30,7 +26,7 @@ export const attachTransactionLogs = (
 		TransactionUpdate<Func>[],
 		string
 	>(store, {
-		key: `👁‍🗨 Transaction Update Log`,
+		key: `🔍 Transaction Update Log`,
 		get:
 			(key) =>
 			({ get }) =>

package/introspection/src/attach-type-selectors.ts

@@ -1,21 +1,28 @@
 import type { ReadonlySelectorFamilyToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { createReadonlySelectorFamily, IMPLICIT } from "atom.io/internal"
+import { createReadonlySelectorFamily } from "atom.io/internal"
 
 import { discoverType } from "./refinery"
 
 export const attachTypeSelectors = (
-	store: Store = IMPLICIT.STORE,
+	store: Store,
 ): ReadonlySelectorFamilyToken<string, string> => {
 	const typeSelectors = createReadonlySelectorFamily<string, string>(store, {
-		key: `👁‍🗨 State Type`,
+		key: `🔍 State Type`,
 		get:
-			(token) =>
+			(key) =>
 			({ get }) => {
 				let state: unknown
 				try {
-					state = get(token as any)
-				} catch (error) {
+					const token =
+						store.atoms.get(key) ??
+						store.selectors.get(key) ??
+						store.readonlySelectors.get(key)
+					if (token === undefined) {
+						throw new Error(`Could not find state with key "${key}"`)
+					}
+					state = get(token)
+				} catch (thrown) {
 					return `error`
 				}
 				const typeOfState = discoverType(state)

package/introspection/src/differ.ts

@@ -1,8 +1,8 @@
-import { sprawl } from "anvl/object"
 import type { Json } from "atom.io/json"
 
 import type { Refinery, Supported } from "./refinery"
 import { discoverType, jsonTreeRefinery, primitiveRefinery } from "./refinery"
+import { sprawl } from "./sprawl"
 
 export function diffNumber(a: number, b: number): Delta {
 	const sign = a < b ? `+` : `-`

package/introspection/src/index.ts

@@ -4,6 +4,7 @@ export * from "./attach-introspection-states"
 export * from "./auditor"
 export * from "./differ"
 export * from "./refinery"
+export * from "./sprawl"
 
 export type FamilyNode<Token extends ReadableToken<unknown>> = {
 	key: string

package/introspection/src/refinery.ts

@@ -68,14 +68,16 @@ export const primitiveRefinery = new Refinery({
 	null: (input: unknown): input is null => input === null,
 })
 
+export function isPlainObject(input: unknown): input is Json.Tree.Object {
+	if (!input) {
+		return false
+	}
+	const prototype = Object.getPrototypeOf(input)
+	return prototype === Object.prototype
+}
+
 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
-	},
+	object: isPlainObject,
 	array: (input: unknown): input is Json.Tree.Array => Array.isArray(input),
 })
 

package/introspection/src/sprawl.ts

@@ -0,0 +1,42 @@
+import { isPlainObject } from "./refinery"
+
+// if you found what you were looking for, return true and break
+export type InspectionResult = Partial<{
+	pathComplete: true
+	jobComplete: true
+}>
+export type InspectNode = (
+	path: string[],
+	node: unknown,
+) => InspectionResult | void
+
+export const sprawl = (
+	tree: Array<unknown> | object,
+	inspector: InspectNode,
+): void => {
+	const walk = (path: string[], node: unknown): InspectionResult => {
+		const inspect = (p: string[], n: unknown): InspectionResult | null => {
+			// console.log(parent)
+			const result = inspector(p, n)
+			if (result) return result
+			return null
+		}
+		const result = inspect(path, node)
+		if (result?.jobComplete ?? result?.pathComplete) {
+			return result
+		}
+		const childEntries = Array.isArray(node)
+			? node.map((v, i) => [i, v])
+			: isPlainObject(node)
+				? Object.entries(node)
+				: []
+		for (const [k, v] of childEntries) {
+			const subResult = walk([...path, k], v)
+			if (subResult?.jobComplete) {
+				return subResult
+			}
+		}
+		return {}
+	}
+	walk([], tree)
+}

package/json/dist/index.d.ts

@@ -44,5 +44,16 @@ type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
     fromJson: (json: J) => T;
 };
 declare const isJson: (input: unknown) => input is Json.Tree.Node;
+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;
+}
+declare const JSON_DEFAULTS: JsonTypes;
 
-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 };
+export { type Canonical, type Entries, type FromEntries, JSON_DEFAULTS, JSON_TYPE_NAMES, Json, type JsonIO, type JsonInterface, type JsonTypeName, type JsonTypes, type KeyOfEntries, type ValueOfEntry, fromEntries, isJson, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson, toEntries };

package/json/dist/index.js

@@ -1,4 +1,113 @@
-export { fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-YQ46F5O2.js';
-import '../../dist/chunk-6WL4RQMQ.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-XPYU2HY2.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);
+}
+function toEntries(obj) {
+  return Object.entries(obj);
+}
+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;
+}
+
+// json/src/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_PROTOTYPES = [
+  Array.prototype,
+  Boolean.prototype,
+  Number.prototype,
+  Object.prototype,
+  String.prototype
+];
+var isJson = (input) => {
+  if (input === null) return true;
+  if (input === void 0) return false;
+  const prototype = Object.getPrototypeOf(input);
+  return JSON_PROTOTYPES.includes(prototype);
+};
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries };

package/json/src/index.ts

@@ -59,3 +59,32 @@ export const isJson = (input: unknown): input is Json.Tree.Node => {
 	const prototype = Object.getPrototypeOf(input)
 	return JSON_PROTOTYPES.includes(prototype)
 }
+
+export const JSON_TYPE_NAMES = [
+	`array`,
+	`boolean`,
+	`null`,
+	`number`,
+	`object`,
+	`string`,
+] as const
+
+export type JsonTypeName = (typeof JSON_TYPE_NAMES)[number]
+
+export interface JsonTypes extends Record<JsonTypeName, Json.Serializable> {
+	array: Json.Array
+	boolean: boolean
+	null: null
+	number: number
+	object: Json.Object
+	string: string
+}
+
+export const JSON_DEFAULTS: JsonTypes = {
+	array: [],
+	boolean: false,
+	null: null,
+	number: 0,
+	object: {},
+	string: ``,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.28.1",
+  "version": "0.29.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -52,23 +52,23 @@
     }
   },
   "devDependencies": {
-    "@testing-library/react": "16.0.0",
-    "@types/eslint": "9.6.0",
+    "@testing-library/react": "16.0.1",
+    "@types/eslint": "9.6.1",
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.4",
+    "@types/react": "18.3.5",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.2.0",
-    "@typescript-eslint/rule-tester": "8.2.0",
+    "@typescript-eslint/parser": "8.4.0",
+    "@typescript-eslint/rule-tester": "8.4.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.24.1",
+    "drizzle-kit": "0.24.2",
     "drizzle-orm": "0.33.0",
-    "eslint": "9.9.0",
-    "framer-motion": "11.3.29",
-    "happy-dom": "15.0.0",
+    "eslint": "9.9.1",
+    "framer-motion": "11.5.2",
+    "happy-dom": "15.7.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
@@ -80,9 +80,9 @@
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
-    "tsx": "4.17.0",
+    "tsx": "4.19.0",
     "typescript": "5.5.4",
-    "vite": "5.4.2",
+    "vite": "5.4.3",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },