// ✅ Good: Explicit interface
interface UserProfile {
  name: string;
  bio?: string;
  image?: string;
}

// ❌ Avoid: Inline object types for complex structures
function updateProfile(profile: { name: string; bio?: string }) { }

// ✅ Good: Use interface instead
function updateProfile(profile: UserProfile) { }

// ❌ Avoid
function processData(data: any) { }

// ✅ Better: Use generics or unknown
function processData<T>(data: T) { }
function processData(data: unknown) { }

// ✅ Acceptable in test mocks only
const mockLogger: any = { debug: vi.fn() };

// ✅ Good: async/await for readability
async function fetchPosts(): Promise<Post[]> {
  try {
    const response = await fetch(url);
    return await response.json();
  } catch (error) {
    logger.error('API', 'Failed to fetch', error as Error);
    throw error;
  }
}

// ❌ Avoid: .then() chains
function fetchPosts(): Promise<Post[]> {
  return fetch(url)
    .then(r => r.json())
    .catch(e => { throw e; });
}

// ✅ Good: Functional component with TypeScript
interface PostCardProps {
  post: NexusPost;
  onSelect?: (id: string) => void;
}

function PostCard({ post, onSelect }: PostCardProps) {
  return (
    <div onClick={() => onSelect?.(post.id)}>
      {post.content}
    </div>
  );
}

export default PostCard;

// ✅ Good: Proper useEffect with cleanup
useEffect(() => {
  const handler = (msg: Message) => { /* ... */ };
  chrome.runtime.onMessage.addListener(handler);
  
  return () => {
    chrome.runtime.onMessage.removeListener(handler);
  };
}, []); // Empty deps = mount/unmount only

// ✅ Good: Dependencies listed
useEffect(() => {
  loadPosts();
}, [currentUrl, session]); // Re-run when these change

// ✅ Good: Local state for component-specific data
const [loading, setLoading] = useState(false);
const [posts, setPosts] = useState<Post[]>([]);

// ✅ Good: Lift state for shared data
// Parent passes down via props or context

import { describe, it, expect, vi, beforeEach } from 'vitest';

describe('generateUrlHashTag', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('should generate deterministic hash for same URL', async () => {
    const url = 'https://example.com';
    const hash1 = await generateUrlHashTag(url);
    const hash2 = await generateUrlHashTag(url);
    
    expect(hash1).toBe(hash2);
    expect(hash1).toHaveLength(10);
  });

  it('should handle errors gracefully', async () => {
    await expect(generateUrlHashTag('')).resolves.toBeDefined();
  });
});