refactor: toBoolean does more; narrower predicates

.changeset/young-kiwis-watch.md

@@ -0,0 +1,18 @@
+---
+"@accelint/converters": minor
+"@accelint/predicates": minor
+---
+
+The `toBoolean` function (packages/converters) centralizes the logic for coercing a value
+to a boolean which enables the predicate functions (packages/predicates/src/is-noyes) to
+be more specific in what they compare against rather than them simply being alias names
+to broad validation. The available predicates are now:
+
+- `isAnyFalsy`
+- `isAnyTruthy`
+- `isFalse`
+- `isTrue`
+- `isOn`
+- `isOff`
+- `isNo`
+- `isYes`

packages/converters/package.json

@@ -39,7 +39,6 @@
   },
   "dependencies": {
     "@accelint/constants": "workspace:0.1.3",
-    "@accelint/predicates": "workspace:0.1.3",
     "typescript": "^5.6.3"
   },
   "$schema": "https://json.schemastore.org/package",

packages/converters/src/to-boolean/index.test.ts

@@ -13,31 +13,57 @@
 import { expect, it, describe } from 'vitest';
 import { toBoolean } from './';
 
-const truthy = [1, '1', 'on', 'true', 'yes', true, 'ON', 'YES', 'TRUE'];
-const falsey = [
+// biome-ignore lint/style/useNumberNamespace: testing value
+const INFINITY = Infinity;
+
+const falsy = [
+  '',
   0,
+  0.0,
   '0',
-  'off',
-  'false',
-  'no',
+  '0.000',
+  '0000.000',
   false,
+  'false',
+  '  FaLsE ',
+  void 0,
+  Number.NaN,
+  null,
+  undefined,
+];
+const truthy = [
   [],
+  1,
+  '1',
+  true,
+  'true',
   {},
-  'OFF',
-  'NO',
-  'FALSE',
+  'any non-empty string',
+  // 'Yes',
+  // 'yes',
+  // 'No',
+  // 'no',
+  // 'off',
+  // 'Off',
+  // 'OFF',
+  // 'On',
+  // 'on',
+  INFINITY,
+  -INFINITY,
+  Number.POSITIVE_INFINITY,
+  Number.NEGATIVE_INFINITY,
+  /abc/,
+  new Date(),
+  new Error('Fun times.'),
+  () => void 0,
 ];
 
 describe('toBoolean', () => {
-  for (const item of truthy) {
-    it(`should return true for ${item}`, () => {
-      expect(toBoolean(item)).toBeTruthy();
-    });
-  }
+  it.each(falsy)('%s', (val) => {
+    expect(toBoolean(val)).toBe(false);
+  });
 
-  for (const item of falsey) {
-    it(`should return false for ${item}`, () => {
-      expect(toBoolean(item)).not.toBeTruthy();
-    });
-  }
+  it.each(truthy)('%s', (val) => {
+    expect(toBoolean(val)).toBe(true);
+  });
 });

packages/converters/src/to-boolean/index.ts

@@ -10,30 +10,29 @@
  * governing permissions and limitations under the License.
  */
 
-import { isTrue } from '@accelint/predicates';
-
 /**
- * Compare the given value against a custom list of `truthy` values.
+ * Returns true for any value not found to be a "false" value.
  *
- * String values are not case sensitive.
+ * **"false" values**
+ *   - inherently false values: '' (empty string), 0, false, undefined, null, NaN
+ *   - numeric zero: '0.000' - any number of leading or trailing zeros
+ *   - string literal: 'false' - any capitalizations or space-padding
  *
- * _1, '1', 'on', 'true', 'yes', true_
+ * For more restrictive comparisons against: true, false, on, off, yes, no; see
+ * the predicates package (\@accelint/predicates).
  *
  * @pure
  *
  * @example
- * toBoolean('on');
- * // true
- *
- * toBoolean('yes');
- * // true
- *
- * toBoolean('off');
- * // false
- *
- * toBoolean('no');
- * // false
+ * toBoolean(1);          // true
+ * toBoolean(' FaLsE ');  // false
+ * toBoolean('  true');   // true
+ * toBoolean('000.000');  // false
  */
 export function toBoolean(val: unknown) {
-  return isTrue(val);
+  return !(
+    !val ||
+    `${val}`.trim().toLowerCase() === 'false' ||
+    Number.parseFloat(`${val}`) === 0
+  );
 }

packages/predicates/src/index.ts

@@ -6,7 +6,16 @@ export { isBbox } from './is-bbox';
 export { isLatitude } from './is-latitude';
 export { isLongitude } from './is-longitude';
 export { isNothing } from './is-nothing';
-export { isFalse, isNo, isOff, isOn, isTrue, isYes } from './is-noyes';
+export {
+  isAnyFalsy,
+  isAnyTruthy,
+  isFalse,
+  isNo,
+  isOff,
+  isOn,
+  isTrue,
+  isYes,
+} from './is-noyes';
 export {
   isFiniteNumber,
   isFiniteNumeric,

packages/predicates/src/is-noyes/index.test.ts

@@ -10,26 +10,43 @@
  * governing permissions and limitations under the License.
  */
 
-import { describe, it, expect } from 'vitest';
-import { isTrue, isYes, isFalse, isNo, isOn, isOff } from './';
+import { describe, expect, it } from 'vitest';
+import {
+  isAnyFalsy,
+  isAnyTruthy,
+  isFalse,
+  isNo,
+  isOff,
+  isOn,
+  isTrue,
+  isYes,
+} from './';
 
-const truthy = [1, '1', 'on', 'true', 'yes', true, 'ON', 'YES', 'TRUE'];
-const falsey = [0, '0', 'off', 'false', 'no', false, 'OFF', 'NO', 'FALSE'];
+type Config = {
+  negative: unknown[];
+  positive: unknown[];
+  predicate: (a: unknown) => boolean;
+};
 
-describe('boolean validators', () => {
-  for (const item of truthy) {
-    it(`should return true for ${item}`, () => {
-      expect(isOn(item)).toBeTruthy();
-      expect(isTrue(item)).toBeTruthy();
-      expect(isYes(item)).toBeTruthy();
-    });
-  }
+const falsy = [0, '', false, ' false ', null, undefined, Number.NaN];
+const truthy = [1, true, ' true '];
 
-  for (const item of falsey) {
-    it(`should return false for ${item}`, () => {
-      expect(isFalse(item)).toBeTruthy();
-      expect(isOff(item)).toBeTruthy();
-      expect(isNo(item)).toBeTruthy();
+describe('boolean predicates', () => {
+  describe.each`
+    predicate      | positive                              | negative
+    ${isAnyFalsy}  | ${[...falsy, 'no', 'off']}            | ${[...truthy, 'on', 'yes']}
+    ${isAnyTruthy} | ${[...truthy, 'on', 'yes']}           | ${[...falsy, 'no', 'off']}
+    ${isFalse}     | ${[...falsy, ' false', '0']}          | ${[...truthy, 'o', 'O', 'true', 'string with false', '0.00']}
+    ${isNo}        | ${[...falsy, ' n', 'N ', 'no', 'NO']} | ${[...truthy, 'yes', 'string with no']}
+    ${isOff}       | ${[...falsy, ' off', 'OFF ']}         | ${[...truthy, 'on', 'string with off', 'of']}
+    ${isOn}        | ${[...truthy, ' on', 'ON ']}          | ${[...falsy, 'of', 'string with on', 'o']}
+    ${isTrue}      | ${[...truthy, ' true']}               | ${[...falsy, 'any string', {}, [], /abc/]}
+    ${isYes}       | ${[...truthy, ' yes', 'YeS ', 'y']}   | ${[...falsy, 'no', 'string with yes', 2]}
+  `('$predicate.name', ({ predicate, ...lists }: Config) => {
+    describe.each(['positive', 'negative'])('%s matches', (list) => {
+      it.each(lists[list] as unknown[])('%j', (val) => {
+        expect(predicate(val)).toBe(list === 'positive');
+      });
     });
-  }
+  });
 });