@blastlabs/utils 1.11.0 → 1.12.0

package/dist/components/dev/WindowSizeDisplay.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { useWindowSize } from '../../hooks/useWindowSize';
+import { useWindowSize } from '../../hooks';
 const positionStyles = {
     'top-left': { top: 16, left: 16 },
     'top-right': { top: 16, right: 16 },
@@ -13,7 +13,7 @@ const positionStyles = {
  * @example
  * ```tsx
  * // Vite 프로젝트
- * import { WindowSizeDisplay } from 'goodchuck-utils/components/dev';
+ * import { WindowSizeDisplay } from '@blastlabs/utils/components/dev';
  *
  * function App() {
  *   return (

package/dist/components/dev/ZIndexDebugger.d.ts

@@ -10,7 +10,7 @@ type Props = {
  * @example
  * ```tsx
  * // Vite 프로젝트
- * import { ZIndexDebugger } from 'goodchuck-utils/components/dev';
+ * import { ZIndexDebugger } from '@blastlabs/utils/components/dev';
  *
  * function App() {
  *   return (

package/dist/components/dev/ZIndexDebugger.js

@@ -6,7 +6,7 @@ import React, { useState, useEffect } from 'react';
  * @example
  * ```tsx
  * // Vite 프로젝트
- * import { ZIndexDebugger } from 'goodchuck-utils/components/dev';
+ * import { ZIndexDebugger } from '@blastlabs/utils/components/dev';
  *
  * function App() {
  *   return (

package/dist/components/dev/index.d.ts

@@ -5,11 +5,12 @@
  * production 환경에서는 제외하는 것을 권장합니다.
  */
 export { default as IdSelector } from './IdSelector';
+export type { IdSelectorProps, LoginInfo } from './IdSelector';
 export { default as WindowSizeDisplay } from './WindowSizeDisplay';
 export { default as DevPanel } from './DevPanel';
 export { default as ZIndexDebugger } from './ZIndexDebugger';
 export { default as ApiLogger, addApiLog, clearApiLogs } from './ApiLogger';
 export { default as FormDevTools } from './FormDevTools';
-export type { FormDevToolsProps, UseFormReturn as FormDevToolsUseFormReturn } from './FormDevTools';
+export type { FormDevToolsProps } from './FormDevTools';
 export type { ApiLogEntry } from './ApiLogger';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/dev/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dev/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,aAAa,IAAI,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AACpG,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dev/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/hooks/event/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Event Handling Hooks
+ */
+export * from './useEventListener';
+export * from './useClickOutside';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/event/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/event/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/dist/hooks/event/index.js

@@ -0,0 +1,5 @@
+/**
+ * Event Handling Hooks
+ */
+export * from './useEventListener';
+export * from './useClickOutside';

package/dist/hooks/event/useClickOutside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useClickOutside.d.ts","sourceRoot":"","sources":["../../../src/hooks/event/useClickOutside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAE,MAAM,OAAO,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACjE,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,EACjD,OAAO,GAAE,OAAc,GACtB,IAAI,CA2BN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACzE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,EACpB,OAAO,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,EACjD,OAAO,GAAE,OAAc,GACtB,IAAI,CA6BN"}

package/dist/hooks/event/useEventListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEventListener.d.ts","sourceRoot":"","sources":["../../../src/hooks/event/useEventListener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,SAAS,EAAE,MAAM,OAAO,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,cAAc,EAC7D,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,SAAS,EACnB,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC;AAER,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,mBAAmB,EAAE,CAAC,SAAS,WAAW,GAAG,cAAc,EAC1G,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,IAAI,EAChD,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EACrB,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC;AAER,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,gBAAgB,EAC/D,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,KAAK,IAAI,EAC7C,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAAC"}

package/dist/hooks/form/__tests__/useCRUDForm.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useCRUDForm.test.d.ts.map

package/dist/hooks/form/__tests__/useCRUDForm.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCRUDForm.test.d.ts","sourceRoot":"","sources":["../../../../src/hooks/form/__tests__/useCRUDForm.test.ts"],"names":[],"mappings":""}

package/dist/hooks/form/__tests__/useCRUDForm.test.js

@@ -0,0 +1,487 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { useCRUDForm } from '../useCRUDForm';
+// Mock form object
+const createMockForm = (defaultValues = {}) => ({
+    watch: vi.fn((name) => name ? defaultValues[name] : defaultValues),
+    getValues: vi.fn((name) => name ? defaultValues[name] : defaultValues),
+    setValue: vi.fn(),
+    reset: vi.fn(),
+    trigger: vi.fn().mockResolvedValue(true),
+    formState: {
+        errors: {},
+        dirtyFields: {},
+        touchedFields: {},
+        isValid: true,
+        isSubmitting: false,
+        submitCount: 0,
+        defaultValues,
+        isDirty: false,
+        isValidating: false,
+        isLoading: false,
+        isSubmitted: false,
+        isSubmitSuccessful: false,
+    },
+    handleSubmit: vi.fn((onValid) => async (e) => {
+        e?.preventDefault?.();
+        await onValid(defaultValues);
+    }),
+    getFieldState: vi.fn(),
+    setError: vi.fn(),
+    clearErrors: vi.fn(),
+    resetField: vi.fn(),
+    setFocus: vi.fn(),
+    unregister: vi.fn(),
+    register: vi.fn(),
+    control: {},
+});
+describe('useCRUDForm', () => {
+    describe('Mode Detection', () => {
+        it('should be in create mode when no id is provided', () => {
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+            }));
+            expect(result.current.mode).toBe('create');
+            expect(result.current.isCreateMode).toBe(true);
+            expect(result.current.isEditMode).toBe(false);
+        });
+        it('should be in edit mode when id is provided', () => {
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+            }));
+            expect(result.current.mode).toBe('edit');
+            expect(result.current.isEditMode).toBe(true);
+            expect(result.current.isCreateMode).toBe(false);
+        });
+    });
+    describe('Data Fetching (Edit Mode)', () => {
+        it('should fetch data in edit mode', async () => {
+            const mockData = { name: 'John', email: 'john@example.com' };
+            const fetchFn = vi.fn().mockResolvedValue(mockData);
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+            }));
+            expect(result.current.isLoading).toBe(true);
+            expect(fetchFn).toHaveBeenCalledWith('123');
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            expect(form.reset).toHaveBeenCalledWith(mockData);
+            expect(result.current.originalData).toEqual(mockData);
+            expect(result.current.error).toBeNull();
+        });
+        it('should call onFetchSuccess when data is loaded', async () => {
+            const mockData = { name: 'John' };
+            const fetchFn = vi.fn().mockResolvedValue(mockData);
+            const onFetchSuccess = vi.fn();
+            const form = createMockForm();
+            renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                onFetchSuccess,
+            }));
+            await waitFor(() => {
+                expect(onFetchSuccess).toHaveBeenCalledWith(mockData);
+            });
+        });
+        it('should handle fetch errors', async () => {
+            const error = new Error('Failed to fetch');
+            const fetchFn = vi.fn().mockRejectedValue(error);
+            const onError = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                onError,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            expect(result.current.error).toEqual(error);
+            expect(onError).toHaveBeenCalledWith(error, 'edit');
+        });
+        it('should not fetch data in create mode', () => {
+            const fetchFn = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                fetchFn,
+            }));
+            expect(fetchFn).not.toHaveBeenCalled();
+            expect(result.current.isLoading).toBe(false);
+        });
+    });
+    describe('Create Mode Submit', () => {
+        it('should call createFn with form data', async () => {
+            const formData = { name: 'John', email: 'john@example.com' };
+            const createFn = vi.fn().mockResolvedValue({ id: '123', ...formData });
+            const form = createMockForm(formData);
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+            }));
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            expect(createFn).toHaveBeenCalledWith(formData);
+        });
+        it('should call onSuccess after successful create', async () => {
+            const formData = { name: 'John' };
+            const createFn = vi.fn().mockResolvedValue({ id: '123' });
+            const onSuccess = vi.fn();
+            const form = createMockForm(formData);
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+                onSuccess,
+            }));
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            expect(onSuccess).toHaveBeenCalledWith(formData, 'create');
+        });
+        it('should handle create errors', async () => {
+            const error = new Error('Failed to create');
+            const createFn = vi.fn().mockRejectedValue(error);
+            const onError = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+                onError,
+            }));
+            await act(async () => {
+                try {
+                    await result.current.submit({});
+                }
+                catch (e) {
+                    // Expected error
+                }
+            });
+            expect(result.current.error).toEqual(error);
+            expect(onError).toHaveBeenCalledWith(error, 'create');
+        });
+    });
+    describe('Edit Mode Submit', () => {
+        it('should call updateFn with id and form data', async () => {
+            const formData = { name: 'John Updated' };
+            const updateFn = vi.fn().mockResolvedValue({ id: '123', ...formData });
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const form = createMockForm(formData);
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            expect(updateFn).toHaveBeenCalledWith('123', formData);
+        });
+        it('should call onSuccess after successful update', async () => {
+            const formData = { name: 'John Updated' };
+            const updateFn = vi.fn().mockResolvedValue({ id: '123' });
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const onSuccess = vi.fn();
+            const form = createMockForm(formData);
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+                onSuccess,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            expect(onSuccess).toHaveBeenCalledWith(formData, 'edit');
+        });
+        it('should handle update errors', async () => {
+            const error = new Error('Failed to update');
+            const updateFn = vi.fn().mockRejectedValue(error);
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const onError = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+                onError,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                try {
+                    await result.current.submit({});
+                }
+                catch (e) {
+                    // Expected error
+                }
+            });
+            expect(result.current.error).toEqual(error);
+            expect(onError).toHaveBeenCalledWith(error, 'edit');
+        });
+    });
+    describe('Data Transformation', () => {
+        it('should transform data before submit', async () => {
+            const formData = { tags: 'react, typescript, hooks' };
+            const transformData = vi.fn((data, mode) => ({
+                ...data,
+                tags: data.tags.split(',').map((t) => t.trim()),
+            }));
+            const createFn = vi.fn().mockResolvedValue({});
+            const form = createMockForm(formData);
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+                transformData,
+            }));
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            expect(transformData).toHaveBeenCalledWith(formData, 'create');
+            expect(createFn).toHaveBeenCalledWith({
+                tags: ['react', 'typescript', 'hooks'],
+            });
+        });
+    });
+    describe('Delete Operation', () => {
+        it('should delete data in edit mode', async () => {
+            const deleteFn = vi.fn().mockResolvedValue({});
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                deleteFn,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.handleDelete();
+            });
+            expect(deleteFn).toHaveBeenCalledWith('123');
+            expect(result.current.isDeleting).toBe(false);
+        });
+        it('should call onSuccess after successful delete', async () => {
+            const deleteFn = vi.fn().mockResolvedValue({});
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const onSuccess = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                deleteFn,
+                onSuccess,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.handleDelete();
+            });
+            expect(onSuccess).toHaveBeenCalled();
+        });
+        it('should throw error when delete is called in create mode', async () => {
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+            }));
+            await expect(async () => {
+                await act(async () => {
+                    await result.current.handleDelete();
+                });
+            }).rejects.toThrow('Delete is only available in edit mode');
+        });
+        it('should handle delete errors', async () => {
+            const error = new Error('Failed to delete');
+            const deleteFn = vi.fn().mockRejectedValue(error);
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const onError = vi.fn();
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                deleteFn,
+                onError,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                try {
+                    await result.current.handleDelete();
+                }
+                catch (e) {
+                    // Expected error
+                }
+            });
+            expect(result.current.error).toEqual(error);
+            expect(onError).toHaveBeenCalledWith(error, 'edit');
+        });
+    });
+    describe('Loading States', () => {
+        it('should track isSubmitting state', async () => {
+            const createFn = vi.fn().mockImplementation(() => new Promise(resolve => setTimeout(() => resolve({}), 100)));
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+            }));
+            expect(result.current.isSubmitting).toBe(false);
+            const submitPromise = act(async () => {
+                await result.current.submit({});
+            });
+            await waitFor(() => {
+                expect(result.current.isSubmitting).toBe(false);
+            });
+            await submitPromise;
+        });
+        it('should track isDeleting state', async () => {
+            const deleteFn = vi.fn().mockImplementation(() => new Promise(resolve => setTimeout(() => resolve({}), 100)));
+            const fetchFn = vi.fn().mockResolvedValue({ name: 'John' });
+            const form = createMockForm();
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                deleteFn,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            expect(result.current.isDeleting).toBe(false);
+            const deletePromise = act(async () => {
+                await result.current.handleDelete();
+            });
+            await waitFor(() => {
+                expect(result.current.isDeleting).toBe(false);
+            });
+            await deletePromise;
+        });
+    });
+    describe('Send Only Dirty Fields', () => {
+        it('should send only changed fields when sendOnlyDirtyFields is true', async () => {
+            const originalData = { name: 'John', email: 'john@example.com', age: 30 };
+            const updatedData = { name: 'John Smith', email: 'john@example.com', age: 30 };
+            const fetchFn = vi.fn().mockResolvedValue(originalData);
+            const updateFn = vi.fn().mockResolvedValue({});
+            const form = createMockForm(updatedData);
+            // Mock dirtyFields - only name is dirty
+            form.formState.dirtyFields = { name: true };
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+                sendOnlyDirtyFields: true,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.submit(updatedData);
+            });
+            // Only the dirty field should be sent
+            expect(updateFn).toHaveBeenCalledWith('123', { name: 'John Smith' });
+        });
+        it('should send all fields when sendOnlyDirtyFields is false (default)', async () => {
+            const originalData = { name: 'John', email: 'john@example.com' };
+            const updatedData = { name: 'John Smith', email: 'john@example.com' };
+            const fetchFn = vi.fn().mockResolvedValue(originalData);
+            const updateFn = vi.fn().mockResolvedValue({});
+            const form = createMockForm(updatedData);
+            form.formState.dirtyFields = { name: true };
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+                sendOnlyDirtyFields: false, // explicitly false
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.submit(updatedData);
+            });
+            // All fields should be sent
+            expect(updateFn).toHaveBeenCalledWith('123', updatedData);
+        });
+        it('should send all fields in create mode even when sendOnlyDirtyFields is true', async () => {
+            const formData = { name: 'John', email: 'john@example.com' };
+            const createFn = vi.fn().mockResolvedValue({ id: '123' });
+            const form = createMockForm(formData);
+            form.formState.dirtyFields = { name: true, email: true };
+            const { result } = renderHook(() => useCRUDForm({
+                form,
+                createFn,
+                sendOnlyDirtyFields: true, // Should be ignored in create mode
+            }));
+            await act(async () => {
+                await result.current.submit(formData);
+            });
+            // All fields should be sent in create mode
+            expect(createFn).toHaveBeenCalledWith(formData);
+        });
+        it('should handle nested dirty fields', async () => {
+            const originalData = {
+                name: 'John',
+                address: {
+                    city: 'Seoul',
+                    country: 'Korea',
+                },
+            };
+            const updatedData = {
+                name: 'John',
+                address: {
+                    city: 'Busan',
+                    country: 'Korea',
+                },
+            };
+            const fetchFn = vi.fn().mockResolvedValue(originalData);
+            const updateFn = vi.fn().mockResolvedValue({});
+            const form = createMockForm(updatedData);
+            // Only address.city is dirty
+            form.formState.dirtyFields = { address: { city: true } };
+            const { result } = renderHook(() => useCRUDForm({
+                id: '123',
+                form,
+                fetchFn,
+                updateFn,
+                sendOnlyDirtyFields: true,
+            }));
+            await waitFor(() => {
+                expect(result.current.isLoading).toBe(false);
+            });
+            await act(async () => {
+                await result.current.submit(updatedData);
+            });
+            // Only the nested dirty field should be extracted
+            expect(updateFn).toHaveBeenCalledWith('123', {
+                address: { city: 'Busan' },
+            });
+        });
+    });
+});

package/dist/hooks/form/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Form Management Hooks
+ */
+export * from './useCRUDForm';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/form/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/form/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,eAAe,CAAC"}

package/dist/hooks/form/index.js

@@ -0,0 +1,4 @@
+/**
+ * Form Management Hooks
+ */
+export * from './useCRUDForm';