gistfile1.txt

# TypeScript Style Guide (No Interfaces, Classes, or Enums)

## 1. General Principles
✅ Prefer **type aliases** over `interface`.
✅ Use **functional programming** principles.
✅ Avoid **OOP constructs** like `class`, `interface`, and `enum`.
✅ Prefer **tuples, records, and discriminated unions**.
✅ Use `const` and **immutability** wherever possible.

---

## 2. File Naming & Conventions
✅ Use **PascalCase** for components and types.
✅ Use **camelCase** for functions, variables, and hooks.
✅ Use **SCREAMING_SNAKE_CASE** for constants.
✅ Keep **index.ts** for module re-exports.
✅ Group related files in folders.

### 📂 **Recommended Folder Structure**
```
/src
  /components
    /Button
      index.ts          # Exports Button for cleaner imports
      Button.ts         # Main component logic
      Button.styles.ts  # Styles (if using styled-components or similar)
      Button.test.ts    # Unit tests
      Button.stories.ts # Storybook stories
  /hooks
    useAuth.ts         # Custom hooks (camelCase)
    useTheme.ts
  /utils
    formatDate.ts      # Utility functions (camelCase)
    fetchData.ts
  /constants
    API_ENDPOINTS.ts   # Constants (SCREAMING_SNAKE_CASE)
    COLORS.ts
  /types
    userTypes.ts       # Shared type definitions (PascalCase for types)
```

### ✅ **Example Import Structure**
```ts
import { Button } from "@/components/Button";
import { useAuth } from "@/hooks/useAuth";
import { formatDate } from "@/utils/formatDate";
import { API_ENDPOINTS } from "@/constants/API_ENDPOINTS";
```

---

## 3. Type Definitions
### ❌ **Avoid Interfaces**  
✅ **Use `type` instead**
```ts
// ❌ Bad: Using interfaces
interface User {
  id: number;
  name: string;
}

// ✅ Good: Using type alias
type User = {
  id: number;
  name: string;
};
```

---

## 4. No Classes
### ❌ **Avoid Classes**  
✅ **Use functions and object literals**
```ts
// ❌ Bad: Using a class
class User {
  constructor(public id: number, public name: string) {}
}

// ✅ Good: Use a factory function
const createUser = (id: number, name: string) => ({ id, name });

const user = createUser(1, "Alice");
```

---

## 5. No Enums
### ❌ **Avoid Enums**  
✅ **Use `const` objects or union types**
```ts
// ❌ Bad: Using enums
enum Status {
  Success,
  Error,
  Loading,
}

// ✅ Good: Use a union type
type Status = "success" | "error" | "loading";

// ✅ Alternative: Use a const object
const Status = {
  Success: "success",
  Error: "error",
  Loading: "loading",
} as const;

type StatusType = typeof Status[keyof typeof Status];
```

---

## 6. Immutability & Functional Programming
✅ Prefer **readonly** and **immutable structures**  
✅ Use **functional patterns** instead of mutations  
```ts
// ❌ Bad: Mutating objects
const user = { id: 1, name: "Alice" };
user.name = "Bob"; // Avoid mutating

// ✅ Good: Return a new object
const updatedUser = { ...user, name: "Bob" };
```

---

## 7. Use Readonly for Objects & Arrays
```ts
// ✅ Prevent mutation
type User = Readonly<{
  id: number;
  name: string;
}>;

const users: ReadonlyArray<User> = [
  { id: 1, name: "Alice" },
];

// ❌ This will cause a TypeScript error
users[0].name = "Bob"; // Error: Cannot assign to 'name' because it is a read-only property
```

---

## 8. Use Tuples Instead of Classes
```ts
// ❌ Bad: Using a class for a point
class Point {
  constructor(public x: number, public y: number) {}
}

// ✅ Good: Use a tuple
type Point = readonly [number, number];

const point: Point = [10, 20];
```

---

## 9. Prefer Function Composition
✅ **Avoid methods inside objects**, prefer **functions that take objects as arguments**.
```ts
// ❌ Bad: Using a method
const user = {
  name: "Alice",
  greet() {
    return `Hello, ${this.name}`;
  },
};

// ✅ Good: Function-based approach
const greet = (user: { name: string }) => `Hello, ${user.name}`;
```

---

## 10. Use Discriminated Unions Instead of Classes
```ts
// ❌ Bad: Using class inheritance
class Success {
  type = "success";
}

class Error {
  type = "error";
}

// ✅ Good: Use discriminated union
type Response = 
  | { type: "success"; data: string }
  | { type: "error"; message: string };

const handleResponse = (res: Response) => {
  if (res.type === "success") {
    console.log(res.data);
  } else {
    console.log(res.message);
  }
};
```

---

## 11. Naming Conventions
✅ Use `camelCase` for variables and functions  
✅ Use `PascalCase` for type aliases  
✅ Use `SCREAMING_SNAKE_CASE` for constants  
```ts
const MAX_USERS = 100; // ✅ Correct
const getUserData = () => {}; // ✅ Correct
type UserProfile = { name: string }; // ✅ Correct
```

---

## Conclusion
This guide enforces a **functional, immutable, and lightweight** TypeScript codebase by eliminating `interface`, `class`, and `enum`. It encourages **type aliases, discriminated unions, and object literals** for better maintainability and readability.