"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h2: "h2", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }; return _jsxs(_Fragment, { children: [_jsx(_components.p, { children: "TypeScript has become an essential tool for React developers, providing type safety, better IDE support, and improved code maintainability. In this guide, we'll explore the best practices that will help you write better TypeScript code in your React applications." }), "\n", _jsx(_components.h2, { children: "Why TypeScript with React?" }), "\n", _jsx(_components.p, { children: "Before diving into best practices, let's understand why TypeScript is so valuable for React development:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Type Safety" }), " - Catch errors at compile time instead of runtime"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Better IDE Support" }), " - Enhanced autocomplete, refactoring, and navigation"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Self-Documenting Code" }), " - Types serve as inline documentation"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Improved Refactoring" }), " - Safely rename and restructure code"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Team Collaboration" }), " - Clear contracts between components and functions"] }), "\n"] }), "\n", _jsx(_components.h2, { children: "Component Type Definitions" }), "\n", _jsx(_components.h3, { children: "Functional Components" }), "\n", _jsx(_components.p, { children: "Always type your functional components properly. Define clear interfaces for your props and use React.FC for functional components:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "import React from \"react\";\n\ninterface ButtonProps {\n children: React.ReactNode;\n onClick: () => void;\n variant?: \"primary\" | \"secondary\";\n disabled?: boolean;\n}\n\nconst Button = ({\n children,\n onClick,\n variant = \"primary\",\n disabled = false,\n}: ButtonProps) => {\n return (\n \n {children}\n \n );\n};\n" }) }), "\n", _jsx(_components.h3, { children: "Props with Children" }), "\n", _jsx(_components.p, { children: "When working with components that accept children, always type the children prop as React.ReactNode to ensure compatibility with all valid React children types:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "interface CardProps {\n title: string;\n children: React.ReactNode;\n className?: string;\n}\n\nconst Card = ({ title, children, className }: CardProps) => {\n return (\n

{title}

\n {children}\n

\n );\n};\n" }) }), "\n", _jsx(_components.h2, { children: "Advanced Prop Patterns" }), "\n", _jsx(_components.h3, { children: "Generic Components" }), "\n", _jsx(_components.p, { children: "Generic components allow you to create reusable components that work with different data types while maintaining type safety. This is particularly useful for list components, form components, and data display components:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "interface ListProps {\n items: T[];\n renderItem: (item: T, index: number) => React.ReactNode;\n keyExtractor: (item: T) => string | number;\n}\n\nfunction List({ items, renderItem, keyExtractor }: ListProps) {\n return (\n

{renderItem(item, index)}

\n );\n}\n" }) }), "\n", _jsx(_components.h3, { children: "Discriminated Unions" }), "\n", _jsx(_components.p, { children: "Use discriminated unions for complex prop combinations where certain props should only be used together. This helps prevent invalid prop combinations at compile time:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "type ButtonProps =\n | {\n variant: \"link\";\n href: string;\n onClick?: never;\n }\n | {\n variant: \"button\";\n href?: never;\n onClick: () => void;\n };\n\nconst Button = (props: ButtonProps & { children: React.ReactNode }) => {\n if (props.variant === \"link\") {\n return {props.children};\n }\n\n return ;\n};\n" }) }), "\n", _jsx(_components.h2, { children: "Hooks and State Management" }), "\n", _jsx(_components.h3, { children: "Custom Hooks" }), "\n", _jsx(_components.p, { children: "When creating custom hooks, always provide proper return types. This makes your hooks more predictable and easier to use across your application:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "import { useState, useCallback, useEffect } from \"react\";\n\ninterface UseApiResult {\n data: T | null;\n loading: boolean;\n error: string | null;\n refetch: () => void;\n}\n\nfunction useApi(url: string): UseApiResult {\n const [data, setData] = useState(null);\n const [loading, setLoading] = useState(true);\n const [error, setError] = useState(null);\n\n const fetchData = useCallback(async () => {\n try {\n setLoading(true);\n setError(null);\n const response = await fetch(url);\n\n if (!response.ok) {\n throw new Error(\"HTTP error! status: \" + response.status);\n }\n\n const result = await response.json();\n setData(result);\n } catch (err) {\n setError(err instanceof Error ? err.message : \"An error occurred\");\n } finally {\n setLoading(false);\n }\n }, [url]);\n\n useEffect(() => {\n fetchData();\n }, [fetchData]);\n\n return { data, loading, error, refetch: fetchData };\n}\n" }) }), "\n", _jsx(_components.h3, { children: "State with Complex Types" }), "\n", _jsx(_components.p, { children: "For complex state objects, define clear interfaces that describe the shape of your state. This helps with debugging and makes your code more maintainable:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "interface User {\n id: number;\n name: string;\n email: string;\n role: \"admin\" | \"user\" | \"moderator\";\n}\n\ninterface AppState {\n user: User | null;\n isAuthenticated: boolean;\n preferences: {\n theme: \"light\" | \"dark\";\n language: string;\n };\n}\n\nconst initialState: AppState = {\n user: null,\n isAuthenticated: false,\n preferences: {\n theme: \"light\",\n language: \"en\",\n },\n};\n" }) }), "\n", _jsx(_components.h2, { children: "Type Utilities" }), "\n", _jsx(_components.h3, { children: "Utility Types" }), "\n", _jsx(_components.p, { children: "TypeScript provides several utility types that can help you create complex types more easily:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "// Partial - Makes all properties in T optional\nfunction updateUser(user: User, fieldsToUpdate: Partial): User {\n return { ...user, ...fieldsToUpdate };\n}\n\n// Pick - Picks a set of properties from T\ntype UserPreview = Pick;\n\n// Omit - Removes properties from T\ntype UserWithoutEmail = Omit;\n\n// Record - Creates an object type with keys of type K and values of type T\ntype UserRoles = Record;\n" }) }), "\n", _jsx(_components.h3, { children: "Type Guards" }), "\n", _jsx(_components.p, { children: "Use type guards to narrow down types in conditional blocks:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-typescript", children: "function isAdmin(user: User): user is User & { role: \"admin\" } {\n return user.role === \"admin\";\n}\n\nfunction renderAdminDashboard(user: User) {\n if (isAdmin(user)) {\n // TypeScript knows user.role is 'admin' here\n return ;\n }\n return ;\n}\n" }) }), "\n", _jsx(_components.h2, { children: "Best Practices" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Always Define Return Types" }), " - Explicitly define return types for functions and components"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Use Type Inference" }), " - Let TypeScript infer types when they're obvious"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Avoid 'any' Type" }), " - Use more specific types or 'unknown' instead"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Use Const Assertions" }), " - For literal types that shouldn't change"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Leverage TypeScript's Strict Mode" }), " - Enable all strict type checking options in tsconfig.json"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Document Complex Types" }), " - Add JSDoc comments for complex types and functions"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Use Type-Only Imports" }), " - For types that are only used for type annotations"] }), "\n"] }), "\n", _jsx(_components.h2, { children: "Conclusion" }), "\n", _jsx(_components.p, { children: "TypeScript brings significant benefits to React development by adding static typing to your components and application logic. By following these best practices, you can write more maintainable, self-documenting code that catches errors at compile time rather than runtime. Start incorporating these patterns into your React applications to take full advantage of TypeScript's powerful type system." })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent };