atom.io 0.44.9 → 0.44.11

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

@@ -0,0 +1,256 @@
+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 FAMILY_FUNCTIONS = [`atomFamily`, `selectorFamily`]
+
+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}}\` as a possible 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
+
+				let errorParamIndex = 1
+
+				// 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
+								errorParamIndex = 2 // AtomToken<T, K, E>
+							}
+						}
+					}
+				}
+
+				const optionsObject = callArguments[0]
+
+				if (optionsObject?.type !== AST_NODE_TYPES.ObjectExpression) return
+
+				const isFamilyDeclaration = FAMILY_FUNCTIONS.includes(functionName)
+				if (isFamilyDeclaration) {
+					errorParamIndex = 2 // atomFamily<T, K, E>
+				}
+
+				const errorTypeNode = typeArguments
+					? typeArguments.params[errorParamIndex]
+					: undefined
+				if (!errorTypeNode) {
+					return
+				}
+
+				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
+						}
+					}
+				})
+
+				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,4 @@
 /* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import type { TSESTree } from "@typescript-eslint/utils"
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils"
 
 const createRule = ESLintUtils.RuleCreator(

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

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

package/src/realtime-react/realtime-context.tsx

@@ -1,5 +1,5 @@
 import { useI } from "atom.io/react"
-import type { RoomSocketInterface } from "atom.io/realtime/shared-room-store"
+import type { RoomSocketInterface } from "atom.io/realtime"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 import type { Socket } from "socket.io-client"

package/src/struct/micro.ts

@@ -1,7 +1,6 @@
+import type { Flat } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
 
-import type { Flat } from "../internal/utility-types"
-
 export type IndexOf<
 	T extends readonly unknown[],
 	E,

package/dist/shared-room-store-ZPGD_PIR.d.ts

@@ -1,28 +0,0 @@
-import { JoinToken, MutableAtomToken, ReadonlyPureSelectorFamilyToken } from "atom.io";
-import { UList } from "atom.io/transceivers/u-list";
-
-//#region src/realtime/realtime-key-types.d.ts
-type SocketKey = `socket::${string}`;
-declare const isSocketKey: (key: string) => key is SocketKey;
-type UserKey = `user::${string}`;
-declare const isUserKey: (key: string) => key is UserKey;
-type RoomKey = `room::${string}`;
-declare const isRoomKey: (key: string) => key is RoomKey;
-//#endregion
-//#region src/realtime/shared-room-store.d.ts
-type RoomSocketInterface<RoomNames extends string> = {
-  createRoom: (roomName: RoomNames) => void;
-  joinRoom: (roomKey: string) => void;
-  [leaveRoom: `leaveRoom:${string}`]: () => void;
-  [deleteRoom: `deleteRoom:${string}`]: () => void;
-};
-declare const roomKeysAtom: MutableAtomToken<UList<string>>;
-type UserInRoomMeta = {
-  enteredAtEpoch: number;
-};
-declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`>;
-declare const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<MutableAtomToken<UList<RoomKey>>[], UserKey>;
-//#endregion
-export { usersInMyRoomView as a, SocketKey as c, isSocketKey as d, isUserKey as f, roomKeysAtom as i, UserKey as l, RoomSocketInterface as n, usersInRooms as o, UserInRoomMeta as r, RoomKey as s, DEFAULT_USER_IN_ROOM_META as t, isRoomKey as u };
-//# sourceMappingURL=shared-room-store-ZPGD_PIR.d.ts.map

package/dist/shared-room-store-ZPGD_PIR.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-room-store-ZPGD_PIR.d.ts","names":["roomKeysAtom: MutableAtomToken<UList<string>>","DEFAULT_USER_IN_ROOM_META: UserInRoomMeta","usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`>","usersInMyRoomView: ReadonlyPureSelectorFamilyToken<\n\tMutableAtomToken<UList<RoomKey>>[],\n\tUserKey\n>"],"sources":["../src/realtime/realtime-key-types.ts","../src/realtime/shared-room-store.ts"],"sourcesContent":[],"mappings":";;;;KAAY,SAAA;cACC,qCAAoC;KAGrC,OAAA;cACC,mCAAkC;AALnC,KAQA,OAAA,GARA,SAAA,MAAA,EAAA;AACC,cAQA,SARoC,EAAA,CAAA,GAAA,EAAA,MAAA,EAAA,GAAA,GAAA,IAQF,OARE;;;KCcrC;EDfZ,UAAY,EAAA,CAAA,QAAA,ECgBY,SDhBZ,EAAA,GAAA,IAAA;EACZ,QAAa,EAAA,CAAA,OAAoC,EAAA,MAAA,EAAA,GAAA,IAAA;EAGjD,CAAA,SAAY,EAAA,aAAA,MAAA,EAAA,CAAA,EAAA,GAAA,GAAA,IAAA;EACZ,CAAA,UAAa,EAAA,cAAkC,MAAA,EAAA,CAAA,EAAA,GAAA,GAAA,IAAA;AAG/C,CAAA;AACa,cCaAA,YDbkC,ECapB,gBDboB,CCaH,KDbG,CAAA,MAAA,CAAA,CAAA;KCkBnC,cAAA;;;AAZA,cAeCC,yBAfD,EAe4B,cAdhB;AAMXD,cAWAE,YAX+B,EAWjB,SAXA,CAAA,MAAA,EAWkB,OAXlB,EAAA,MAAA,EAWmC,OAXnC,EAAA,KAAA,CAAA;AAKf,cAeCC,iBAfD,EAeoB,+BAfpB,CAgBX,gBAhBW,CAgBM,KAhBN,CAgBY,OAhBZ,CAAA,CAAA,EAAA,EAiBX,OAjBW,CAAA"}

package/dist/utility-types-BRPuC_bI.d.ts

@@ -1,10 +0,0 @@
-//#region src/internal/utility-types.d.ts
-type Fn = (...parameters: any[]) => any;
-type Ctor<T> = new (...args: any[]) => T;
-type Flat<R extends { [K in PropertyKey]: any }> = { [K in keyof R]: R[K] };
-type Count<N extends number, A extends any[] = []> = [...A, any][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
-type Each<E extends any[]> = { [P in Count<E[`length`]>]: E[P] };
-type Refinement<A, B extends A> = (a: A) => a is B;
-//#endregion
-export { Fn as a, Flat as i, Ctor as n, Refinement as o, Each as r, Count as t };
-//# sourceMappingURL=utility-types-BRPuC_bI.d.ts.map

package/dist/utility-types-BRPuC_bI.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility-types-BRPuC_bI.d.ts","names":[],"sources":["../src/internal/utility-types.ts"],"sourcesContent":[],"mappings":";KAAY,EAAA;AAAA,KAEA,IAFA,CAAA,CAAA,CAAA,GAAA,KAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAEkC,CAFlC;AAEA,KAEA,IAFA,CAAA,UAAkC,QAEX,WAFW,GAAA,GAAA,EAAA,CAAA,GAAA,QAAA,MAGjC,CAHiC,GAG7B,CAH6B,CAG3B,CAH2B,CAAA,EAAA;AAElC,KAIA,KAJA,CAAuB,UAAA,MAAA,EACtB,UAAA,GAAA,EAAA,GAAA,EAAA,CAAI,GAAA,CAAA,GAIb,CAJa,EAAA,GAAA,CAAA,CAAA,QAAA,CAAA,SAMG,CANH,GAOd,CAPc,CAAA,QAAA,CAAA,GAQd,CARc,CAAA,QAAA,CAAA,GAQA,KARA,CAQM,CARN,EAAA,CAAA,GAQa,CARb,EAAA,GAAA,CAAA,CAAA;AAAE,KAUP,IAVO,CAAA,UAAA,GAAA,EAAA,CAAA,GAAA,QAWZ,KAXY,CAWN,CAXM,CAAA,QAAA,CAAA,CAAA,GAWS,CAXT,CAWW,CAXX,CAAA,EAAA;AAAA,KAcP,UAdO,CAGnB,CAAA,EACI,UAUgC,CAVhC,CAEgB,GAAA,CAAA,CAAA,EAQyB,CARzB,EAAA,GAAA,CAAA,IAQoC,CARpC"}