@drivenets/design-system 0.8.0 → 0.9.1

package/src/utils/responsive.unit.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+
+import { BREAKPOINT_LG, isResponsiveValue, resolveResponsiveValue } from './responsive';
+
+describe('BREAKPOINT_LG', () => {
+	it('should be sourced from the SCSS variable and equal 1440', () => {
+		expect(BREAKPOINT_LG).toBe(1440);
+	});
+});
+
+describe('isResponsiveValue', () => {
+	it('should return true for a responsive object', () => {
+		expect(isResponsiveValue({ lg: 'large', md: 'small' })).toBe(true);
+	});
+
+	it('should return false for a string', () => {
+		expect(isResponsiveValue('large')).toBe(false);
+	});
+
+	it('should return false for null', () => {
+		expect(isResponsiveValue(null as unknown as string)).toBe(false);
+	});
+
+	it('should return true for an object with only lg', () => {
+		expect(isResponsiveValue({ lg: 'large' })).toBe(true);
+	});
+
+	it('should return true for an object with only md', () => {
+		expect(isResponsiveValue({ md: 'small' })).toBe(true);
+	});
+});
+
+describe('resolveResponsiveValue', () => {
+	it('should return static value unchanged for both breakpoints', () => {
+		expect(resolveResponsiveValue('large', 'lg')).toBe('large');
+		expect(resolveResponsiveValue('large', 'md')).toBe('large');
+	});
+
+	it('should resolve lg value from responsive object', () => {
+		expect(resolveResponsiveValue({ lg: 'large', md: 'small' }, 'lg')).toBe('large');
+	});
+
+	it('should resolve md value from responsive object', () => {
+		expect(resolveResponsiveValue({ lg: 'large', md: 'small' }, 'md')).toBe('small');
+	});
+
+	it('should fall back to lg when md is not specified', () => {
+		expect(resolveResponsiveValue({ lg: 'large' }, 'md')).toBe('large');
+	});
+
+	it('should fall back to md when lg is not specified', () => {
+		expect(resolveResponsiveValue({ md: 'small' }, 'lg')).toBe('small');
+	});
+});

package/src/utils/type-utils.ts

@@ -0,0 +1 @@
+export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;

package/src/utils/use-controlled.browser.test.ts

@@ -13,8 +13,8 @@ describe('useControlled', () => {
 		});
 
 		it('should call the provided setValue', async () => {
-			const setValue = vi.fn();
-			const { result, act } = await renderHook(() => useControlled<string>('hello', setValue, ''));
+			const setValue = vi.fn(() => {});
+			const { result, act } = await renderHook(() => useControlled('hello', setValue, ''));
 
 			await act(() => {
 				result.current[1]('world');
@@ -33,13 +33,13 @@ describe('useControlled', () => {
 
 	describe('uncontrolled mode', () => {
 		it('should use defaultValue as the initial value', async () => {
-			const { result } = await renderHook(() => useControlled<string>(undefined, undefined, 'fallback'));
+			const { result } = await renderHook(() => useControlled(undefined, undefined, 'fallback'));
 
 			expect(result.current[0]).toBe('fallback');
 		});
 
 		it('should update internal state via the setter', async () => {
-			const { result, act } = await renderHook(() => useControlled<string>(undefined, undefined, 'fallback'));
+			const { result, act } = await renderHook(() => useControlled(undefined, undefined, 'fallback'));
 
 			expect(result.current[0]).toBe('fallback');
 
@@ -63,8 +63,8 @@ describe('useControlled', () => {
 		});
 
 		it('should treat setValue-only (no value) as uncontrolled', async () => {
-			const setValue = vi.fn();
-			const { result, act } = await renderHook(() => useControlled<string>(undefined, setValue, 'default'));
+			const setValue = vi.fn(() => {});
+			const { result, act } = await renderHook(() => useControlled(undefined, setValue, 'default'));
 
 			expect(result.current[0]).toBe('default');
 

package/src/utils/use-controlled.ts

@@ -10,7 +10,7 @@ export const useControlled = <T>(
 	defaultValue: T,
 ) => {
 	const isControlled = value !== undefined && setValue !== undefined;
-	const [internalValue, setInternalValue] = useState<T>(value ?? defaultValue);
+	const [internalValue, setInternalValue] = useState(value ?? defaultValue);
 	const resolvedValue = isControlled ? value : internalValue;
 	const resolvedSetValue = isControlled ? setValue : setInternalValue;