@blac/react 2.0.0-rc-16 → 2.0.0-rc.0

package/src/__tests__/useBloc.proxyConfig.test.tsx

@@ -1,228 +0,0 @@
-import { Blac, Cubit } from '@blac/core';
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import useBloc from '../useBloc';
-
-interface TestState {
-  count: number;
-  nested: {
-    value: string;
-  };
-}
-
-class TestCubit extends Cubit<TestState> {
-  constructor() {
-    super({ count: 0, nested: { value: 'initial' } });
-  }
-
-  increment = () => {
-    this.emit({ ...this.state, count: this.state.count + 1 });
-  };
-
-  updateNested = () => {
-    this.emit({ ...this.state, nested: { value: 'updated' } });
-  };
-}
-
-describe('useBloc with proxy tracking config', () => {
-  const originalConfig = { ...Blac.config };
-
-  beforeEach(() => {
-    Blac.resetInstance();
-  });
-
-  afterEach(() => {
-    Blac.setConfig(originalConfig);
-    Blac.resetInstance();
-  });
-
-  describe('when proxyDependencyTracking is enabled (default)', () => {
-    beforeEach(() => {
-      Blac.setConfig({ proxyDependencyTracking: true });
-    });
-
-    it('should only re-render when accessed properties change', () => {
-      const { result } = renderHook(() => useBloc(TestCubit));
-      const renderSpy = vi.fn();
-
-      // Access only count in render
-      renderHook(() => {
-        const [state] = useBloc(TestCubit);
-        renderSpy(state.count);
-        return state.count;
-      });
-
-      expect(renderSpy).toHaveBeenCalledTimes(1);
-      expect(renderSpy).toHaveBeenCalledWith(0);
-
-      // Update nested value (not accessed)
-      act(() => {
-        result.current[1].updateNested();
-      });
-
-      // Should not re-render since nested.value wasn't accessed
-      expect(renderSpy).toHaveBeenCalledTimes(1);
-
-      // Update count (accessed property)
-      act(() => {
-        result.current[1].increment();
-      });
-
-      // Should re-render since count was accessed
-      expect(renderSpy).toHaveBeenCalledTimes(2);
-      expect(renderSpy).toHaveBeenLastCalledWith(1);
-    });
-  });
-
-  describe('when proxyDependencyTracking is disabled', () => {
-    beforeEach(() => {
-      Blac.setConfig({ proxyDependencyTracking: false });
-    });
-
-    it('should re-render on any state change', () => {
-      const { result } = renderHook(() => useBloc(TestCubit));
-      const renderSpy = vi.fn();
-
-      // Access only count in render
-      renderHook(() => {
-        const [state] = useBloc(TestCubit);
-        renderSpy(state.count);
-        return state.count;
-      });
-
-      expect(renderSpy).toHaveBeenCalledTimes(1);
-      expect(renderSpy).toHaveBeenCalledWith(0);
-
-      // Update nested value (not accessed)
-      act(() => {
-        result.current[1].updateNested();
-      });
-
-      // Should re-render even though nested.value wasn't accessed
-      expect(renderSpy).toHaveBeenCalledTimes(2);
-      expect(renderSpy).toHaveBeenLastCalledWith(0); // count didn't change
-
-      // Update count
-      act(() => {
-        result.current[1].increment();
-      });
-
-      // Should re-render
-      expect(renderSpy).toHaveBeenCalledTimes(3);
-      expect(renderSpy).toHaveBeenLastCalledWith(1);
-    });
-
-    it('should still respect manual dependencies when provided', () => {
-      const renderSpy = vi.fn();
-
-      const { result } = renderHook(() =>
-        useBloc(TestCubit, {
-          dependencies: (bloc) => [bloc.state.count],
-        }),
-      );
-
-      // Create another hook that tracks renders
-      renderHook(() => {
-        const [state] = useBloc(TestCubit, {
-          dependencies: (bloc) => [bloc.state.count],
-        });
-        renderSpy(state);
-        return state;
-      });
-
-      expect(renderSpy).toHaveBeenCalledTimes(1);
-
-      // Update nested value
-      act(() => {
-        result.current[1].updateNested();
-      });
-
-      // Should not re-render since dependencies only include count
-      expect(renderSpy).toHaveBeenCalledTimes(1);
-
-      // Update count
-      act(() => {
-        result.current[1].increment();
-      });
-
-      // Should re-render since count is in dependencies
-      expect(renderSpy).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('runtime config changes', () => {
-    it('should respect config changes for new hooks', () => {
-      // Start with proxy tracking enabled
-      Blac.setConfig({ proxyDependencyTracking: true });
-
-      // Create a new cubit instance for this test to avoid interference
-      class TestCubit2 extends Cubit<TestState> {
-        constructor() {
-          super({ count: 0, nested: { value: 'initial' } });
-        }
-
-        increment = () => {
-          this.emit({ ...this.state, count: this.state.count + 1 });
-        };
-
-        updateNested = () => {
-          this.emit({ ...this.state, nested: { value: 'updated' } });
-        };
-      }
-
-      const renderSpy1 = vi.fn();
-
-      const { result: result1 } = renderHook(() => {
-        const [state, bloc] = useBloc(TestCubit2);
-        renderSpy1(state.count);
-        return [state, bloc] as const;
-      });
-
-      expect(renderSpy1).toHaveBeenCalledTimes(1);
-
-      // Update nested value
-      act(() => {
-        result1.current[1].updateNested();
-      });
-
-      // Should not re-render since nested.value wasn't accessed (proxy tracking enabled)
-      expect(renderSpy1).toHaveBeenCalledTimes(1);
-
-      // Change config for future hooks
-      Blac.setConfig({ proxyDependencyTracking: false });
-
-      // Create new cubit class to ensure fresh instance
-      class TestCubit3 extends Cubit<TestState> {
-        constructor() {
-          super({ count: 0, nested: { value: 'initial' } });
-        }
-
-        increment = () => {
-          this.emit({ ...this.state, count: this.state.count + 1 });
-        };
-
-        updateNested = () => {
-          this.emit({ ...this.state, nested: { value: 'updated' } });
-        };
-      }
-
-      // Create new hook after config change
-      const renderSpy2 = vi.fn();
-      const { result: result2 } = renderHook(() => {
-        const [state, bloc] = useBloc(TestCubit3);
-        renderSpy2(state.count);
-        return [state, bloc] as const;
-      });
-
-      expect(renderSpy2).toHaveBeenCalledTimes(1);
-
-      // Update nested value on the new cubit
-      act(() => {
-        result2.current[1].updateNested();
-      });
-
-      // Should re-render even though nested.value wasn't accessed (proxy tracking disabled)
-      expect(renderSpy2).toHaveBeenCalledTimes(2);
-    });
-  });
-});

package/src/__tests__/useBloc.staticProps.test.tsx

@@ -1,297 +0,0 @@
-import { Blac, Cubit } from '@blac/core';
-import { renderHook } from '@testing-library/react';
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import useBloc from '../useBloc';
-
-// Test components
-interface UserDetailsProps {
-  userId: string;
-  page: number;
-}
-
-interface UserDetailsState {
-  user: { id: string; name: string } | null;
-  loading: boolean;
-  page: number;
-}
-
-class UserDetailsCubit extends Cubit<UserDetailsState> {
-  props: ConstructorParameters<typeof UserDetailsCubit>[0];
-
-  constructor(props: UserDetailsProps) {
-    super({ user: null, loading: false, page: props.page });
-    this.props = props;
-  }
-
-  loadUser = () => {
-    this.emit({ ...this.state, loading: true });
-    // Simulate API call
-    setTimeout(() => {
-      this.emit({
-        ...this.state,
-        user: { id: this.props!.userId, name: `User ${this.props!.userId}` },
-        loading: false,
-      });
-    }, 10);
-  };
-}
-
-interface SearchProps {
-  query: string;
-  filters?: { category?: string; minPrice?: number; tags?: string[] };
-}
-
-interface SearchState {
-  results: string[];
-  loading: boolean;
-}
-
-class SearchCubit extends Cubit<SearchState> {
-  constructor(props: SearchProps) {
-    super({ results: [], loading: false });
-  }
-}
-
-describe('useBloc staticProps integration', () => {
-  beforeEach(() => {
-    Blac.resetInstance();
-    vi.clearAllMocks();
-  });
-
-  describe('staticProps with instanceId', () => {
-    it('should use explicit instanceId when provided with staticProps', () => {
-      const { result: result1 } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user123', page: 1 },
-          instanceId: 'user123',
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user123', page: 2 }, // Different page
-          instanceId: 'user123', // Same instanceId
-        }),
-      );
-
-      // Both should have the same instanceId
-      expect(result1.current[1]._id).toBe('user123');
-      expect(result2.current[1]._id).toBe('user123');
-
-      // Note: In React Testing Library, each renderHook creates a separate component tree,
-      // so they won't share the same instance. In a real app, they would.
-      expect(result1.current[1]._id).toBe(result2.current[1]._id);
-    });
-
-    it('should create different instances with different instanceIds', () => {
-      const { result: result1 } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user123', page: 1 },
-          instanceId: 'user123',
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user456', page: 1 },
-          instanceId: 'user456',
-        }),
-      );
-
-      // Should have different IDs
-      expect(result1.current[1]._id).toBe('user123');
-      expect(result2.current[1]._id).toBe('user456');
-      expect(result1.current[1]._id).not.toBe(result2.current[1]._id);
-    });
-  });
-
-  describe('staticProps without instanceId (auto-generation)', () => {
-    it('should generate instanceId from primitive staticProps values', () => {
-      const { result: result1 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: { query: 'test', filters: { category: 'books' } },
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: { query: 'test', filters: { category: 'movies' } },
-        }),
-      );
-
-      // Should have generated ID from the query primitive
-      expect(result1.current[1]._id).toBe('query:test');
-      expect(result2.current[1]._id).toBe('query:test');
-
-      // They have the same generated ID
-      expect(result1.current[1]._id).toBe(result2.current[1]._id);
-    });
-
-    it('should create different instances for different primitive values', () => {
-      const { result: result1 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: { query: 'test1' },
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: { query: 'test2' },
-        }),
-      );
-
-      // Should have different generated IDs
-      expect(result1.current[1]._id).toBe('query:test1');
-      expect(result2.current[1]._id).toBe('query:test2');
-      expect(result1.current[1]._id).not.toBe(result2.current[1]._id);
-    });
-
-    it('should ignore non-primitive values when generating instanceId', () => {
-      const filters = { category: 'books', tags: ['fiction', 'bestseller'] };
-
-      const { result: result1 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: { query: 'test', filters }, // filters has an array
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(SearchCubit, {
-          staticProps: {
-            query: 'test',
-            filters: { ...filters, tags: ['different'] },
-          },
-        }),
-      );
-
-      // Both should generate the same ID (only 'query' is used)
-      expect(result1.current[1]._id).toBe('query:test');
-      expect(result2.current[1]._id).toBe('query:test');
-    });
-  });
-
-  describe('InstanceId usage', () => {
-    it('should use instanceId option', () => {
-      const { result } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user123', page: 1 },
-          instanceId: 'custom-id',
-        }),
-      );
-
-      expect(result.current[1]._id).toBe('custom-id');
-    });
-
-    it('should use instanceId option with static props', () => {
-      const { result } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'user123', page: 1 },
-          instanceId: 'user123',
-        }),
-      );
-
-      const [state, bloc] = result.current;
-      expect(state.page).toBe(1);
-      expect(bloc).toBeDefined();
-      expect(bloc._id).toBe('user123');
-    });
-
-    it('should use explicit instanceId when provided', () => {
-      const { result } = renderHook(() =>
-        useBloc(UserDetailsCubit, {
-          staticProps: { userId: 'new', page: 2 },
-          instanceId: 'new-id',
-        }),
-      );
-
-      // Should use the instanceId
-      expect(result.current[1]._id).toBe('new-id');
-
-      // Should use staticProps
-      expect(result.current[1].props).toEqual({ userId: 'new', page: 2 });
-    });
-  });
-
-  describe('Complex scenarios', () => {
-    it('should handle mixed primitive types in staticProps', () => {
-      interface ConfigProps {
-        enabled: boolean;
-        maxRetries: number;
-        apiKey: string;
-        debugInfo?: { level: string };
-      }
-
-      class ConfigCubit extends Cubit<{ config: ConfigProps | null }> {
-        constructor(props: ConfigProps) {
-          super({ config: props });
-        }
-      }
-
-      const { result: result1 } = renderHook(() =>
-        useBloc(ConfigCubit, {
-          staticProps: {
-            enabled: true,
-            maxRetries: 3,
-            apiKey: 'abc123',
-            debugInfo: { level: 'verbose' }, // This should be ignored
-          },
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(ConfigCubit, {
-          staticProps: {
-            enabled: true,
-            maxRetries: 3,
-            apiKey: 'abc123',
-            debugInfo: { level: 'quiet' }, // Different object, but should still match
-          },
-        }),
-      );
-
-      // Should generate the same ID from primitives
-      const expectedId = 'apiKey:abc123|enabled:true|maxRetries:3';
-      expect(result1.current[1]._id).toBe(expectedId);
-      expect(result2.current[1]._id).toBe(expectedId);
-    });
-
-    it('should handle null and undefined in staticProps', () => {
-      interface OptionalProps {
-        required: string;
-        optional?: string;
-        nullable: string | null;
-      }
-
-      class OptionalCubit extends Cubit<{ data: any }> {
-        constructor(props: OptionalProps) {
-          super({ data: props });
-        }
-      }
-
-      const { result: result1 } = renderHook(() =>
-        useBloc(OptionalCubit, {
-          staticProps: {
-            required: 'test',
-            optional: undefined,
-            nullable: null,
-          },
-        }),
-      );
-
-      const { result: result2 } = renderHook(() =>
-        useBloc(OptionalCubit, {
-          staticProps: {
-            required: 'test',
-            optional: undefined,
-            nullable: null,
-          },
-        }),
-      );
-
-      // Should generate the same ID including null/undefined
-      const expectedId = 'nullable:null|optional:undefined|required:test';
-      expect(result1.current[1]._id).toBe(expectedId);
-      expect(result2.current[1]._id).toBe(expectedId);
-    });
-  });
-});