atom.io 0.21.1 → 0.22.0

package/eslint-plugin/src/walk.ts

@@ -0,0 +1,73 @@
+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 `FunctionDeclaration`:
+		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 `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/immortal/dist/index.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+var atom_io = require('atom.io');
+var data = require('atom.io/data');
+var internal = require('atom.io/internal');
+var json = require('atom.io/json');
+
+// immortal/src/molecule.ts
+var Molecule = class _Molecule {
+  constructor(key, above = [], store = internal.IMPLICIT.STORE) {
+    this.key = key;
+    this.above = above;
+    this.store = store;
+    this.below = [];
+    this.tokens = [];
+    this.joins = [];
+    this.dispose = this[Symbol.dispose];
+    store.molecules.set(json.stringifyJson(key), this);
+    for (const parent of above) {
+      parent.below.push(this);
+    }
+  }
+  bond(token) {
+    const state = internal.initFamilyMember(token, this.key, this.store);
+    if (token.type === `mutable_atom_family`) {
+      const jsonFamily = internal.getJsonFamily(token, this.store);
+      const jsonState = internal.initFamilyMember(jsonFamily, this.key, this.store);
+      this.tokens.push(jsonState);
+    }
+    this.tokens.push(state);
+    return state;
+  }
+  spawn(key) {
+    const child = new _Molecule(key, [this], this.store);
+    return child;
+  }
+  with(molecule) {
+    return (key) => {
+      const child = new _Molecule(key, [this, molecule], this.store);
+      return child;
+    };
+  }
+  detach(child) {
+    const childIndex = this.below.indexOf(child);
+    if (childIndex !== void 0) {
+      this.below.splice(childIndex, 1);
+    }
+    const parentIndex = child.above.indexOf(this);
+    if (parentIndex !== void 0) {
+      child.above.splice(parentIndex, 1);
+    }
+  }
+  claim(child) {
+    if (child === this) {
+      return;
+    }
+    for (const parent of child.above) {
+      parent.detach(child);
+    }
+    this.below.push(child);
+    child.above.push(this);
+  }
+  clear() {
+    var _a;
+    while (this.below.length > 0) {
+      (_a = this.below.pop()) == null ? void 0 : _a.dispose();
+    }
+    while (this.tokens.length > 0) {
+      const token = this.tokens.pop();
+      if (token) {
+        atom_io.disposeState(token, this.store);
+      }
+    }
+    while (this.joins.length > 0) {
+      const join = this.joins.pop();
+      if (join) {
+        join.molecules.delete(json.stringifyJson(this.key));
+      }
+    }
+  }
+  join(token) {
+    const join = data.getJoin(token, this.store);
+    join.molecules.set(json.stringifyJson(this.key), this);
+    this.joins.push(join);
+  }
+  [Symbol.dispose]() {
+    this.clear();
+    this.store.molecules.delete(json.stringifyJson(this.key));
+    for (const parent of this.above) {
+      parent.detach(this);
+    }
+  }
+};
+function seekState(token, key) {
+  const state = internal.seekInStore(token, key, internal.IMPLICIT.STORE);
+  return state;
+}
+
+exports.Molecule = Molecule;
+exports.seekState = seekState;

package/immortal/dist/index.js

@@ -0,0 +1,97 @@
+import '../../dist/chunk-F2X4B4VY.js';
+import { disposeState } from 'atom.io';
+import { getJoin } from 'atom.io/data';
+import { IMPLICIT, initFamilyMember, getJsonFamily, seekInStore } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
+
+var Molecule = class _Molecule {
+  constructor(key, above = [], store = IMPLICIT.STORE) {
+    this.key = key;
+    this.above = above;
+    this.store = store;
+    this.below = [];
+    this.tokens = [];
+    this.joins = [];
+    this.dispose = this[Symbol.dispose];
+    store.molecules.set(stringifyJson(key), this);
+    for (const parent of above) {
+      parent.below.push(this);
+    }
+  }
+  bond(token) {
+    const state = initFamilyMember(token, this.key, this.store);
+    if (token.type === `mutable_atom_family`) {
+      const jsonFamily = getJsonFamily(token, this.store);
+      const jsonState = initFamilyMember(jsonFamily, this.key, this.store);
+      this.tokens.push(jsonState);
+    }
+    this.tokens.push(state);
+    return state;
+  }
+  spawn(key) {
+    const child = new _Molecule(key, [this], this.store);
+    return child;
+  }
+  with(molecule) {
+    return (key) => {
+      const child = new _Molecule(key, [this, molecule], this.store);
+      return child;
+    };
+  }
+  detach(child) {
+    const childIndex = this.below.indexOf(child);
+    if (childIndex !== void 0) {
+      this.below.splice(childIndex, 1);
+    }
+    const parentIndex = child.above.indexOf(this);
+    if (parentIndex !== void 0) {
+      child.above.splice(parentIndex, 1);
+    }
+  }
+  claim(child) {
+    if (child === this) {
+      return;
+    }
+    for (const parent of child.above) {
+      parent.detach(child);
+    }
+    this.below.push(child);
+    child.above.push(this);
+  }
+  clear() {
+    var _a;
+    while (this.below.length > 0) {
+      (_a = this.below.pop()) == null ? void 0 : _a.dispose();
+    }
+    while (this.tokens.length > 0) {
+      const token = this.tokens.pop();
+      if (token) {
+        disposeState(token, this.store);
+      }
+    }
+    while (this.joins.length > 0) {
+      const join = this.joins.pop();
+      if (join) {
+        join.molecules.delete(stringifyJson(this.key));
+      }
+    }
+  }
+  join(token) {
+    const join = getJoin(token, this.store);
+    join.molecules.set(stringifyJson(this.key), this);
+    this.joins.push(join);
+  }
+  [Symbol.dispose]() {
+    this.clear();
+    this.store.molecules.delete(stringifyJson(this.key));
+    for (const parent of this.above) {
+      parent.detach(this);
+    }
+  }
+};
+function seekState(token, key) {
+  const state = seekInStore(token, key, IMPLICIT.STORE);
+  return state;
+}
+
+export { Molecule, seekState };

package/immortal/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "atom.io-immortal",
+	"type": "module",
+	"private": true,
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"browser": "./dist/index.js",
+			"require": "./dist/index.cjs",
+			"types": "./dist/index.d.ts"
+		}
+	}
+}

package/immortal/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./molecule"
+export * from "./seek-state"

package/immortal/src/molecule.ts

@@ -0,0 +1,134 @@
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import { disposeState } from "atom.io"
+import type { Join, JoinToken } from "atom.io/data"
+import { getJoin } from "atom.io/data"
+import type { Store, Transceiver } from "atom.io/internal"
+import { getJsonFamily, IMPLICIT, initFamilyMember } from "atom.io/internal"
+import { type Json, stringifyJson } from "atom.io/json"
+
+export class Molecule<Key extends Json.Serializable> {
+	public readonly below: Molecule<any>[] = []
+	public readonly tokens: ReadableToken<any>[] = []
+	public readonly joins: Join<any, any, any, any>[] = []
+	public constructor(
+		public readonly key: Key,
+		public readonly above: Molecule<any>[] = [],
+		public readonly store: Store = IMPLICIT.STORE,
+	) {
+		store.molecules.set(stringifyJson(key), this)
+		for (const parent of above) {
+			parent.below.push(this)
+		}
+	}
+
+	public bond<
+		T extends Transceiver<any>,
+		J extends Json.Serializable,
+		K extends string,
+	>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>
+	public bond<T, K extends Key>(
+		token: RegularAtomFamilyToken<T, K>,
+	): RegularAtomToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: WritableSelectorFamilyToken<T, K>,
+	): WritableSelectorToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: ReadonlySelectorFamilyToken<T, K>,
+	): ReadonlySelectorToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: WritableFamilyToken<T, K>,
+	): WritableToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: ReadableFamilyToken<T, K>,
+	): ReadableToken<T>
+	public bond(token: ReadableFamilyToken<any, any>): ReadableToken<any> {
+		const state = initFamilyMember(token, this.key, this.store)
+		if (token.type === `mutable_atom_family`) {
+			const jsonFamily = getJsonFamily(token, this.store)
+			const jsonState = initFamilyMember(jsonFamily, this.key, this.store)
+			this.tokens.push(jsonState)
+		}
+		this.tokens.push(state)
+		return state
+	}
+
+	public spawn<K extends Json.Serializable>(key: K): Molecule<K> {
+		const child = new Molecule(key, [this], this.store)
+		return child
+	}
+
+	public with(molecule: Molecule<any>): (key: string) => Molecule<any> {
+		return (key) => {
+			const child = new Molecule(key, [this, molecule], this.store)
+			return child
+		}
+	}
+
+	public detach(child: Molecule<any>): void {
+		const childIndex = this.below.indexOf(child)
+		if (childIndex !== undefined) {
+			this.below.splice(childIndex, 1)
+		}
+		const parentIndex = child.above.indexOf(this)
+		if (parentIndex !== undefined) {
+			child.above.splice(parentIndex, 1)
+		}
+	}
+
+	public claim(child: Molecule<any>): void {
+		if (child === this) {
+			return
+		}
+		for (const parent of child.above) {
+			parent.detach(child)
+		}
+		this.below.push(child)
+		child.above.push(this)
+	}
+
+	public clear(): void {
+		while (this.below.length > 0) {
+			this.below.pop()?.dispose()
+		}
+		while (this.tokens.length > 0) {
+			const token = this.tokens.pop()
+			if (token) {
+				disposeState(token, this.store)
+			}
+		}
+		while (this.joins.length > 0) {
+			const join = this.joins.pop()
+			if (join) {
+				join.molecules.delete(stringifyJson(this.key))
+			}
+		}
+	}
+
+	public join(token: JoinToken<any, any, any, any>): void {
+		const join = getJoin(token, this.store)
+		join.molecules.set(stringifyJson(this.key), this)
+		this.joins.push(join)
+	}
+
+	private [Symbol.dispose](): void {
+		this.clear()
+		this.store.molecules.delete(stringifyJson(this.key))
+		for (const parent of this.above) {
+			parent.detach(this)
+		}
+	}
+	public dispose = this[Symbol.dispose]
+}

package/immortal/src/seek-state.ts

@@ -0,0 +1,60 @@
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Transceiver } from "atom.io/internal"
+import { IMPLICIT, seekInStore } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+export function seekState<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+): MutableAtomToken<T, J> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+): RegularAtomToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+): WritableSelectorToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+): ReadonlySelectorToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+): WritableToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+): ReadableToken<T> | undefined
+
+export function seekState(
+	token: ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+): ReadableToken<any> | undefined {
+	const state = seekInStore(token, key, IMPLICIT.STORE)
+	return state
+}