atom.io 0.29.2 → 0.29.4

package/internal/src/junction.ts

@@ -0,0 +1,375 @@
+import type { Refinement } from "atom.io/introspection"
+import type { Json } from "atom.io/json"
+
+export interface JunctionEntries<Content extends Json.Object | null>
+	extends Json.Object {
+	readonly relations: [string, string[]][]
+	readonly contents: [string, Content][]
+}
+export interface JunctionSchema<ASide extends string, BSide extends string>
+	extends Json.Object {
+	readonly between: [a: ASide, b: BSide]
+	readonly cardinality: `1:1` | `1:n` | `n:n`
+}
+
+export type BaseExternalStoreConfiguration = {
+	addRelation: (a: string, b: string) => void
+	deleteRelation: (a: string, b: string) => void
+	replaceRelationsSafely: (a: string, bs: string[]) => void
+	replaceRelationsUnsafely: (a: string, bs: string[]) => void
+	getRelatedKeys: (key: string) => Set<string> | undefined
+	has: (a: string, b?: string) => boolean
+}
+
+export type ExternalStoreWithContentConfiguration<Content extends Json.Object> =
+	{
+		getContent: (contentKey: string) => Content | undefined
+		setContent: (contentKey: string, content: Content) => void
+		deleteContent: (contentKey: string) => void
+	}
+
+export type Empty<Obj extends object> = {
+	[Key in keyof Obj]?: undefined
+}
+
+export type ExternalStoreConfiguration<Content extends Json.Object | null> =
+	Content extends Json.Object
+		? BaseExternalStoreConfiguration &
+				ExternalStoreWithContentConfiguration<Content>
+		: BaseExternalStoreConfiguration &
+				Empty<ExternalStoreWithContentConfiguration<Json.Object>>
+
+export type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
+	warn?: (...args: any[]) => void
+	externalStore?: ExternalStoreConfiguration<Content>
+	isContent?: Refinement<unknown, Content>
+	makeContentKey?: (a: string, b: string) => string
+}
+
+export type JunctionJSON<
+	ASide extends string,
+	BSide extends string,
+	Content extends Json.Object | null,
+> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>
+
+export class Junction<
+	const ASide extends string,
+	const BSide extends string,
+	const Content extends Json.Object | null = null,
+> {
+	public readonly a: ASide
+	public readonly b: BSide
+	public readonly cardinality: `1:1` | `1:n` | `n:n`
+	public readonly relations = new Map<string, Set<string>>()
+	public readonly contents = new Map<string, Content>()
+
+	public isContent: Refinement<unknown, Content> | null
+	public makeContentKey = (a: string, b: string): string => `${a}:${b}`
+
+	public warn?: (...args: any[]) => void
+
+	public getRelatedKeys(key: string): Set<string> | undefined {
+		return this.relations.get(key)
+	}
+	protected addRelation(a: string, b: string): void {
+		let aRelations = this.relations.get(a)
+		let bRelations = this.relations.get(b)
+		if (aRelations) {
+			aRelations.add(b)
+		} else {
+			aRelations = new Set([b])
+			this.relations.set(a, aRelations)
+		}
+		if (bRelations) {
+			bRelations.add(a)
+		} else {
+			bRelations = new Set([a])
+			this.relations.set(b, bRelations)
+		}
+	}
+	protected deleteRelation(a: string, b: string): void {
+		const aRelations = this.relations.get(a)
+		if (aRelations) {
+			aRelations.delete(b)
+			if (aRelations.size === 0) {
+				this.relations.delete(a)
+			}
+			const bRelations = this.relations.get(b)
+			if (bRelations) {
+				bRelations.delete(a)
+				if (bRelations.size === 0) {
+					this.relations.delete(b)
+				}
+			}
+		}
+	}
+
+	protected replaceRelationsUnsafely(a: string, bs: string[]): void {
+		this.relations.set(a, new Set(bs))
+		for (const b of bs) {
+			const bRelations = new Set([a])
+			this.relations.set(b, bRelations)
+		}
+	}
+	protected replaceRelationsSafely(a: string, bs: string[]): void {
+		const aRelationsPrev = this.relations.get(a)
+		if (aRelationsPrev) {
+			for (const b of aRelationsPrev) {
+				const bRelations = this.relations.get(b)
+				if (bRelations) {
+					if (bRelations.size === 1) {
+						this.relations.delete(b)
+					} else {
+						bRelations.delete(a)
+					}
+					this.contents.delete(this.makeContentKey(a, b))
+				}
+			}
+		}
+		this.relations.set(a, new Set(bs))
+		for (const b of bs) {
+			let bRelations = this.relations.get(b)
+			if (bRelations) {
+				bRelations.add(a)
+			} else {
+				bRelations = new Set([a])
+				this.relations.set(b, bRelations)
+			}
+		}
+	}
+
+	protected getContentInternal(contentKey: string): Content | undefined {
+		return this.contents.get(contentKey)
+	}
+	protected setContent(contentKey: string, content: Content): void {
+		this.contents.set(contentKey, content)
+	}
+	protected deleteContent(contentKey: string): void {
+		this.contents.delete(contentKey)
+	}
+
+	public constructor(
+		data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>,
+		config?: JunctionAdvancedConfiguration<Content>,
+	) {
+		this.a = data.between[0]
+		this.b = data.between[1]
+
+		this.cardinality = data.cardinality
+		if (!config?.externalStore) {
+			this.relations = new Map(data.relations?.map(([a, b]) => [a, new Set(b)]))
+			this.contents = new Map(data.contents)
+		}
+		this.isContent = config?.isContent ?? null
+		if (config?.makeContentKey) {
+			this.makeContentKey = config.makeContentKey
+		}
+		if (config?.externalStore) {
+			const externalStore = config.externalStore
+			this.has = (a, b) => externalStore.has(a, b)
+			this.addRelation = (a, b) => {
+				externalStore.addRelation(a, b)
+			}
+			this.deleteRelation = (a, b) => {
+				externalStore.deleteRelation(a, b)
+			}
+			this.replaceRelationsSafely = (a, bs) => {
+				externalStore.replaceRelationsSafely(a, bs)
+			}
+			this.replaceRelationsUnsafely = (a, bs) => {
+				externalStore.replaceRelationsUnsafely(a, bs)
+			}
+			this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key)
+			if (externalStore.getContent) {
+				this.getContentInternal = (contentKey) => {
+					return externalStore.getContent(contentKey) as any
+				}
+				this.setContent = (contentKey, content) => {
+					externalStore.setContent(contentKey, content as any)
+				}
+				this.deleteContent = (contentKey) => {
+					externalStore.deleteContent(contentKey)
+				}
+			}
+			for (const [x, ys] of data.relations ?? []) {
+				for (const y of ys) this.addRelation(x, y)
+			}
+			for (const [contentKey, content] of data.contents ?? []) {
+				this.setContent(contentKey, content)
+			}
+		}
+		if (config?.warn) {
+			this.warn = config.warn
+		}
+	}
+	public toJSON(): JunctionJSON<ASide, BSide, Content> {
+		return {
+			between: [this.a, this.b],
+			cardinality: this.cardinality,
+			relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+			contents: [...this.contents.entries()],
+		}
+	}
+
+	public set(
+		a: string,
+		...rest: Content extends null ? [b: string] : [b: string, content: Content]
+	): this
+	public set(
+		relation: { [Key in ASide | BSide]: string },
+		...rest: Content extends null ? [] | [b?: undefined] : [content: Content]
+	): this
+	public set(
+		a: string | { [Key in ASide | BSide]: string },
+		...rest: Content extends null
+			? [] | [b?: string | undefined]
+			: [b: string, content: Content] | [content: Content]
+	): this {
+		const b: string =
+			typeof rest[0] === `string`
+				? rest[0]
+				: (a[this.b as keyof typeof a] as string)
+		const content: Content | undefined =
+			(rest[1] ?? typeof rest[0] === `string`) ? undefined : (rest[0] as Content)
+		a = typeof a === `string` ? a : a[this.a]
+		switch (this.cardinality) {
+			// biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
+			case `1:1`: {
+				const bPrev = this.getRelatedKey(a)
+				if (bPrev && bPrev !== b) this.delete(bPrev, a)
+			}
+			case `1:n`: {
+				const aPrev = this.getRelatedKey(b)
+				if (aPrev && aPrev !== a) this.delete(aPrev, b)
+			}
+		}
+		if (content) {
+			const contentKey = this.makeContentKey(a, b)
+			this.setContent(contentKey, content)
+		}
+		this.addRelation(a, b)
+		return this
+	}
+
+	public delete(a: string, b?: string): this
+	public delete(
+		relation:
+			| Record<ASide | BSide, string>
+			| Record<ASide, string>
+			| Record<BSide, string>,
+		b?: undefined,
+	): this
+	public delete(
+		x:
+			| Record<ASide | BSide, string>
+			| Record<ASide, string>
+			| Record<BSide, string>
+			| string,
+		b?: string,
+	): this {
+		// @ts-expect-error we deduce that this.b may index x
+		b = typeof b === `string` ? b : (x[this.b] as string | undefined)
+		// @ts-expect-error we deduce that this.a may index x
+		const a = typeof x === `string` ? x : (x[this.a] as string | undefined)
+
+		if (a === undefined && typeof b === `string`) {
+			const bRelations = this.getRelatedKeys(b)
+			if (bRelations) {
+				for (const bRelation of bRelations) {
+					this.delete(bRelation, b)
+				}
+			}
+		}
+		if (typeof a === `string` && b === undefined) {
+			const aRelations = this.getRelatedKeys(a)
+			if (aRelations) {
+				for (const aRelation of aRelations) {
+					this.delete(a, aRelation)
+				}
+			}
+		}
+		if (typeof a === `string` && typeof b === `string`) {
+			this.deleteRelation(a, b)
+			const contentKey = this.makeContentKey(a, b)
+			this.deleteContent(contentKey)
+		}
+		return this
+	}
+
+	public getRelatedKey(key: string): string | undefined {
+		const relations = this.getRelatedKeys(key)
+		if (relations) {
+			if (relations.size > 1) {
+				this.warn?.(
+					`${relations.size} related keys were found for key "${key}": (${[
+						...relations,
+					]
+						.map((k) => `"${k}"`)
+						.join(`, `)}). Only one related key was expected.`,
+				)
+			}
+			for (const relation of relations) {
+				return relation
+			}
+		}
+	}
+
+	public replaceRelations(
+		a: string,
+		relations: Content extends null ? string[] : Record<string, Content>,
+		config?: { reckless: boolean },
+	): this {
+		const hasContent = !Array.isArray(relations)
+		const bs = hasContent ? Object.keys(relations) : relations
+		if (config?.reckless) {
+			this.replaceRelationsUnsafely(a, bs)
+		} else {
+			this.replaceRelationsSafely(a, bs)
+		}
+		if (hasContent) {
+			for (const b of bs) {
+				const contentKey = this.makeContentKey(a, b)
+				const content = relations[b] as Content
+				this.setContent(contentKey, content)
+			}
+		}
+		return this
+	}
+
+	public getContent(a: string, b: string): Content | undefined {
+		const contentKey = this.makeContentKey(a, b)
+		return this.getContentInternal(contentKey)
+	}
+
+	public getRelationEntries(
+		input: Record<ASide, string> | Record<BSide, string>,
+	): [string, Content][] {
+		const a: string | undefined = (input as any)[this.a]
+		const b: string | undefined = (input as any)[this.b]
+		if (a !== undefined && b === undefined) {
+			const aRelations = this.getRelatedKeys(a)
+			if (aRelations) {
+				return [...aRelations].map((aRelation) => {
+					return [aRelation, this.getContent(a, aRelation) ?? (null as Content)]
+				})
+			}
+		}
+		if (a === undefined && b !== undefined) {
+			const bRelations = this.getRelatedKeys(b)
+			if (bRelations) {
+				return [...bRelations].map((bRelation) => {
+					return [bRelation, this.getContent(bRelation, b) ?? (null as Content)]
+				})
+			}
+		}
+		return []
+	}
+
+	public has(a: string, b?: string): boolean {
+		if (b) {
+			const setA = this.getRelatedKeys(a)
+			return setA?.has(b) ?? false
+		}
+		return this.relations.has(a)
+	}
+}

package/internal/src/store/store.ts

@@ -10,22 +10,19 @@ import type {
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
 
-import { Junction } from "~/packages/rel8/junction/src"
-
 import type {
 	Atom,
-	Func,
-	Molecule,
 	MutableAtomFamily,
 	ReadonlySelector,
 	ReadonlySelectorFamily,
 	RegularAtomFamily,
-	Tracker,
-	Transceiver,
 	WritableSelector,
 	WritableSelectorFamily,
 } from ".."
+import { Junction } from "../junction"
 import type { Lineage } from "../lineage"
+import type { Molecule } from "../molecule"
+import type { Tracker, Transceiver } from "../mutable"
 import { getJsonToken, getUpdateToken } from "../mutable"
 import type { OperationProgress } from "../operation"
 import { StatefulSubject, Subject } from "../subject"
@@ -36,6 +33,7 @@ import type {
 	TransactionProgress,
 } from "../transaction"
 import { isRootStore } from "../transaction"
+import type { Func } from "../utility-types"
 import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {

package/internal/src/transaction/build-transaction.ts

@@ -2,12 +2,11 @@ import type { disposeState, getState, setState } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
 
-import { Junction } from "~/packages/rel8/junction/src"
-
 import { arbitrary } from "../arbitrary"
 import { disposeFromStore, findInStore, seekInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
+import { Junction } from "../junction"
 import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import { makeMoleculeInStore } from "../molecule"

package/json/dist/index.js

@@ -1,5 +1,4 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-J4B56MM5.js';
-import '../../dist/chunk-IBTHB2PI.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-TCINPEYE.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.29.2",
+  "version": "0.29.4",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -54,20 +54,20 @@
   "devDependencies": {
     "@testing-library/react": "16.0.1",
     "@types/eslint": "9.6.1",
-    "@types/estree": "1.0.5",
+    "@types/estree": "1.0.6",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.5",
+    "@types/react": "18.3.8",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.5.0",
-    "@typescript-eslint/rule-tester": "8.5.0",
+    "@typescript-eslint/parser": "8.6.0",
+    "@typescript-eslint/rule-tester": "8.6.0",
     "@vitest/coverage-v8": "2.1.1",
     "@vitest/ui": "2.1.1",
     "concurrently": "9.0.1",
     "drizzle-kit": "0.24.2",
     "drizzle-orm": "0.33.0",
-    "eslint": "9.10.0",
-    "framer-motion": "11.5.4",
+    "eslint": "9.11.0",
+    "framer-motion": "11.5.6",
     "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
@@ -79,12 +79,13 @@
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
-    "tsup": "8.2.4",
+    "tsup": "8.3.0",
     "tsx": "4.19.1",
     "typescript": "5.6.2",
-    "vite": "5.4.5",
+    "vite": "5.4.7",
     "vite-tsconfig-paths": "5.0.1",
-    "vitest": "2.1.1"
+    "vitest": "2.1.1",
+    "zod": "3.23.8"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -260,6 +261,7 @@
     "test:once": "bun run test:manifest && cross-env IMPORT=dist vitest run",
     "test:once:public": "cross-env IMPORT=dist vitest run public",
     "test:manifest": "tsx __scripts__/manifest-test.node.ts",
-    "test:semver": "bun ../break-check/src/break-check.x.ts --verbose"
+    "test:semver": "bun ../break-check/src/break-check.x.ts --verbose",
+    "postversion": "biome format --write package.json"
   }
 }

package/realtime-react/dist/index.js

@@ -24,7 +24,7 @@ var RealtimeProvider = ({ children, socket }) => {
   }, [socket, setMyId]);
   return /* @__PURE__ */ jsx(RealtimeContext.Provider, { value: { socket, services }, children });
 };
-var { NODE_ENV } = process.env;
+var { NODE_ENV } = globalThis.env ?? {};
 var IN_DEV = NODE_ENV === `development`;
 function noop() {
 }

package/realtime-react/src/use-single-effect.ts

@@ -1,6 +1,6 @@
 import * as React from "react"
 
-const { NODE_ENV } = process.env
+const { NODE_ENV } = globalThis.env ?? {}
 const IN_DEV = NODE_ENV === `development`
 
 function noop() {}

package/realtime-server/dist/index.js

@@ -6,7 +6,7 @@ import { editRelationsInStore, join, findRelationsInStore } from 'atom.io/data';
 import * as AtomIO from 'atom.io';
 import { atomFamily, selectorFamily, atom } from 'atom.io';
 import { roomIndex, usersInRooms } from 'atom.io/realtime';
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 
 // realtime-server/src/ipc-sockets/custom-socket.ts
 var CustomSocket = class {

package/realtime-testing/dist/index.js

@@ -1,5 +1,5 @@
 import '../../dist/chunk-XWL6SNVU.js';
-import * as http from 'http';
+import * as http from 'node:http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
 import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';