Ensure arguments to escapeAll and quoteAll are actually arrays

Author: ericcornelissen

src/index.js

@@ -13,7 +13,7 @@ import process from "node:process";
 
 import { parseOptions } from "./internal/options.js";
 import { getHelpersByPlatform } from "./internal/platforms.js";
-import { checkedToString } from "./internal/reflection.js";
+import { checkedToString, ensureArray } from "./internal/reflection.js";
 
 /**
  * A class to escape user-controlled inputs to shell commands to prevent shell
@@ -127,6 +127,7 @@ export class Shescape {
    * @since 2.0.0
    */
   escapeAll(args) {
+    ensureArray(args);
     return args.map((arg) => this.escape(arg));
   }
 
@@ -161,6 +162,7 @@ export class Shescape {
    * @since 2.0.0
    */
   quoteAll(args) {
+    ensureArray(args);
     return args.map((arg) => this.quote(arg));
   }
 }

src/internal/reflection.js

@@ -4,12 +4,20 @@
  */
 
 /**
- * The error message for incorrect parameter types.
+ * The error message for non-array values.
  *
  * @constant
  * @type {string}
  */
-const typeError =
+const typeErrorArray = "Shescape requires argument lists to be an array";
+
+/**
+ * The error message for non-stringable values.
+ *
+ * @constant
+ * @type {string}
+ */
+const typeErrorString =
   "Shescape requires strings or values that can be converted into a string using .toString()";
 
 /**
@@ -79,12 +87,24 @@ export function checkedToString(value) {
 
   const maybeStr = maybeToString(value);
   if (maybeStr === null) {
-    throw new TypeError(typeError);
+    throw new TypeError(typeErrorString);
   }
 
   return maybeStr;
 }
 
+/**
+ * Ensures a value is an array.
+ *
+ * @param {unknown} value The value of interest.
+ * @throws {TypeError} The `value` is not an array.
+ */
+export function ensureArray(value) {
+  if (!isArray(value)) {
+    throw new TypeError(typeErrorArray);
+  }
+}
+
 /**
  * Checks if a value is a string.
  *
@@ -94,3 +114,11 @@ export function checkedToString(value) {
 export function isString(value) {
   return typeof value === typeofString;
 }
+
+/**
+ * Checks if a value is an array.
+ *
+ * @param {unknown} value The value of interest.
+ * @throws {TypeError} The `value` is not an array.
+ */
+export const isArray = Array.isArray;

test/_constants.js

@@ -29,9 +29,15 @@ export const illegalArgumentLists = [
   { description: "typed array (uint8)", value: new Uint8Array() },
   { description: "typed array (uint16)", value: new Uint16Array() },
   { description: "typed array (uint32)", value: new Uint32Array() },
+  { description: "typed array (uint64)", value: new BigUint64Array() },
   { description: "typed array (int8)", value: new Int8Array() },
   { description: "typed array (int16)", value: new Int16Array() },
   { description: "typed array (int32)", value: new Int32Array() },
+  { description: "typed array (int64)", value: new BigInt64Array() },
+  { description: "typed array (float16)", value: new Float16Array() },
+  { description: "typed array (float32)", value: new Float32Array() },
+  { description: "typed array (float64)", value: new Float64Array() },
+  { description: "typed array (clamped)", value: new Uint8ClampedArray() },
 ];
 
 /* OS platforms (based on https://nodejs.org/api/os.html#osplatform) */

test/unit/reflection/ensure-array.test.js

@@ -0,0 +1,25 @@
+/**
+ * @overview Contains unit tests for the `ensureArray` function.
+ * @license MIT
+ */
+
+import { testProp } from "@fast-check/ava";
+import test from "ava";
+import * as fc from "fast-check";
+
+import { ensureArray } from "../../../src/internal/reflection.js";
+
+import { constants } from "./_.js";
+
+testProp("arrays", [fc.array(fc.anything())], (t, value) => {
+  t.notThrows(() => ensureArray(value));
+});
+
+for (const { description, value } of constants.illegalArgumentLists) {
+  test(description, (t) => {
+    t.throws(() => ensureArray(value), {
+      instanceOf: TypeError,
+      message: "Shescape requires argument lists to be an array",
+    });
+  });
+}

test/unit/reflection/is-array.test.js

@@ -0,0 +1,23 @@
+/**
+ * @overview Contains unit tests for the `isString` function.
+ * @license MIT
+ */
+
+import { testProp } from "@fast-check/ava";
+import * as fc from "fast-check";
+
+import { isArray } from "../../../src/internal/reflection.js";
+
+testProp("arrays", [fc.array(fc.anything())], (t, value) => {
+  const result = isArray(value);
+  t.true(result);
+});
+
+testProp(
+  "non-arrays",
+  [fc.anything().filter((value) => !Array.isArray(value))],
+  (t, value) => {
+    const result = isArray(value);
+    t.false(result);
+  },
+);