atom.io 0.19.2 → 0.19.4

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,233 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@typescript-eslint/utils');
+
+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, {
+  explicitStateTypes: () => explicitStateTypes,
+  synchronousSelectorDependencies: () => synchronousSelectorDependencies
+});
+var createRule = utils.ESLintUtils.RuleCreator(
+  (name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`
+);
+var STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`];
+var explicitStateTypes = createRule({
+  name: `explicit-state-types`,
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `State declarations must have generic type arguments directly passed to them`
+    },
+    messages: {
+      noTypeArgument: `State declarations must have generic type arguments directly passed to them.`
+    },
+    schema: []
+    // no options
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        switch (callee.type) {
+          case `Identifier`: {
+            if (STATE_FUNCTIONS.includes(callee.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+            break;
+          }
+          case `MemberExpression`: {
+            if (callee.property.type === `Identifier` && STATE_FUNCTIONS.includes(callee.property.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// 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: {
+    "explicit-state-types": explicitStateTypes,
+    "synchronous-selector-dependencies": synchronousSelectorDependencies
+  }
+};
+
+exports.Rules = rules_exports;
+exports.default = src_default;

package/eslint-plugin/dist/index.js

@@ -0,0 +1,223 @@
+import { __export } from '../../dist/chunk-F2X4B4VY.js';
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+// eslint-plugin/src/rules/index.ts
+var rules_exports = {};
+__export(rules_exports, {
+  explicitStateTypes: () => explicitStateTypes,
+  synchronousSelectorDependencies: () => synchronousSelectorDependencies
+});
+var createRule = ESLintUtils.RuleCreator(
+  (name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`
+);
+var STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`];
+var explicitStateTypes = createRule({
+  name: `explicit-state-types`,
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `State declarations must have generic type arguments directly passed to them`
+    },
+    messages: {
+      noTypeArgument: `State declarations must have generic type arguments directly passed to them.`
+    },
+    schema: []
+    // no options
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        switch (callee.type) {
+          case `Identifier`: {
+            if (STATE_FUNCTIONS.includes(callee.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+            break;
+          }
+          case `MemberExpression`: {
+            if (callee.property.type === `Identifier` && STATE_FUNCTIONS.includes(callee.property.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// 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: {
+    "explicit-state-types": explicitStateTypes,
+    "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,12 @@
+import type { ESLint } from "eslint"
+
+import * as Rules from "./rules"
+
+export { Rules }
+
+export default {
+	rules: {
+		"explicit-state-types": Rules.explicitStateTypes as any,
+		"synchronous-selector-dependencies": Rules.synchronousSelectorDependencies,
+	},
+} satisfies ESLint.Plugin

package/eslint-plugin/src/rules/explicit-state-types.ts

@@ -0,0 +1,55 @@
+import { ESLintUtils } from "@typescript-eslint/utils"
+
+const createRule = ESLintUtils.RuleCreator(
+	(name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`,
+)
+
+const STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`]
+
+export const explicitStateTypes = createRule({
+	name: `explicit-state-types`,
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `State declarations must have generic type arguments directly passed to them`,
+		},
+		messages: {
+			noTypeArgument: `State declarations must have generic type arguments directly passed to them.`,
+		},
+		schema: [], // no options
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CallExpression(node) {
+				const { callee } = node
+				switch (callee.type) {
+					case `Identifier`: {
+						if (STATE_FUNCTIONS.includes(callee.name)) {
+							if (!node.typeArguments) {
+								context.report({
+									node,
+									messageId: `noTypeArgument`,
+								})
+							}
+						}
+						break
+					}
+					case `MemberExpression`: {
+						if (
+							callee.property.type === `Identifier` &&
+							STATE_FUNCTIONS.includes(callee.property.name)
+						) {
+							if (!node.typeArguments) {
+								context.report({
+									node,
+									messageId: `noTypeArgument`,
+								})
+							}
+						}
+					}
+				}
+			},
+		}
+	},
+})

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

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