atom.io 0.35.0 → 0.36.1

package/src/eslint-plugin/walk.ts

@@ -1,81 +0,0 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import type * as ESTree from "estree"
-
-export function walk(
-	node: ESTree.Node,
-	callback: (node: ESTree.Node, depth: number) => void,
-	depth = 0,
-): void {
-	callback(node, depth)
-
-	switch (node.type) {
-		case `AwaitExpression`:
-			walk(node.argument, callback, depth + 1)
-			break
-		case `FunctionExpression`:
-		case `ArrowFunctionExpression`:
-			for (const param of node.params) {
-				walk(param, callback, depth + 1)
-			}
-			walk(node.body, callback, depth + 1)
-			break
-		case `BlockStatement`:
-			for (const statement of node.body) {
-				walk(statement, callback, depth + 1)
-			}
-			break
-		case `IfStatement`:
-			walk(node.test, callback, depth)
-			walk(node.consequent, callback, depth)
-			if (node.alternate) {
-				walk(node.alternate, callback, depth)
-			}
-			break
-		case `SwitchStatement`:
-			walk(node.discriminant, callback, depth + 1)
-			for (const caseOrDefault of node.cases) {
-				walk(caseOrDefault, callback, depth)
-			}
-			break
-		case `ReturnStatement`:
-			if (node.argument) {
-				walk(node.argument, callback, depth)
-			}
-			break
-		case `SwitchCase`:
-			if (node.test) {
-				walk(node.test, callback, depth)
-			}
-			for (const statement of node.consequent) {
-				walk(statement, callback, depth)
-			}
-			break
-		case `VariableDeclaration`:
-			for (const declaration of node.declarations) {
-				walk(declaration, callback, depth)
-				if (declaration.init) {
-					walk(declaration.init, callback, depth)
-				}
-			}
-			break
-		case `BinaryExpression`:
-			walk(node.left, callback, depth)
-			walk(node.right, callback, depth)
-			break
-		case `ConditionalExpression`:
-			walk(node.test, callback, depth + 1)
-			walk(node.consequent, callback, depth + 1)
-			walk(node.alternate, callback, depth + 1)
-			break
-		case `MemberExpression`:
-			walk(node.object, callback, depth)
-			walk(node.property, callback, depth)
-			break
-		case `CallExpression`:
-			walk(node.callee, callback, depth)
-			for (const argument of node.arguments) {
-				walk(argument, callback, depth)
-			}
-			break
-	}
-}

package/src/internal/set-state/copy-mutable-if-needed.ts

@@ -1,27 +0,0 @@
-import type { MutableAtom, Transceiver } from ".."
-import { Tracker } from "../mutable"
-import type { Store } from "../store"
-
-export function copyMutableIfNeeded<T extends Transceiver<any>>(
-	target: Store,
-	atom: MutableAtom<T, any>,
-	origin: Store,
-): T {
-	const originValue = origin.valueMap.get(atom.key)
-	const targetValue = target.valueMap.get(atom.key)
-
-	if (originValue !== targetValue) {
-		return targetValue
-	}
-
-	if (originValue === undefined) {
-		return atom.default()
-	}
-
-	origin.logger.info(`📃`, `atom`, atom.key, `copying`)
-	const jsonValue = atom.toJson(originValue)
-	const copiedValue = atom.fromJson(jsonValue)
-	target.valueMap.set(atom.key, copiedValue)
-	new Tracker(atom, origin)
-	return copiedValue
-}

package/src/json/select-json-family.ts

@@ -1,55 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
-import { createWritablePureSelectorFamily } from "atom.io/internal"
-
-import type { Canonical, Json, JsonInterface } from "."
-
-export function selectJsonFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K>
-export function selectJsonFamily<
-	T,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K>
-export function selectJsonFamily<
-	T,
-	J extends Json.Serializable,
-	K extends Canonical,
->(
-	store: Store,
-	atomFamilyToken:
-		| AtomIO.MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, J, K>
-		| AtomIO.RegularAtomFamilyToken<T, K>,
-	transform: JsonInterface<T, J>,
-): AtomIO.WritablePureSelectorFamilyToken<J, K> {
-	const jsonFamily = createWritablePureSelectorFamily<J, K>(
-		store,
-		{
-			key: `${atomFamilyToken.key}:JSON`,
-			get:
-				(key) =>
-				({ get }) => {
-					const baseState = get(atomFamilyToken, key)
-					return transform.toJson(baseState)
-				},
-			set:
-				(key) =>
-				({ set }, newValue) => {
-					set(atomFamilyToken, key, transform.fromJson(newValue))
-				},
-		},
-		[`mutable`, `json`],
-	)
-	return jsonFamily
-}

package/src/json/select-json.ts

@@ -1,19 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
-import { createStandaloneSelector, IMPLICIT } from "atom.io/internal"
-
-import type { Json, JsonInterface } from "."
-
-export const selectJson = <T, J extends Json.Serializable>(
-	atom: AtomIO.AtomToken<T>,
-	transform: JsonInterface<T, J>,
-	store: Store = IMPLICIT.STORE,
-): AtomIO.WritablePureSelectorToken<J> => {
-	return createStandaloneSelector(store, {
-		key: `${atom.key}:JSON`,
-		get: ({ get }) => transform.toJson(get(atom)),
-		set: ({ set }, newValue) => {
-			set(atom, transform.fromJson(newValue))
-		},
-	})
-}