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

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);
-    });
-  });
-});

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

@@ -1,202 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { Cubit, Blac } from '@blac/core';
-import useBloc from '../useBloc';
-
-interface TestState {
-  count: number;
-  name: string;
-  unused: string;
-}
-
-class TestCubit extends Cubit<TestState> {
-  static isolated = true; // Make it isolated to avoid test interference
-
-  constructor() {
-    super({ count: 0, name: 'Alice', unused: 'not-used' });
-  }
-
-  increment = () => {
-    this.emit({ ...this.state, count: this.state.count + 1 });
-  };
-
-  changeName = (name: string) => {
-    this.emit({ ...this.state, name });
-  };
-
-  changeUnused = (value: string) => {
-    this.emit({ ...this.state, unused: value });
-  };
-}
-
-describe('useBloc dependency tracking', () => {
-  it('should only track properties accessed during current render', () => {
-    let renderCount = 0;
-    let accessedProperties: string[] = [];
-
-    const { result, rerender } = renderHook(() => {
-      const [state, cubit] = useBloc(TestCubit);
-      renderCount++;
-
-      // Reset tracked properties for this render
-      accessedProperties = [];
-
-      // First few renders: access both count and name
-      if (renderCount <= 2) {
-        // Access count and name
-        void state.count;
-        void state.name;
-        accessedProperties = ['count', 'name'];
-      } else {
-        // Later renders: only access count
-        void state.count;
-        accessedProperties = ['count'];
-      }
-
-      return { state, cubit, accessedProperties };
-    });
-
-    // Initial render - accessing count and name
-    expect(renderCount).toBe(1);
-    expect(result.current.accessedProperties).toEqual(['count', 'name']);
-
-    // Change name - should trigger re-render since we're tracking it
-    act(() => {
-      result.current.cubit.changeName('Bob');
-    });
-    expect(renderCount).toBe(2);
-    expect(result.current.state.name).toBe('Bob');
-
-    // Force a re-render (this will be render #3, where we stop accessing name)
-    rerender();
-    expect(renderCount).toBe(3);
-    expect(result.current.accessedProperties).toEqual(['count']); // Only accessing count now
-
-    // Change name again - should NOT trigger re-render since we're no longer tracking it
-    const prevRenderCount = renderCount;
-    act(() => {
-      result.current.cubit.changeName('Charlie');
-    });
-
-    // Render count should not increase
-    expect(renderCount).toBe(prevRenderCount);
-    // But state should still be updated if we check it
-    expect(result.current.cubit.state.name).toBe('Charlie');
-
-    // Change count - should trigger re-render since we're still tracking it
-    act(() => {
-      result.current.cubit.increment();
-    });
-    expect(renderCount).toBe(prevRenderCount + 1);
-    expect(result.current.state.count).toBe(1);
-  });
-
-  it('should not re-render when non-accessed properties change', () => {
-    let renderCount = 0;
-
-    const { result } = renderHook(() => {
-      const [state, cubit] = useBloc(TestCubit);
-      renderCount++;
-
-      // Only access count, never access unused
-      void state.count;
-
-      return { state, cubit };
-    });
-
-    expect(renderCount).toBe(1);
-
-    // Change unused property - should NOT trigger re-render
-    act(() => {
-      result.current.cubit.changeUnused('changed');
-    });
-
-    // Should not re-render
-    expect(renderCount).toBe(1);
-
-    // The component shouldn't re-render, so we can't check the state through result.current
-    // This is the expected behavior - component doesn't see changes to untracked properties
-  });
-
-  it('should track nested property access correctly', () => {
-    interface NestedState {
-      user: {
-        profile: {
-          name: string;
-          age: number;
-        };
-      };
-      settings: {
-        theme: string;
-      };
-    }
-
-    class NestedCubit extends Cubit<NestedState> {
-      static isolated = true;
-
-      constructor() {
-        super({
-          user: {
-            profile: {
-              name: 'Alice',
-              age: 25,
-            },
-          },
-          settings: {
-            theme: 'light',
-          },
-        });
-      }
-
-      updateName = (name: string) => {
-        this.emit({
-          ...this.state,
-          user: {
-            ...this.state.user,
-            profile: {
-              ...this.state.user.profile,
-              name,
-            },
-          },
-        });
-      };
-
-      updateTheme = (theme: string) => {
-        this.emit({
-          ...this.state,
-          settings: {
-            ...this.state.settings,
-            theme,
-          },
-        });
-      };
-    }
-
-    let renderCount = 0;
-
-    const { result } = renderHook(() => {
-      const [state, cubit] = useBloc(NestedCubit);
-      renderCount++;
-
-      // Only access user.profile.name
-      void state.user.profile.name;
-
-      return { state, cubit };
-    });
-
-    expect(renderCount).toBe(1);
-
-    // Change theme - should NOT trigger re-render
-    act(() => {
-      result.current.cubit.updateTheme('dark');
-    });
-    expect(renderCount).toBe(1);
-
-    // Change name - should trigger re-render
-    act(() => {
-      result.current.cubit.updateName('Bob');
-    });
-    expect(renderCount).toBe(2);
-    expect(result.current.state.user.profile.name).toBe('Bob');
-  });
-});

package/src/index.ts

@@ -1,3 +0,0 @@
-export { default as useBloc } from './useBloc';
-export { default as useBlocNext } from './useBloc';
-export { default as useExternalBlocStore } from './useExternalBlocStore';