@murky-web/typebuddy 0.1.0

package/README.md

@@ -0,0 +1,177 @@
+# TypeBuddy
+
+TypeBuddy is a utility library for type guards, parsing, and small TypeScript-first helper types. It focuses on two things:
+
+- predictable runtime helpers for common JavaScript values
+- a small type system around `Optional`, `Maybe`, and `Nullable`
+
+## Features
+
+-   runtime guards for common JavaScript values
+-   parsing helpers for strings, numbers, arrays, and URLs
+-   utility types like `Optional<T>`, `Maybe<T>`, `Nullable<T>`
+-   type-system guards like `isOptional`, `isMaybe`, `isNullable`
+-   global type opt-in through `@murky-web/typebuddy/globals`
+-   custom `oxlint` rules through `@murky-web/typebuddy/oxlint`
+-   tree-shake-friendly ESM output for frontend and backend bundles
+
+## Installation
+
+From npm:
+
+```bash
+bun add @murky-web/typebuddy
+```
+
+From JSR:
+
+```bash
+npx jsr add @murky-web/typebuddy
+```
+
+## Usage
+
+Here's an example of how to use TypeBuddy in your TypeScript project:
+
+```typescript
+import { isString, parseNumber, isUuidString, isEmptyObject } from "@murky-web/typebuddy";
+
+const value: unknown = "123";
+
+if (isString(value)) {
+    console.log(`The value is a string: ${value}`);
+}
+
+const numberValue = parseNumber(value);
+console.log(`Parsed number: ${numberValue}`);
+
+const uuid = "550e8400-e29b-41d4-a716-446655440000";
+if (isUuidString(uuid)) {
+    console.log(`The value is a valid UUID: ${uuid}`);
+}
+
+const obj = {};
+if (isEmptyObject(obj)) {
+    console.log("The object is empty");
+}
+```
+
+### Type-system guards
+
+```typescript
+import { isArray, isNullable, isOptional } from "@murky-web/typebuddy";
+import type { Nullable, Optional } from "@murky-web/typebuddy";
+
+const title: Optional<string> = "ready";
+if (isOptional(title)) {
+    throw new Error("title is missing");
+}
+
+const subtitle: Nullable<string> = "ready";
+if (isNullable(subtitle)) {
+    throw new Error("subtitle is missing");
+}
+
+// after the early guards both values are narrowed to string
+title.toUpperCase();
+subtitle.toUpperCase();
+
+const tags: Nullable<string[]> = ["a", "b"];
+if (!isArray(tags)) {
+    throw new Error("tags missing");
+}
+
+// tags is narrowed to string[]
+tags.map((tag) => tag.toUpperCase());
+```
+
+### Global types
+
+This opt-in global entry is available in the npm package surface. The JSR build
+does not expose it because JSR rejects global augmentations in published
+modules.
+
+If you want the `typebuddy` utility types globally, opt in once in your project:
+
+```typescript
+import type {} from "@murky-web/typebuddy/globals";
+```
+
+That makes these names available globally:
+
+-   `Optional`
+-   `ResolveOptional`
+-   `Maybe`
+-   `ResolveMaybe`
+-   `Nullable`
+-   `ResolveNullable`
+-   `MaybePromise`
+-   `Success`
+-   `Failed`
+-   `JsonifiedValue`
+-   `Stringified`
+
+## API
+
+### Type Checking Functions
+
+-   `isObject(value: unknown): value is object`
+-   `isBoolean(value: unknown): value is boolean`
+-   `isNull(value: unknown): value is null`
+-   `isUndefined(value: unknown): value is undefined`
+-   `isOptional<T>(value: Optional<T>): value is undefined`
+-   `isMaybe<T>(value: Maybe<T>): value is null`
+-   `isNullable<T>(value: Nullable<T>): value is null | undefined`
+-   `isFunction(value: unknown): value is Function`
+-   `isPromise(value: unknown): value is Promise<unknown>`
+-   `isError(value: unknown): value is Error`
+-   `isDate(value: unknown): value is Date`
+-   `isRegExp(value: unknown): value is RegExp`
+-   `isSymbol(value: unknown): value is symbol`
+-   `isEmptyObject(value: unknown): value is Record<string, unknown>`
+-   `isInstanceOf<T>(value: unknown, constructor: { new (...args: unknown[]): T }): value is T`
+-   `isArray<T>(value: unknown): value is T[]`
+-   `isEmptyArray<T>(value: unknown): value is T[]`
+-   `isNumber(value: unknown): value is number`
+-   `isInteger(value: unknown): value is number`
+-   `isFloat(value: unknown): value is number`
+-   `isString(value: unknown): value is string`
+-   `isUuidString(input: unknown): input is string`
+-   `isUlidString(input: unknown): input is string`
+
+### Parsing Functions
+
+-   `parseNumber<T extends number, R extends Optional<T>>(value: unknown, defaultValue?: R): ResolveOptional<T, R>`
+-   `parseInteger(value: unknown, defaultValue?: Optional<number>): Optional<number>`
+-   `parseFloat<T extends number, R extends Optional<T>>(value: unknown, defaultValue?: R): ResolveOptional<T, R>`
+-   `parseString<T extends string, R extends Optional<T>>(value: unknown, defaultValue?: R): ResolveOptional<T, R>`
+-   `parseArray<T, R extends Optional<T[]>>(value: unknown, defaultValue?: R): ResolveOptional<T[], R>`
+-   `parseDomainName<T extends string, R extends Optional<T>>(url: string, defaultValue?: R): ResolveOptional<T, R>`
+
+### Utility Functions
+
+-   `getKeys<T extends Record<string, unknown>>(object: T): Array<keyof T>`
+-   `arrayContainsCommonValue<T>(array1: T[], array2: T[]): boolean`
+-   `isEmptyString(value: unknown): boolean`
+-   `isEmptyLike(value: unknown): boolean`
+-   `hasEmptyValues(value: unknown): boolean`
+
+### Types
+
+-   `Optional<T>`
+-   `ResolveOptional<T, R>`
+-   `Maybe<T>`
+-   `ResolveMaybe<T, R>`
+-   `Nullable<T>`
+-   `ResolveNullable<T, R>`
+-   `MaybePromise<T>`
+-   `Success<T>`
+-   `Failed<T>`
+-   `JsonifiedObject<T>`
+-   `JsonifiedValue<T>`
+-   `Stringified<T>`
+
+### Tooling Entries
+
+-   `@murky-web/typebuddy/oxlint`
+-   `@murky-web/typebuddy/globals`

package/biome/index.ts

@@ -0,0 +1,6 @@
+const resolveAsset = (asset: string): string =>
+  decodeURIComponent(new URL(asset, import.meta.url).pathname);
+
+export const MaybePromiseRule: string = resolveAsset("./maybe_promise_rule.grit");
+export const OptionalRule: string = resolveAsset("./optional_rule.gritt");
+export const TryCatchAsyncRule: string = resolveAsset("./require-try-catch-async.grit");

package/biome/maybe_promise_rule.grit

@@ -0,0 +1,15 @@
+or {
+  // 1. Replace Promise with MaybePromise in return types
+  `: Promise<$type>` => `: MaybePromise<$type>`,
+
+  // 2. Wrap return values in try blocks with { value, isError: false }
+  `try { $tryBody } catch ($err) { $catchBody }` where {
+    $tryBody <: contains `return $value` and {
+      $value <: not contains `{ isError: $isErrorValue }`
+    }
+  } => `try { $tryBody <: replace `return $value` => `return { value: $value, isError: false }` } catch ($err) { $catchBody }`,
+
+  // 3. Handle empty return statements in try blocks
+  `try { $tryBody } catch ($err) { $catchBody }` where {
+    $tryBody <: contains `return;`
+  } => `try { $tryBody <: replace `return;` => `return { value: undefined, isError: false };` } catch ($err) { $catchBody }`,

package/biome/maybe_rule.grit

@@ -0,0 +1,11 @@
+or {
+  // T | null -> Maybe<T>
+  `$type | null` where {
+    $type <: not contains `null | undefined`
+  } => `Maybe<$type>`,
+
+  // T | null | undefined -> Nullable<T>
+  `$type | null | undefined` where {
+    $type <: not contains `null | undefined`
+  } => `Nullable<$type>`
+}

package/biome/nullable_rule.grit

@@ -0,0 +1,3 @@
+`$type | null | undefined` where {
+  $type <: not contains `null | undefined`
+} => `Nullable<$type>`

package/biome/optional_rule.gritt

@@ -0,0 +1,8 @@
+or {
+  // T | null -> Maybe<T>
+  `$type | null` where { $type <: not contains `null | undefined` } => `Maybe<$type>`,
+  // T | null | undefined -> Nullable<T>
+  `$type | null | undefined` where { $type <: not contains `null | undefined` } => `Nullable<$type>`,
+  // T | undefined -> Optional<T>
+  `$type | undefined` where { $type <: not contains `undefined` } => `Optional<$type>`
+}

package/biome/require-try-catch-async.grit

@@ -0,0 +1,5 @@
+or {
+  `async function $name($params) { $body }` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `async function $name($params) { try { $body } catch (err) { // handle error } }`,
+  `(async function($params) { $body })` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `(async function($params) { try { $body } catch (err) { // handle error } })`,
+  `(async ($params) => { $body })` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `(async ($params) => { try { $body } catch (err) { // handle error } })`
+}

package/dist/biome.js

@@ -0,0 +1,7 @@
+//#region biome/index.ts
+const resolveAsset = (asset) => decodeURIComponent(new URL(asset, import.meta.url).pathname);
+const MaybePromiseRule = resolveAsset("./maybe_promise_rule.grit");
+const OptionalRule = resolveAsset("./optional_rule.gritt");
+const TryCatchAsyncRule = resolveAsset("./require-try-catch-async.grit");
+//#endregion
+export { MaybePromiseRule, OptionalRule, TryCatchAsyncRule };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { arrayContainsCommonValue, fastIsArray, getKeys, hasEmptyValues, isArray, isBoolean, isDate, isEmptyArray, isEmptyLike, isEmptyObject, isEmptyString, isError, isFloat, isFunction, isInstanceOf, isInteger, isMaybe, isNull, isNullable, isNumber, isObject, isOptional, isPromise, isRegExp, isString, isSuccess, isSymbol, isUlidString, isUndefined, isUuidString, parseArray, parseDomainName, parseFloat, parseInteger, parseNumber, parseString } from "./type_helper.js";
+export { arrayContainsCommonValue, fastIsArray, getKeys, hasEmptyValues, isArray, isBoolean, isDate, isEmptyArray, isEmptyLike, isEmptyObject, isEmptyString, isError, isFloat, isFunction, isInstanceOf, isInteger, isMaybe, isNull, isNullable, isNumber, isObject, isOptional, isPromise, isRegExp, isString, isSuccess, isSymbol, isUlidString, isUndefined, isUuidString, parseArray, parseDomainName, parseFloat, parseInteger, parseNumber, parseString };

package/dist/maybe_promise_rule.grit

@@ -0,0 +1,15 @@
+or {
+  // 1. Replace Promise with MaybePromise in return types
+  `: Promise<$type>` => `: MaybePromise<$type>`,
+
+  // 2. Wrap return values in try blocks with { value, isError: false }
+  `try { $tryBody } catch ($err) { $catchBody }` where {
+    $tryBody <: contains `return $value` and {
+      $value <: not contains `{ isError: $isErrorValue }`
+    }
+  } => `try { $tryBody <: replace `return $value` => `return { value: $value, isError: false }` } catch ($err) { $catchBody }`,
+
+  // 3. Handle empty return statements in try blocks
+  `try { $tryBody } catch ($err) { $catchBody }` where {
+    $tryBody <: contains `return;`
+  } => `try { $tryBody <: replace `return;` => `return { value: undefined, isError: false };` } catch ($err) { $catchBody }`,

package/dist/maybe_rule.grit

@@ -0,0 +1,11 @@
+or {
+  // T | null -> Maybe<T>
+  `$type | null` where {
+    $type <: not contains `null | undefined`
+  } => `Maybe<$type>`,
+
+  // T | null | undefined -> Nullable<T>
+  `$type | null | undefined` where {
+    $type <: not contains `null | undefined`
+  } => `Nullable<$type>`
+}

package/dist/nullable_rule.grit

@@ -0,0 +1,3 @@
+`$type | null | undefined` where {
+  $type <: not contains `null | undefined`
+} => `Nullable<$type>`

package/dist/optional_rule.gritt

@@ -0,0 +1,8 @@
+or {
+  // T | null -> Maybe<T>
+  `$type | null` where { $type <: not contains `null | undefined` } => `Maybe<$type>`,
+  // T | null | undefined -> Nullable<T>
+  `$type | null | undefined` where { $type <: not contains `null | undefined` } => `Nullable<$type>`,
+  // T | undefined -> Optional<T>
+  `$type | undefined` where { $type <: not contains `undefined` } => `Optional<$type>`
+}

package/dist/oxlint.js

@@ -0,0 +1,18 @@
+import { rule } from "./rules/async_rule.js";
+import { rule as rule$1 } from "./rules/maybe_promise_rule.js";
+import { rule as rule$2 } from "./rules/maybe_rule.js";
+import { rule as rule$3 } from "./rules/nullable_rule.js";
+import { rule as rule$4 } from "./rules/optional_rule.js";
+//#region oxlint/index.ts
+const plugin = {
+	meta: { name: "typebuddy" },
+	rules: {
+		"prefer-maybe": rule$2,
+		"prefer-maybe-promise": rule$1,
+		"prefer-nullable": rule$3,
+		"prefer-optional": rule$4,
+		"require-try-catch": rule
+	}
+};
+//#endregion
+export { plugin as default, plugin as typebuddyOxlintPlugin };

package/dist/require-try-catch-async.grit

@@ -0,0 +1,5 @@
+or {
+  `async function $name($params) { $body }` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `async function $name($params) { try { $body } catch (err) { // handle error } }`,
+  `(async function($params) { $body })` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `(async function($params) { try { $body } catch (err) { // handle error } })`,
+  `(async ($params) => { $body })` where { $body <: not contains `try { $tryBody } catch ($err) { $catchBody }` } => `(async ($params) => { try { $body } catch (err) { // handle error } })`
+}

package/dist/rules/async_rule.js

@@ -0,0 +1,58 @@
+//#region rules/async_rule.ts
+function hasTryCatch(nodes) {
+	return nodes.some((node) => {
+		return node.type === "TryStatement";
+	});
+}
+const rule = {
+	create(context) {
+		const sourceCode = context.getSourceCode();
+		function getIndentation(node) {
+			const firstLine = sourceCode.getText(node).split("\n")[0];
+			const match = /^\s*/.exec(firstLine);
+			return match ? match[0] : "";
+		}
+		function wrapInTryCatch(node) {
+			const body = Array.isArray(node.body) ? node.body : [];
+			const indent = getIndentation(node);
+			const innerIndent = `${indent}  `;
+			return `{
+${indent}try {
+${body.map((statement) => {
+				return `${innerIndent}${sourceCode.getText(statement).replaceAll(/^\s*/gm, "")}`;
+			}).join("\n")}
+${indent}} catch (err) {
+${innerIndent}return FAILED_PROMISE;
+${indent}}
+}`;
+		}
+		function checkFunction(node) {
+			if (node.async !== true) return;
+			const bodyNode = node.body;
+			if (!bodyNode || Array.isArray(bodyNode) || bodyNode.type !== "BlockStatement") return;
+			if (hasTryCatch(Array.isArray(bodyNode.body) ? bodyNode.body : [])) return;
+			context.report({
+				node,
+				messageId: "missingTryCatch",
+				fix(fixer) {
+					return fixer.replaceText(bodyNode, wrapInTryCatch(bodyNode));
+				}
+			});
+		}
+		return {
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			ArrowFunctionExpression: checkFunction
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		type: "suggestion",
+		docs: { description: "Async functions should have a try-catch block returning FAILED_PROMISE." },
+		fixable: "code",
+		schema: [],
+		messages: { missingTryCatch: "Async functions must have a try-catch block returning FAILED_PROMISE." }
+	}
+};
+//#endregion
+export { rule };

package/dist/rules/maybe_promise_rule.js

@@ -0,0 +1,132 @@
+//#region rules/maybe_promise_rule.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value;
+}
+function isAsyncFunction(node) {
+	return node.async === true;
+}
+function hasTypeParameters(value) {
+	return isNode(value) && Array.isArray(value.params);
+}
+const rule = {
+	create(context) {
+		const sourceCode = context.getSourceCode();
+		function isTypeReference(node) {
+			return isNode(node) && node.type === "TSTypeReference";
+		}
+		function getTypeName(node) {
+			const typeName = node.typeName;
+			if (!isNode(typeName) || typeName.type !== "Identifier") return null;
+			return typeof typeName.name === "string" ? typeName.name : null;
+		}
+		function getTypeArgument(node) {
+			const typeArguments = node.typeArguments;
+			if (!hasTypeParameters(typeArguments)) return null;
+			const [firstParam] = typeArguments.params;
+			if (!isNode(firstParam)) return null;
+			return firstParam;
+		}
+		function getPromiseTypeArgument(node) {
+			if (getTypeName(node) !== "Promise") return null;
+			return getTypeArgument(node);
+		}
+		function checkReturnType(node) {
+			if (!isAsyncFunction(node)) return;
+			if (!isNode(node.returnType)) return;
+			const typeAnnotation = node.returnType.typeAnnotation;
+			if (!isTypeReference(typeAnnotation)) return;
+			if (getTypeName(typeAnnotation) !== "Promise") return;
+			const typeName = typeAnnotation.typeName;
+			context.report({
+				node: typeName,
+				messageId: "replaceWithMaybePromise",
+				fix(fixer) {
+					return fixer.replaceText(typeName, "MaybePromise");
+				}
+			});
+		}
+		function wrapReturnValue(node, isAsync, returnType) {
+			if (!isAsync) return;
+			const argument = node.argument;
+			if (!isNode(argument)) {
+				if (returnType?.type === "TSVoidKeyword") context.report({
+					node,
+					messageId: "returnVoidPromise",
+					fix(fixer) {
+						return fixer.replaceText(node, "return VOID_PROMISE");
+					}
+				});
+				return;
+			}
+			if (argument.type === "Identifier" && (argument.name === "VOID_PROMISE" || argument.name === "FAILED_PROMISE")) return;
+			if (!(argument.type === "ObjectExpression" && Array.isArray(argument.properties) && argument.properties.some((property) => isNode(property) && property.type === "Property" && isNode(property.key) && property.key.type === "Identifier" && property.key.name === "isError"))) context.report({
+				node: argument,
+				messageId: "wrapReturn",
+				fix(fixer) {
+					const argumentText = sourceCode.getText(argument);
+					return fixer.replaceText(argument, `{ value: ${argumentText}, isError: false }`);
+				}
+			});
+		}
+		function processTryCatch(node) {
+			let parent = node.parent;
+			let isAsync = false;
+			let parentFunction = null;
+			while (parent) {
+				if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") {
+					isAsync = parent.async === true;
+					parentFunction = parent;
+					break;
+				}
+				parent = parent.parent;
+			}
+			if (!isAsync || !parentFunction) return;
+			let returnType = null;
+			if (isNode(parentFunction.returnType)) {
+				const typeAnnotation = parentFunction.returnType.typeAnnotation;
+				if (isTypeReference(typeAnnotation)) returnType = getPromiseTypeArgument(typeAnnotation);
+			}
+			const blockBody = isNode(node.block) && Array.isArray(node.block.body) ? node.block.body : [];
+			for (const statement of blockBody) if (isNode(statement) && statement.type === "ReturnStatement") wrapReturnValue(statement, isAsync, returnType);
+			if (!isNode(node.handler) || !isNode(node.handler.body)) return;
+			const catchBody = Array.isArray(node.handler.body.body) ? node.handler.body.body.filter(isNode) : [];
+			if (!catchBody.some((statement) => statement.type === "ReturnStatement" && isNode(statement.argument) && statement.argument.type === "Identifier" && statement.argument.name === "FAILED_PROMISE")) context.report({
+				node: node.handler,
+				messageId: "returnFailedPromise",
+				fix(fixer) {
+					const lastStatement = catchBody.at(-1);
+					if (lastStatement?.type === "ReturnStatement" && isNode(lastStatement.argument) && lastStatement.argument.type === "ObjectExpression") return fixer.replaceText(lastStatement, "return FAILED_PROMISE");
+					const handler = node.handler;
+					if (!isNode(handler)) return null;
+					const bodyRange = handler.body;
+					if (!isNode(bodyRange) || !Array.isArray(bodyRange.range)) return null;
+					return fixer.insertTextBeforeRange([bodyRange.range[1] - 1, bodyRange.range[1] - 1], "return FAILED_PROMISE; ");
+				}
+			});
+		}
+		return {
+			FunctionDeclaration: checkReturnType,
+			FunctionExpression: checkReturnType,
+			ArrowFunctionExpression: checkReturnType,
+			TSDeclareFunction: checkReturnType,
+			TSFunctionType: checkReturnType,
+			TSMethodSignature: checkReturnType,
+			TryStatement: processTryCatch
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		type: "suggestion",
+		docs: { description: "Ensure async functions' return values follow the MaybePromise pattern." },
+		fixable: "code",
+		schema: [],
+		messages: {
+			replaceWithMaybePromise: "Use 'MaybePromise' instead of 'Promise' as the return type in async functions.",
+			wrapReturn: "Wrap return value with { value: value, isError: false }.",
+			returnVoidPromise: "Return VOID_PROMISE for async functions with Promise<void> return type.",
+			returnFailedPromise: "Return FAILED_PROMISE in catch block of async functions."
+		}
+	}
+};
+//#endregion
+export { rule };

package/dist/rules/maybe_rule.js

@@ -0,0 +1,34 @@
+//#region rules/maybe_rule.ts
+const rule = {
+	create(context) {
+		return { TSUnionType(node) {
+			const types = node.types;
+			const sourceCode = context.getSourceCode();
+			const nullType = types.find((typeNode) => typeNode.type === "TSNullKeyword");
+			const undefinedType = types.find((typeNode) => typeNode.type === "TSUndefinedKeyword");
+			const otherTypes = types.filter((typeNode) => typeNode.type !== "TSNullKeyword" && typeNode.type !== "TSUndefinedKeyword");
+			if (nullType && !undefinedType && otherTypes.length === 1) {
+				const typeText = sourceCode.getText(otherTypes[0]);
+				context.report({
+					node,
+					messageId: "useMaybe",
+					data: { type: typeText },
+					fix(fixer) {
+						return fixer.replaceText(node, `Maybe<${typeText}>`);
+					}
+				});
+			}
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Use Maybe<T> for T | null" },
+		fixable: "code",
+		schema: [],
+		messages: { useMaybe: "Use Maybe<{{type}}> instead of {{type}} | null" }
+	}
+};
+//#endregion
+export { rule };

package/dist/rules/nullable_rule.js

@@ -0,0 +1,35 @@
+//#region rules/nullable_rule.ts
+const rule = {
+	create(context) {
+		return { TSUnionType(node) {
+			const types = node.types;
+			if (types.length !== 3) return;
+			const sourceCode = context.getSourceCode();
+			const nullType = types.find((typeNode) => typeNode.type === "TSNullKeyword");
+			const undefinedType = types.find((typeNode) => typeNode.type === "TSUndefinedKeyword");
+			const otherType = types.find((typeNode) => typeNode.type !== "TSNullKeyword" && typeNode.type !== "TSUndefinedKeyword");
+			if (nullType && undefinedType && otherType) {
+				const typeText = sourceCode.getText(otherType);
+				context.report({
+					node,
+					messageId: "useNullable",
+					data: { type: typeText },
+					fix(fixer) {
+						return fixer.replaceText(node, `Nullable<${typeText}>`);
+					}
+				});
+			}
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		type: "suggestion",
+		hasSuggestions: true,
+		docs: { description: "Use Nullable<T> instead of T | null | undefined" },
+		fixable: "code",
+		schema: [],
+		messages: { useNullable: "Use Nullable<{{type}}> instead of {{type}} | null | undefined" }
+	}
+};
+//#endregion
+export { rule };

package/dist/rules/optional_rule.js

@@ -0,0 +1,31 @@
+//#region rules/optional_rule.ts
+const rule = {
+	create(context) {
+		return { TSUnionType(node) {
+			if (node.types.length !== 2) return;
+			const undefinedType = node.types.find((typeNode) => typeNode.type === "TSUndefinedKeyword");
+			const otherType = node.types.find((typeNode) => typeNode.type !== "TSUndefinedKeyword");
+			if (undefinedType && otherType) {
+				const typeText = context.getSourceCode().getText(otherType);
+				context.report({
+					node,
+					messageId: "preferOptional",
+					data: { type: typeText },
+					fix(fixer) {
+						return fixer.replaceText(node, `Optional<${typeText}>`);
+					}
+				});
+			}
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce using Optional<T> instead of T | undefined" },
+		fixable: "code",
+		schema: [],
+		messages: { preferOptional: "Use Optional<{{type}}> instead of {{type}} | undefined" }
+	}
+};
+//#endregion
+export { rule };