atom.io 0.19.2 → 0.19.3

package/data/dist/index.js

@@ -1,6 +1,6 @@
 export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-MSCJWACE.js';
 import '../../dist/chunk-FTONNX2R.js';
-import '../../dist/chunk-U2IICNHQ.js';
+import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';
 
 function dict(findState, index, store = IMPLICIT.STORE) {

package/data/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

package/dist/{chunk-U2IICNHQ.js → chunk-F2X4B4VY.js}

@@ -30,5 +30,9 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-export { __objRest, __restKey, __spreadProps, __spreadValues };
+export { __export, __objRest, __restKey, __spreadProps, __spreadValues };

package/dist/index.js

@@ -1,4 +1,4 @@
-import './chunk-U2IICNHQ.js';
+import './chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
 import { createStandaloneAtom, IMPLICIT, createAtomFamily, findInStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 

package/eslint-plugin/dist/index.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// eslint-plugin/src/rules/index.ts
+var rules_exports = {};
+__export(rules_exports, {
+  synchronousSelectorDependencies: () => synchronousSelectorDependencies
+});
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+function walk(node, callback, 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;
+  }
+}
+var synchronousSelectorDependencies = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `disallow await before calling get on the parameter's get method inside selector`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: []
+    // no options
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        let selectorComputation;
+        if (`name` in node.callee && node.callee.name === `selectorFamily`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const selectorLookupProperty = node.arguments[0].properties.find(
+              (prop) => {
+                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
+              }
+            );
+            const selectorLookup = selectorLookupProperty == null ? void 0 : selectorLookupProperty.value;
+            if ((selectorLookup == null ? void 0 : selectorLookup.type) === `FunctionExpression` || (selectorLookup == null ? void 0 : selectorLookup.type) === `ArrowFunctionExpression`) {
+              if (selectorLookup.body.type === `BlockStatement`) {
+                for (const statement of selectorLookup.body.body) {
+                  if (statement.type === `ReturnStatement` && statement.argument) {
+                    selectorComputation = statement.argument;
+                  }
+                }
+              } else if (selectorLookup.body.type === `FunctionExpression` || selectorLookup.body.type === `ArrowFunctionExpression`) {
+                selectorComputation = selectorLookup.body;
+              }
+            }
+          }
+        }
+        if (`name` in node.callee && node.callee.name === `selector`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const selectorComputationProperty = node.arguments[0].properties.find(
+              (prop) => {
+                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
+              }
+            );
+            selectorComputation = selectorComputationProperty == null ? void 0 : selectorComputationProperty.value;
+          }
+        }
+        if ((selectorComputation == null ? void 0 : selectorComputation.type) === `FunctionExpression` || (selectorComputation == null ? void 0 : selectorComputation.type) === `ArrowFunctionExpression`) {
+          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
+          let awaited;
+          let awaitNode;
+          walk(selectorComputation, (n, depth) => {
+            if (typeof awaited === `number`) {
+              if (awaited > depth) {
+                awaited = void 0;
+                awaitNode = void 0;
+              }
+            }
+            switch (n.type) {
+              case `AwaitExpression`:
+                awaited = depth;
+                awaitNode = n;
+                break;
+              case `CallExpression`:
+                if (awaitNode) {
+                  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 === `get`) {
+                        willReport = true;
+                      }
+                      break;
+                    case `Identifier`:
+                      if (n.callee.name === `get`) {
+                        willReport = true;
+                      }
+                      break;
+                  }
+                  if (willReport) {
+                    context.report({
+                      node: awaitNode,
+                      message: `Using await before calling the 'get' transactor is not allowed.`
+                    });
+                  }
+                }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/index.ts
+var src_default = {
+  rules: {
+    "synchronous-selector-dependencies": synchronousSelectorDependencies
+  }
+};
+
+exports.Rules = rules_exports;
+exports.default = src_default;

package/eslint-plugin/dist/index.js

@@ -0,0 +1,171 @@
+import { __export } from '../../dist/chunk-F2X4B4VY.js';
+
+// eslint-plugin/src/rules/index.ts
+var rules_exports = {};
+__export(rules_exports, {
+  synchronousSelectorDependencies: () => synchronousSelectorDependencies
+});
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+function walk(node, callback, 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;
+  }
+}
+var synchronousSelectorDependencies = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `disallow await before calling get on the parameter's get method inside selector`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: []
+    // no options
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        let selectorComputation;
+        if (`name` in node.callee && node.callee.name === `selectorFamily`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const selectorLookupProperty = node.arguments[0].properties.find(
+              (prop) => {
+                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
+              }
+            );
+            const selectorLookup = selectorLookupProperty == null ? void 0 : selectorLookupProperty.value;
+            if ((selectorLookup == null ? void 0 : selectorLookup.type) === `FunctionExpression` || (selectorLookup == null ? void 0 : selectorLookup.type) === `ArrowFunctionExpression`) {
+              if (selectorLookup.body.type === `BlockStatement`) {
+                for (const statement of selectorLookup.body.body) {
+                  if (statement.type === `ReturnStatement` && statement.argument) {
+                    selectorComputation = statement.argument;
+                  }
+                }
+              } else if (selectorLookup.body.type === `FunctionExpression` || selectorLookup.body.type === `ArrowFunctionExpression`) {
+                selectorComputation = selectorLookup.body;
+              }
+            }
+          }
+        }
+        if (`name` in node.callee && node.callee.name === `selector`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const selectorComputationProperty = node.arguments[0].properties.find(
+              (prop) => {
+                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
+              }
+            );
+            selectorComputation = selectorComputationProperty == null ? void 0 : selectorComputationProperty.value;
+          }
+        }
+        if ((selectorComputation == null ? void 0 : selectorComputation.type) === `FunctionExpression` || (selectorComputation == null ? void 0 : selectorComputation.type) === `ArrowFunctionExpression`) {
+          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
+          let awaited;
+          let awaitNode;
+          walk(selectorComputation, (n, depth) => {
+            if (typeof awaited === `number`) {
+              if (awaited > depth) {
+                awaited = void 0;
+                awaitNode = void 0;
+              }
+            }
+            switch (n.type) {
+              case `AwaitExpression`:
+                awaited = depth;
+                awaitNode = n;
+                break;
+              case `CallExpression`:
+                if (awaitNode) {
+                  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 === `get`) {
+                        willReport = true;
+                      }
+                      break;
+                    case `Identifier`:
+                      if (n.callee.name === `get`) {
+                        willReport = true;
+                      }
+                      break;
+                  }
+                  if (willReport) {
+                    context.report({
+                      node: awaitNode,
+                      message: `Using await before calling the 'get' transactor is not allowed.`
+                    });
+                  }
+                }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/index.ts
+var src_default = {
+  rules: {
+    "synchronous-selector-dependencies": synchronousSelectorDependencies
+  }
+};
+
+export { rules_exports as Rules, src_default as default };

package/eslint-plugin/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "atom.io-eslint-plugin",
+	"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/eslint-plugin/src/index.ts

@@ -0,0 +1,11 @@
+import type { ESLint } from "eslint"
+
+import * as Rules from "./rules"
+
+export { Rules }
+
+export default {
+	rules: {
+		"synchronous-selector-dependencies": Rules.synchronousSelectorDependencies,
+	},
+} satisfies ESLint.Plugin

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

@@ -0,0 +1 @@
+export * from "./synchronous-selector-dependencies"

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

@@ -0,0 +1,190 @@
+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
+	}
+}
+
+export const synchronousSelectorDependencies = {
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `disallow await before calling get on the parameter's get method inside selector`,
+			category: `Possible Errors`,
+			recommended: false,
+			url: ``, // URL to documentation page for this rule
+		},
+		schema: [], // no options
+	},
+	create(context) {
+		return {
+			CallExpression(node) {
+				let selectorComputation: ESTree.Node | undefined
+				if (`name` in node.callee && node.callee.name === `selectorFamily`) {
+					if (node.arguments[0].type === `ObjectExpression`) {
+						const selectorLookupProperty = node.arguments[0].properties.find(
+							(prop): prop is ESTree.Property => {
+								return (
+									`key` in prop && `name` in prop.key && prop.key.name === `get`
+								)
+							},
+						)
+						const selectorLookup = selectorLookupProperty?.value
+						if (
+							selectorLookup?.type === `FunctionExpression` ||
+							selectorLookup?.type === `ArrowFunctionExpression`
+						) {
+							if (selectorLookup.body.type === `BlockStatement`) {
+								for (const statement of selectorLookup.body.body) {
+									if (
+										statement.type === `ReturnStatement` &&
+										statement.argument
+									) {
+										selectorComputation = statement.argument
+									}
+								}
+							} else if (
+								selectorLookup.body.type === `FunctionExpression` ||
+								selectorLookup.body.type === `ArrowFunctionExpression`
+							) {
+								selectorComputation = selectorLookup.body
+							}
+						}
+					}
+				}
+				if (`name` in node.callee && node.callee.name === `selector`) {
+					if (node.arguments[0].type === `ObjectExpression`) {
+						const selectorComputationProperty =
+							node.arguments[0].properties.find(
+								(prop): prop is ESTree.Property => {
+									return (
+										`key` in prop &&
+										`name` in prop.key &&
+										prop.key.name === `get`
+									)
+								},
+							)
+						selectorComputation = selectorComputationProperty?.value
+					}
+				}
+				if (
+					selectorComputation?.type === `FunctionExpression` ||
+					selectorComputation?.type === `ArrowFunctionExpression`
+				) {
+					const nonDestructuredTransactorsName =
+						selectorComputation.params[0] &&
+						`name` in selectorComputation.params[0]
+							? selectorComputation.params[0].name
+							: undefined
+					let awaited: number | undefined
+					let awaitNode: ESTree.AwaitExpression | undefined
+					walk(selectorComputation, (n, depth) => {
+						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
+						if (typeof awaited === `number`) {
+							if (awaited > depth) {
+								awaited = undefined
+								awaitNode = undefined
+							}
+						}
+						switch (n.type) {
+							case `AwaitExpression`:
+								awaited = depth
+								awaitNode = n
+								break
+							case `CallExpression`:
+								if (awaitNode) {
+									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 === `get`
+											) {
+												willReport = true
+											}
+											break
+										case `Identifier`:
+											if (n.callee.name === `get`) {
+												willReport = true
+											}
+											break
+									}
+									if (willReport) {
+										context.report({
+											node: awaitNode,
+											message: `Using await before calling the 'get' transactor is not allowed.`,
+										})
+									}
+								}
+						}
+					})
+				}
+			},
+		}
+	},
+} satisfies Rule.RuleModule

package/internal/dist/index.js

@@ -1,5 +1,5 @@
 import { Junction } from '../../dist/chunk-FTONNX2R.js';
-import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
+import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 

package/internal/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

package/introspection/dist/index.js

@@ -1,4 +1,4 @@
-import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
+import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
 import { createRegularAtom, newest, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
 

package/introspection/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

package/json/dist/index.js

@@ -1,6 +1,6 @@
 import { parseJson } from '../../dist/chunk-BF4MVQF6.js';
 export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-BF4MVQF6.js';
-import '../../dist/chunk-U2IICNHQ.js';
+import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, IMPLICIT, createSelectorFamily } from 'atom.io/internal';
 
 var selectJson = (atom, transform, store = IMPLICIT.STORE) => {

package/json/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {