feat: improve input data validation

Adds a check of the input value for an empty string.

Author: mrmlnc

src/index.spec.ts

@@ -7,8 +7,11 @@ import * as fg from '.';
 describe('Package', () => {
 	describe('.sync', () => {
 		it('should throw an error when input values can not pass validation', () => {
+			const message = 'Patterns must be a string (non empty) or an array of strings';
+
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			assert.throws(() => fg.sync(null as any), /TypeError: Patterns must be a string or an array of strings/);
+			assert.throws(() => fg.sync(null as any), { message });
+			assert.throws(() => fg.sync(''), { message });
 		});
 
 		it('should returns entries', () => {
@@ -49,13 +52,11 @@ describe('Package', () => {
 
 	describe('.async', () => {
 		it('should throw an error when input values can not pass validation', async () => {
-			try {
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				await fg(null as any);
-				throw new Error('An unexpected error was found.');
-			} catch (error) {
-				assert.strictEqual((error as Error).toString(), 'TypeError: Patterns must be a string or an array of strings');
-			}
+			const message = 'Patterns must be a string (non empty) or an array of strings';
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			await assert.rejects(() => fg(null as any), { message });
+			await assert.rejects(() => fg(''), { message });
 		});
 
 		it('should returns entries', async () => {
@@ -96,8 +97,11 @@ describe('Package', () => {
 
 	describe('.stream', () => {
 		it('should throw an error when input values can not pass validation', () => {
+			const message = 'Patterns must be a string (non empty) or an array of strings';
+
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			assert.throws(() => fg.stream(null as any), /TypeError: Patterns must be a string or an array of strings/);
+			assert.throws(() => fg.stream(null as any), { message });
+			assert.throws(() => fg.stream(''), { message });
 		});
 
 		it('should returns entries', (done) => {
@@ -152,8 +156,11 @@ describe('Package', () => {
 
 	describe('.generateTasks', () => {
 		it('should throw an error when input values can not pass validation', () => {
+			const message = 'Patterns must be a string (non empty) or an array of strings';
+
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			assert.throws(() => fg.generateTasks(null as any), /TypeError: Patterns must be a string or an array of strings/);
+			assert.throws(() => fg.generateTasks(null as any), { message });
+			assert.throws(() => fg.generateTasks(''), { message });
 		});
 
 		it('should return tasks', () => {

src/index.ts

@@ -89,16 +89,13 @@ function getWorks<T>(source: PatternInternal | PatternInternal[], _Provider: new
 	return tasks.map(provider.read, provider);
 }
 
-function assertPatternsInput(source: unknown): void | never {
-	if (([] as unknown[]).concat(source).every(isString)) {
-		return;
-	}
-
-	throw new TypeError('Patterns must be a string or an array of strings');
-}
+function assertPatternsInput(input: unknown): void | never {
+	const source = ([] as unknown[]).concat(input);
+	const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
 
-function isString(source: unknown): source is string {
-	return typeof source === 'string';
+	if (!isValidSource) {
+		throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+	}
 }
 
 export = FastGlob;

src/utils/index.ts

@@ -4,12 +4,14 @@ import * as fs from './fs';
 import * as path from './path';
 import * as pattern from './pattern';
 import * as stream from './stream';
+import * as string from './string';
 
 export {
 	array,
 	errno,
 	fs,
 	path,
 	pattern,
-	stream
+	stream,
+	string
 };

src/utils/string.spec.ts

@@ -0,0 +1,33 @@
+import * as assert from 'assert';
+
+import * as util from './string';
+
+describe('Utils → String', () => {
+	describe('.isString', () => {
+		it('should return true', () => {
+			const actual = util.isString('');
+
+			assert.ok(actual);
+		});
+
+		it('should return false', () => {
+			const actual = util.isString(undefined as unknown as string);
+
+			assert.ok(!actual);
+		});
+	});
+
+	describe('.isEmpty', () => {
+		it('should return true', () => {
+			const actual = util.isEmpty('');
+
+			assert.ok(actual);
+		});
+
+		it('should return false', () => {
+			const actual = util.isEmpty('string');
+
+			assert.ok(!actual);
+		});
+	});
+});

src/utils/string.ts

@@ -0,0 +1,7 @@
+export function isString(input: unknown): input is string {
+	return typeof input === 'string';
+}
+
+export function isEmpty(input: string): boolean {
+	return input === '';
+}