atom.io 0.44.8 → 0.44.10

package/src/eslint-plugin/rules/exact-catch-types.ts

@@ -0,0 +1,253 @@
+import type { TSESTree } from "@typescript-eslint/utils"
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils"
+import type {
+	InterfaceType,
+	Symbol as TsSymbol,
+	Type,
+	TypeNode,
+} from "typescript"
+
+const createRule = ESLintUtils.RuleCreator(
+	(name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`,
+)
+
+const STATE_FUNCTIONS_WITH_CATCH = [
+	`atom`,
+	`atomFamily`,
+	`selector`,
+	`selectorFamily`,
+]
+const STANDALONE_FUNCTIONS = [`atom`, `selector`]
+
+export const exactCatchTypes: ESLintUtils.RuleModule<
+	`extraneousErrorTypes` | `invalidCatchProperty` | `missingCatchProperty`,
+	[],
+	unknown,
+	ESLintUtils.RuleListener
+> = createRule({
+	name: `catch-constructor-type`,
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `Ensures that when an error type (E) is provided to an atom, the 'catch' property is set and all constructors in it are assignable to E.`,
+		},
+		messages: {
+			missingCatchProperty:
+				`This {{functionName}} was provided the error type \`{{errorTypeName}}\` ` +
+				`but the required 'catch' property is missing from its options. ` +
+				`Either remove \`{{errorTypeName}}\`, or add \`catch: [{{errorTypeName}}]\` to the options object.`,
+			invalidCatchProperty:
+				`This {{functionName}} was provided a catch array containing the class \`{{constructorName}}\`. ` +
+				`However, that class is not represented in the {{functionName}}'s error type, \`{{errorTypeName}}\`. ` +
+				`As a result, it might catch errors that the {{functionName}} is not designed to handle. ` +
+				`Either include \`{{constructorName}}\` in the {{functionName}}'s error type, or remove it from the 'catch' array.`,
+			extraneousErrorTypes:
+				`This {{functionName}} was provided an error type including the class {{errorTypeName}}, ` +
+				`but its 'catch' property doesn't include a constructor for that class. ` +
+				`Either include a constructor for {{errorTypeName}} in the 'catch' array, or remove {{errorTypeName}} from the error type.`,
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		const parserServices = ESLintUtils.getParserServices(context)
+		const checker = parserServices.program.getTypeChecker()
+
+		return {
+			CallExpression(node) {
+				const {
+					callee,
+					typeArguments: directTypeArguments,
+					arguments: callArguments,
+				} = node
+
+				// Check if the function call is one of the targeted state functions
+				let functionName: string | null = null
+				if (callee.type === AST_NODE_TYPES.Identifier) {
+					if (STATE_FUNCTIONS_WITH_CATCH.includes(callee.name)) {
+						functionName = callee.name
+					}
+				} else if (callee.type === AST_NODE_TYPES.MemberExpression) {
+					if (
+						callee.property.type === AST_NODE_TYPES.Identifier &&
+						STATE_FUNCTIONS_WITH_CATCH.includes(callee.property.name)
+					) {
+						functionName = callee.property.name
+					}
+				}
+
+				if (!functionName) return
+
+				// Where do the type arguments come from?
+				let typeArguments: TSESTree.TSTypeParameterInstantiation | undefined
+				if (directTypeArguments) {
+					typeArguments = directTypeArguments
+				} else {
+					const parent = node.parent
+					if (
+						parent?.type === AST_NODE_TYPES.VariableDeclarator &&
+						parent.init === node
+					) {
+						// Check if the VariableDeclarator has an id with a TypeAnnotation
+						const declaratorId = parent.id
+						if (declaratorId.type === AST_NODE_TYPES.Identifier) {
+							// Check for 'const myAtom: AtomToken<string> = ...'
+							const typeAnnotation = declaratorId.typeAnnotation?.typeAnnotation
+							if (
+								typeAnnotation &&
+								`typeArguments` in typeAnnotation &&
+								typeAnnotation.typeArguments
+							) {
+								typeArguments = typeAnnotation.typeArguments
+							}
+						}
+					}
+				}
+
+				const optionsObject = callArguments[0]
+
+				if (optionsObject?.type !== AST_NODE_TYPES.ObjectExpression) return
+
+				const isStandalone = STANDALONE_FUNCTIONS.includes(functionName)
+
+				const errorTypeNode = typeArguments
+					? isStandalone
+						? typeArguments.params[1]
+						: typeArguments.params[2]
+					: undefined
+
+				let catchProperty: TSESTree.Property | undefined
+				optionsObject.properties.forEach((property) => {
+					if (property.type === AST_NODE_TYPES.Property) {
+						if (
+							(property.key.type === AST_NODE_TYPES.Identifier &&
+								property.key.name === `catch`) ||
+							(property.key.type === AST_NODE_TYPES.Literal &&
+								property.key.value === `catch`)
+						) {
+							catchProperty = property
+						}
+					}
+				})
+
+				if (!errorTypeNode) {
+					return
+				}
+
+				const typeNode = parserServices.esTreeNodeToTSNodeMap.get(
+					errorTypeNode,
+				) as TypeNode
+				// Get the TypeScript Type object for E
+				const errorTypeTs = checker.getTypeFromTypeNode(typeNode)
+				const errorTypeName = checker.typeToString(errorTypeTs)
+
+				if (!catchProperty) {
+					context.report({
+						node: optionsObject,
+						messageId: `missingCatchProperty`,
+						data: { functionName, errorTypeName },
+					})
+					return
+				}
+
+				// --- New Validation: Check Constructor Types ---
+				const catchArray = catchProperty.value
+				if (catchArray.type !== AST_NODE_TYPES.ArrayExpression) {
+					// We only check array literals (e.g., [Ctor1, Ctor2])
+					return
+				}
+
+				// 3. Collect all acceptable nominal symbols from E
+				const acceptableErrorSymbols: TsSymbol[] = []
+
+				// Check if E is a Union Type
+				if (errorTypeTs.isUnion()) {
+					// Add the symbol of every member of the union (e.g., Symbol(SpecialError), Symbol(FancyError))
+					for (const memberType of errorTypeTs.types) {
+						const symbol = memberType.getSymbol()
+						if (symbol) {
+							acceptableErrorSymbols.push(symbol)
+						}
+					}
+				} else {
+					// E is a single type, add its symbol
+					const symbol = errorTypeTs.getSymbol()
+					if (symbol) {
+						acceptableErrorSymbols.push(symbol)
+					}
+				}
+
+				if (catchArray.elements.length === 0) {
+					context.report({
+						node: catchProperty,
+						messageId: `missingCatchProperty`,
+						data: { functionName, errorTypeName },
+					})
+					return
+				}
+				const errorSymbolsToRepresent = new Set(acceptableErrorSymbols)
+
+				// Iterate over each constructor reference in the 'catch' array
+				for (const element of catchArray.elements) {
+					if (!element || element.type !== AST_NODE_TYPES.Identifier) {
+						// Only check simple identifier references (e.g., [ClientError])
+						continue
+					}
+
+					// Get the type of the constructor identifier (e.g., the Type of 'Error')
+					const constructorTsNode =
+						parserServices.esTreeNodeToTSNodeMap.get(element)
+					const constructorType = checker.getTypeAtLocation(constructorTsNode)
+					const constructorName = element.name
+
+					// console.log(`constructorName`, constructorName)
+
+					// Extract the instance type from the constructor type.
+					// e.g., turn 'typeof ClientError' into 'ClientError'
+					let instanceType: Type | undefined
+					if (
+						(constructorType as InterfaceType).getConstructSignatures().length >
+						0
+					) {
+						// Get the return type of the constructor signature
+						const signature = (
+							constructorType as InterfaceType
+						).getConstructSignatures()[0]
+						instanceType = signature.getReturnType()
+					}
+
+					// If we couldn't get the instance type, skip the check
+
+					const constructorInstanceSymbol = instanceType?.getSymbol()
+					if (!constructorInstanceSymbol) continue
+
+					// Check for symbol identity
+					if (acceptableErrorSymbols.includes(constructorInstanceSymbol)) {
+						errorSymbolsToRepresent.delete(constructorInstanceSymbol)
+					} else {
+						context.report({
+							node: element,
+							messageId: `invalidCatchProperty`,
+							data: {
+								functionName,
+								constructorName: constructorName,
+								errorTypeName: errorTypeName,
+							},
+						})
+					}
+				}
+
+				for (const errorSymbol of errorSymbolsToRepresent) {
+					context.report({
+						node: catchProperty,
+						messageId: `extraneousErrorTypes`,
+						data: {
+							errorTypeName: checker.symbolToString(errorSymbol),
+							functionName,
+						},
+					})
+				}
+			},
+		}
+	},
+})

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

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import { ESLintUtils } from "@typescript-eslint/utils"
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils"
 
 const createRule = ESLintUtils.RuleCreator(
 	(name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`,
@@ -14,9 +14,15 @@ const STATE_FUNCTIONS = [
 	`selectorFamily`,
 ]
 
+type Options = [
+	{
+		permitAnnotation?: boolean
+	},
+]
+
 export const explicitStateTypes: ESLintUtils.RuleModule<
-	`noTypeArgument`,
-	[],
+	`noTypeArgument` | `noTypeArgumentOrAnnotation`,
+	Options,
 	unknown,
 	ESLintUtils.RuleListener
 > = createRule({
@@ -28,40 +34,87 @@ export const explicitStateTypes: ESLintUtils.RuleModule<
 		},
 		messages: {
 			noTypeArgument: `State declarations must have generic type arguments directly passed to them.`,
+			noTypeArgumentOrAnnotation: `State declarations must have generic type arguments directly passed to them, or a top-level type annotation.`,
 		},
-		schema: [], // no options
+		schema: [
+			{
+				type: `object`,
+				properties: {
+					permitAnnotation: {
+						type: `boolean`,
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
 	},
-	defaultOptions: [],
+	defaultOptions: [
+		{
+			permitAnnotation: false,
+		},
+	],
 	create(context) {
+		const options = context.options[0]
+		const permitAnnotation = options?.permitAnnotation ?? false
+
 		return {
 			CallExpression(node) {
-				const { callee } = node
+				const callee = node.callee
+
 				switch (callee.type) {
-					case `Identifier`: {
-						if (STATE_FUNCTIONS.includes(callee.name)) {
-							if (!node.typeArguments) {
-								context.report({
-									node,
-									messageId: `noTypeArgument`,
-								})
-							}
+					case `Identifier`:
+						if (STATE_FUNCTIONS.includes(callee.name) === false) {
+							return
 						}
 						break
-					}
-					case `MemberExpression`: {
+					case `MemberExpression`:
 						if (
-							callee.property.type === `Identifier` &&
-							STATE_FUNCTIONS.includes(callee.property.name)
+							(callee.property.type === `Identifier` &&
+								STATE_FUNCTIONS.includes(callee.property.name)) === false
 						) {
-							if (!node.typeArguments) {
-								context.report({
-									node,
-									messageId: `noTypeArgument`,
-								})
-							}
+							return
+						}
+						break
+					default:
+						return
+				}
+
+				// Check for the *required* generic type argument first
+				if (node.typeArguments) {
+					return // Generic type argument is present, no error
+				}
+
+				// If generic arguments are missing, check if the top-level annotation exception is enabled AND present
+				if (permitAnnotation) {
+					let hasAnnotation = false
+					// Check if the CallExpression is the initializer of a variable declarator
+					const parent = node.parent
+					if (
+						parent?.type === AST_NODE_TYPES.VariableDeclarator &&
+						parent.init === node
+					) {
+						// Check if the VariableDeclarator has an id with a TypeAnnotation
+						const declaratorId = parent.id
+						if (declaratorId.type === AST_NODE_TYPES.Identifier) {
+							// Check for 'const myAtom: AtomToken<string> = ...'
+							hasAnnotation = Boolean(declaratorId.typeAnnotation)
 						}
 					}
+					if (hasAnnotation) {
+						return // Exception met: type annotation is on the variable declaration
+					}
+					context.report({
+						node,
+						messageId: `noTypeArgumentOrAnnotation`,
+					})
+					return
 				}
+
+				context.report({
+					node,
+					messageId: `noTypeArgument`,
+				})
 			},
 		}
 	},

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

@@ -1 +1,2 @@
+export * from "./exact-catch-types"
 export * from "./explicit-state-types"

package/src/realtime/mutex-store.ts

@@ -2,10 +2,7 @@ import type { AtomFamilyToken } from "atom.io"
 import { atomFamily } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-export const mutexAtoms: AtomFamilyToken<boolean, Canonical> = atomFamily<
-	boolean,
-	Canonical
->({
+export const mutexAtoms: AtomFamilyToken<boolean, Canonical> = atomFamily({
 	key: `mutex`,
 	default: false,
 })

package/src/realtime/shared-room-store.ts

@@ -20,9 +20,7 @@ export type RoomSocketInterface<RoomNames extends string> = {
 	[deleteRoom: `deleteRoom:${string}`]: () => void
 }
 
-export const roomKeysAtom: MutableAtomToken<UList<string>> = mutableAtom<
-	UList<string>
->({
+export const roomKeysAtom: MutableAtomToken<UList<string>> = mutableAtom({
 	key: `roomIndex`,
 	class: UList,
 })
@@ -45,7 +43,7 @@ export const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`> =
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
 	MutableAtomToken<UList<RoomKey>>[],
 	UserKey
-> = selectorFamily<MutableAtomToken<UList<RoomKey>>[], UserKey>({
+> = selectorFamily({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>

package/src/realtime-server/continuity/continuity-store.ts

@@ -49,12 +49,7 @@ export const redactorAtoms: RegularAtomFamilyToken<
 		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
 	},
 	UserKey
-> = atomFamily<
-	{
-		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
-	},
-	UserKey
->({
+> = atomFamily({
 	key: `redactor`,
 	default: { occlude: (updates) => updates },
 })
@@ -66,7 +61,7 @@ export type ContinuitySyncTransactionUpdate = Pick<
 export const unacknowledgedUpdatesAtoms: RegularAtomFamilyToken<
 	ContinuitySyncTransactionUpdate[],
 	UserKey
-> = atomFamily<ContinuitySyncTransactionUpdate[], UserKey>({
+> = atomFamily({
 	key: `unacknowledgedUpdates`,
 	default: () => [],
 })

package/src/realtime-server/realtime-server-stores/server-user-store.ts

@@ -20,20 +20,16 @@ export type SocketSystemHierarchy = Hierarchy<
 >
 
 export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
-	atomFamily<Socket | null, SocketKey>({
+	atomFamily({
 		key: `sockets`,
 		default: null,
 	})
 
-export const socketKeysAtom: MutableAtomToken<UList<SocketKey>> = mutableAtom<
-	UList<SocketKey>
->({
+export const socketKeysAtom: MutableAtomToken<UList<SocketKey>> = mutableAtom({
 	key: `socketsIndex`,
 	class: UList,
 })
-export const userKeysAtom: MutableAtomToken<UList<UserKey>> = mutableAtom<
-	UList<UserKey>
->({
+export const userKeysAtom: MutableAtomToken<UList<UserKey>> = mutableAtom({
 	key: `usersIndex`,
 	class: UList,
 })
@@ -52,7 +48,7 @@ export const usersOfSockets: JoinToken<
 })
 
 export const selfListSelectors: PureSelectorFamilyToken<UserKey[], UserKey> =
-	selectorFamily<UserKey[], UserKey>({
+	selectorFamily({
 		key: `selfList`,
 		get: (userId) => () => [userId],
 	})

package/dist/chunk-dQTVuLCX.js

@@ -1,13 +0,0 @@
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __export = (all) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	return target;
-};
-
-//#endregion
-export { __export as t };