atom.io 0.21.1 → 0.23.0

package/eslint-plugin/src/rules/index.ts

@@ -1,2 +1,3 @@
 export * from "./explicit-state-types"
+export * from "./lifespan"
 export * from "./synchronous-selector-dependencies"

package/eslint-plugin/src/rules/lifespan.ts

@@ -0,0 +1,203 @@
+import type { Rule } from "eslint"
+import type * as ESTree from "estree"
+
+import { walk } from "../walk"
+
+export const lifespan = {
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+			category: `Possible Errors`,
+			recommended: false,
+			url: ``, // URL to documentation page for this rule
+		},
+		schema: [
+			{
+				type: `string`,
+				enum: [`ephemeral`, `immortal`],
+				default: `ephemeral`,
+			},
+		],
+	},
+	create(context) {
+		const storeLifespan = (context.options[0] ?? `ephemeral`) as
+			| `ephemeral`
+			| `immortal`
+		return {
+			ImportDeclaration(node) {
+				const importSource = node.source.value as string
+				if (!importSource.startsWith(`atom.io/`)) {
+					return
+				}
+				const [_, subPackageName] = importSource.split(`/`)
+				if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+					context.report({
+						node,
+						message: `do not import from "${importSource}" in an ${storeLifespan} store`,
+					})
+				}
+			},
+
+			CallExpression(node) {
+				if (storeLifespan === `ephemeral`) {
+					return
+				}
+
+				const functionCallee =
+					node.callee.type === `Identifier` ? node.callee : undefined
+				const methodCallee =
+					node.callee.type === `MemberExpression` &&
+					node.callee.property.type === `Identifier`
+						? node.callee.property
+						: undefined
+				const callee = functionCallee ?? methodCallee
+
+				if (callee === undefined) {
+					return
+				}
+
+				if (callee.name === `findState`) {
+					context.report({
+						node,
+						message: `do not use findState in an ${storeLifespan} store`,
+					})
+				}
+
+				const storeProcedures: (
+					| ESTree.ArrowFunctionExpression
+					| ESTree.FunctionExpression
+				)[] = []
+				if (
+					callee.name === `selector` ||
+					callee.name === `selectorFamily` ||
+					callee.name === `transaction`
+				) {
+					if (node.arguments[0].type === `ObjectExpression`) {
+						const argProperties = node.arguments[0].properties
+						switch (callee.name) {
+							case `selector`:
+							case `selectorFamily`:
+								{
+									const getAndSetProps = argProperties.filter(
+										(prop): prop is ESTree.Property => {
+											return (
+												`key` in prop &&
+												`name` in prop.key &&
+												(prop.key.name === `get` || prop.key.name === `set`)
+											)
+										},
+									)
+									switch (callee.name) {
+										case `selector`:
+											{
+												for (const prop of getAndSetProps) {
+													if (
+														prop.value.type === `FunctionExpression` ||
+														prop.value.type === `ArrowFunctionExpression`
+													) {
+														storeProcedures.push(prop.value)
+													}
+												}
+											}
+											break
+										case `selectorFamily`:
+											{
+												for (const prop of getAndSetProps) {
+													const { value } = prop
+													if (
+														value.type === `FunctionExpression` ||
+														value.type === `ArrowFunctionExpression`
+													) {
+														if (value.body.type === `BlockStatement`) {
+															for (const statement of value.body.body) {
+																if (
+																	statement.type === `ReturnStatement` &&
+																	statement.argument &&
+																	(statement.argument.type ===
+																		`FunctionExpression` ||
+																		statement.argument.type ===
+																			`ArrowFunctionExpression`)
+																) {
+																	storeProcedures.push(statement.argument)
+																}
+															}
+														} else if (
+															value.body.type === `FunctionExpression` ||
+															value.body.type === `ArrowFunctionExpression`
+														) {
+															storeProcedures.push(value.body)
+														}
+													}
+												}
+											}
+											break
+									}
+								}
+								break
+
+							case `transaction`:
+								{
+									const doProp = argProperties.find(
+										(prop): prop is ESTree.Property => {
+											return (
+												`key` in prop &&
+												`name` in prop.key &&
+												prop.key.name === `do`
+											)
+										},
+									)
+									if (doProp) {
+										if (
+											doProp.value.type === `FunctionExpression` ||
+											doProp.value.type === `ArrowFunctionExpression`
+										) {
+											storeProcedures.push(doProp.value)
+										}
+									}
+								}
+								break
+						}
+					}
+				}
+
+				for (const storeProcedure of storeProcedures) {
+					const transactorsParam = storeProcedure.params[0]
+					const nonDestructuredTransactorsName =
+						transactorsParam && `name` in transactorsParam
+							? transactorsParam.name
+							: undefined
+					walk(storeProcedure.body, (n) => {
+						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
+						if (n.type === `CallExpression`) {
+							let willReport = false
+							switch (n.callee.type) {
+								case `MemberExpression`:
+									if (
+										n.callee.object.type === `Identifier` &&
+										n.callee.object.name === nonDestructuredTransactorsName &&
+										n.callee.property.type === `Identifier` &&
+										n.callee.property.name === `find`
+									) {
+										willReport = true
+									}
+									break
+								case `Identifier`:
+									if (n.callee.name === `find`) {
+										willReport = true
+									}
+									break
+							}
+							if (willReport) {
+								context.report({
+									node: n,
+									message: `Using find in a transactor is not allowed in an immortal store.`,
+								})
+							}
+						}
+					})
+				}
+			},
+		}
+	},
+} satisfies Rule.RuleModule

package/eslint-plugin/src/rules/synchronous-selector-dependencies.ts

@@ -1,71 +1,7 @@
 import type { Rule } from "eslint"
 import type * as ESTree from "estree"
 
-function walk(
-	node: ESTree.Node,
-	callback: (node: ESTree.Node, depth: number) => void,
-	depth = 0,
-) {
-	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
-	}
-}
+import { walk } from "../walk"
 
 export const synchronousSelectorDependencies = {
 	meta: {

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,260 @@
+'use strict';
+
+var Internal = require('atom.io/internal');
+var json = require('atom.io/json');
+var data = require('atom.io/data');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var Molecule = class _Molecule {
+  constructor(store, above, token) {
+    this.store = store;
+    this.token = token;
+    this.type = `molecule`;
+    this.below = [];
+    this.tokens = [];
+    this.joins = [];
+    this.subject = new Internal.Subject();
+    this.dispose = this[Symbol.dispose];
+    if (above) {
+      if (Array.isArray(above)) {
+        this.above = above;
+        for (const parent of above) {
+          parent.below.push(this);
+        }
+      } else {
+        this.above = [above];
+        above.below.push(this);
+      }
+    } else {
+      this.above = [];
+    }
+  }
+  get key() {
+    return this.token.key;
+  }
+  bond(token) {
+    const state = Internal.initFamilyMember(token, this.token.key, this.store);
+    if (token.type === `mutable_atom_family`) {
+      const jsonFamily = Internal.getJsonFamily(token, this.store);
+      const jsonState = Internal.initFamilyMember(jsonFamily, this.token.key, this.store);
+      this.tokens.push(jsonState);
+    }
+    this.tokens.push(state);
+    this.subject.next({ type: `state_creation`, token: state });
+    return state;
+  }
+  spawn(key) {
+    const child = new _Molecule(this.store, this, { key, type: `molecule` });
+    return child;
+  }
+  with(molecule) {
+    return (key) => {
+      const child = new _Molecule(this.store, [this, molecule], {
+        key,
+        type: `molecule`
+      });
+      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) {
+        Internal.disposeFromStore(token, this.store);
+      }
+    }
+    while (this.joins.length > 0) {
+      const join = this.joins.pop();
+      if (join) {
+        join.molecules.delete(json.stringifyJson(this.token.key));
+      }
+    }
+  }
+  join(token) {
+    const join = data.getJoin(token, this.store);
+    join.molecules.set(json.stringifyJson(this.token.key), this);
+    this.joins.push(join);
+  }
+  [Symbol.dispose]() {
+    this.clear();
+    const target = Internal.newest(this.store);
+    target.molecules.delete(json.stringifyJson(this.token.key));
+    for (const parent of this.above) {
+      parent.detach(this);
+    }
+  }
+};
+
+// immortal/src/make-molecule.ts
+function createMoleculeFamily(options, store) {
+  const subject = new Internal__namespace.Subject();
+  const token = {
+    key: options.key,
+    type: `molecule_family`
+  };
+  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+function moleculeFamily(options) {
+  return createMoleculeFamily(options, Internal__namespace.IMPLICIT.STORE);
+}
+function makeMoleculeInStore(store, context, family, key, ...params) {
+  const target = Internal__namespace.newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => store.molecules.get(json.stringifyJson(ctx.key))).filter((m) => m !== void 0);
+  const Formula = Internal__namespace.withdraw(family, store);
+  const molecule = new Formula(owners, token, ...params);
+  target.molecules.set(json.stringifyJson(key), molecule);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = Internal__namespace.isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    Formula.subject.next(update);
+  }
+  return token;
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(
+    Internal__namespace.IMPLICIT.STORE,
+    context,
+    family,
+    key,
+    ...params
+  );
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(json.stringifyJson(token.key));
+  return molecule;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, Internal__namespace.IMPLICIT.STORE);
+}
+function disposeMolecule(token, store) {
+  const mole = useMoleculeFromStore(token, store);
+  if (!mole || !token.family) {
+    return;
+  }
+  const { family } = token;
+  const Formula = Internal__namespace.withdraw(family, store);
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    token,
+    family,
+    context: mole.above,
+    familyKeys: mole.tokens.map((t) => {
+      var _a;
+      return (_a = t.family) == null ? void 0 : _a.key;
+    }).filter((k) => typeof k === `string`)
+  };
+  if (token.family) {
+    disposalEvent.family = token.family;
+  }
+  const isTransaction = Internal__namespace.isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    Formula.subject.next(disposalEvent);
+  }
+  mole.dispose();
+}
+function makeRootMolecule(key, store = Internal__namespace.IMPLICIT.STORE) {
+  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
+  store.molecules.set(json.stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
+function seekState(token, key) {
+  if (token.type === `molecule_family`) {
+    return Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
+  }
+  const state = Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
+  return state;
+}
+
+exports.Molecule = Molecule;
+exports.createMoleculeFamily = createMoleculeFamily;
+exports.disposeMolecule = disposeMolecule;
+exports.makeMolecule = makeMolecule;
+exports.makeMoleculeInStore = makeMoleculeInStore;
+exports.makeRootMolecule = makeRootMolecule;
+exports.moleculeFamily = moleculeFamily;
+exports.seekState = seekState;
+exports.useMolecule = useMolecule;
+exports.useMoleculeFromStore = useMoleculeFromStore;