fix: correct TypeScript types for singleParse and multiParse (#241)

- Add explicit generic type parameter T with default string
- singleParse codec now correctly typed as (value: string) => T
- multiParse codec now correctly typed as (entry: [string, string]) => [string, T]
- Return types properly reflect generic T
- Add comprehensive tests for both functions

Fixes FE-584

Author: cristinecula

src/location.ts

@@ -1,31 +1,41 @@
 import { identity } from './function';
 
 export const hashUrl = () =>
-		new URL(
-			location.hash.replace(/^#!?/iu, '').replace('%23', '#'),
-			location.origin,
-		),
-	singleParse = (hashParam: string, codec = identity) => {
-		const values = new URLSearchParams(hashUrl().hash.replace('#', '')).getAll(
-			hashParam,
-		);
+	new URL(
+		location.hash.replace(/^#!?/iu, '').replace('%23', '#'),
+		location.origin,
+	);
 
-		switch (values.length) {
-			case 0:
-				return undefined;
-			case 1:
-				return codec(values[0]);
-			default:
-				return values.map(codec);
-		}
-	},
-	multiParse = (hashParam: string, codec = identity) => {
-		const params = Array.from(
-			new URLSearchParams(hashUrl().hash.replace('#', '')).entries(),
-		)
-			.filter(([param]) => param.startsWith(hashParam))
-			.map(([param, value]) => codec([param.replace(hashParam, ''), value]))
-			.filter(([, value]) => value != null);
+export const singleParse = <T = string>(
+	hashParam: string,
+	codec: (value: string) => T = identity as (value: string) => T,
+): T | T[] | undefined => {
+	const values = new URLSearchParams(hashUrl().hash.replace('#', '')).getAll(
+		hashParam,
+	);
 
-		return Object.fromEntries(params);
-	};
+	switch (values.length) {
+		case 0:
+			return undefined;
+		case 1:
+			return codec(values[0]);
+		default:
+			return values.map(codec);
+	}
+};
+
+export const multiParse = <T = string>(
+	hashParam: string,
+	codec: (entry: [string, string]) => [string, T] = identity as (
+		entry: [string, string],
+	) => [string, T],
+): Record<string, T> => {
+	const params = Array.from(
+		new URLSearchParams(hashUrl().hash.replace('#', '')).entries(),
+	)
+		.filter(([param]) => param.startsWith(hashParam))
+		.map(([param, value]) => codec([param.replace(hashParam, ''), value]))
+		.filter(([, value]) => value != null);
+
+	return Object.fromEntries(params) as Record<string, T>;
+};

test/location.test.ts

@@ -0,0 +1,127 @@
+import { assert } from '@open-wc/testing';
+import { hashUrl, multiParse, singleParse } from '../src/location';
+
+suite('location', () => {
+	const originalHash = window.location.hash;
+
+	const setHash = (hash: string) => {
+		window.location.hash = hash;
+	};
+
+	teardown(() => {
+		window.location.hash = originalHash;
+	});
+
+	suite('hashUrl', () => {
+		test('returns URL from hash', () => {
+			setHash('#!/path#foo=bar');
+			const url = hashUrl();
+			assert.instanceOf(url, URL);
+			assert.equal(url.pathname, '/path');
+			assert.equal(url.hash, '#foo=bar');
+		});
+
+		test('handles #! prefix', () => {
+			setHash('#!/test');
+			const url = hashUrl();
+			assert.equal(url.pathname, '/test');
+		});
+
+		test('handles %23 in hash', () => {
+			setHash('#!%23anchor');
+			const url = hashUrl();
+			assert.equal(url.hash, '#anchor');
+		});
+	});
+
+	suite('singleParse', () => {
+		test('returns undefined when param not found', () => {
+			setHash('#!/path');
+			const result = singleParse('nonexistent');
+			assert.isUndefined(result);
+		});
+
+		test('returns string for single value', () => {
+			setHash('#!/path#name=value');
+			const result = singleParse('name');
+			assert.equal(result, 'value');
+		});
+
+		test('returns array for multiple values', () => {
+			setHash('#!/path#name=value1&name=value2');
+			const result = singleParse('name');
+			assert.deepEqual(result, ['value1', 'value2']);
+		});
+
+		test('applies custom codec to single value', () => {
+			setHash('#!/path#count=42');
+			const result = singleParse('count', (v) => parseInt(v, 10));
+			assert.equal(result, 42);
+		});
+
+		test('applies custom codec to multiple values', () => {
+			setHash('#!/path#count=1&count=2&count=3');
+			const result = singleParse('count', (v) => parseInt(v, 10));
+			assert.deepEqual(result, [1, 2, 3]);
+		});
+
+		test('preserves string type with default codec', () => {
+			setHash('#!/path#name=test');
+			const result: string | string[] | undefined = singleParse('name');
+			assert.equal(result, 'test');
+		});
+
+		test('works with hash params (not query string)', () => {
+			setHash('##foo=bar&baz=qux');
+			const result = singleParse('foo');
+			assert.equal(result, 'bar');
+		});
+	});
+
+	suite('multiParse', () => {
+		test('returns empty object when no params match', () => {
+			setHash('#!/path');
+			const result = multiParse('filter.');
+			assert.deepEqual(result, {});
+		});
+
+		test('parses params with prefix', () => {
+			setHash('#!/path#filter.status=active&filter.type=admin');
+			const result = multiParse('filter.');
+			assert.deepEqual(result, { status: 'active', type: 'admin' });
+		});
+
+		test('returns Record<string, string> with default codec', () => {
+			setHash('#!/path#name=john&age=30');
+			const result: Record<string, string> = multiParse('');
+			assert.deepEqual(result, { name: 'john', age: '30' });
+		});
+
+		test('applies custom codec for value transformation', () => {
+			setHash('#!/path#count.a=1&count.b=2');
+			const result = multiParse(
+				'count.',
+				([key, value]) => [key, parseInt(value, 10)] as const,
+			);
+			assert.deepEqual(result, { a: 1, b: 2 });
+		});
+
+		test('applies custom codec with type transformation', () => {
+			setHash('#!/path#flag.enabled=true&flag.visible=false');
+			const result = multiParse(
+				'flag.',
+				([key, value]) => [key, value === 'true'] as const,
+			);
+			assert.deepEqual(result, { enabled: true, visible: false });
+		});
+
+		test('filters out null/undefined values', () => {
+			setHash('#!/path#item.a=value&item.b=');
+			const result = multiParse('item.', ([key, value]) =>
+				value ? ([key, value] as const) : ([key, null] as const),
+			);
+			// The empty string for 'b' becomes null, filter removes it
+			assert.deepEqual(result, { a: 'value' });
+		});
+	});
+});