@design-edito/tools 0.4.5 → 0.4.6

package/agnostic/arrays/shuffle/index.js

@@ -1,12 +1,16 @@
-// src/agnostic/arrays/shuffle/index.ts
-function shuffle(array) {
-  const shuffled = [...array];
-  for (let i = shuffled.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-  }
-  return shuffled;
+/**
+ * Shuffles an array using the Fisher-Yates algorithm.
+ *
+ * Creates a new array with the same elements in random order. The original array is not modified.
+ *
+ * @param array - The array to shuffle.
+ * @returns A new array with shuffled elements.
+ */
+export function shuffle(array) {
+    const shuffled = [...array];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
 }
-export {
-  shuffle
-};

package/agnostic/arrays/shuffle/index.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import { shuffle } from './index.js';
+describe('shuffle', () => {
+    it('shuffles and keeps the same length', () => {
+        const source = [0, 1, 2, 3, 4];
+        const shuffled = shuffle(source);
+        expect(shuffled).toHaveLength(5);
+        expect(shuffled).toContain(0);
+        expect(shuffled).toContain(1);
+        expect(shuffled).toContain(2);
+        expect(shuffled).toContain(3);
+        expect(shuffled).toContain(4);
+    });
+});

package/agnostic/booleans/is-falsy/index.js

@@ -1,17 +1,26 @@
-// src/agnostic/misc/is-nullish/index.ts
-var nullishValues = [null, void 0];
-
-// src/agnostic/booleans/is-falsy/index.ts
-var falsyValues = [...nullishValues, false, "", 0, -0, NaN];
-if (typeof BigInt === "function") falsyValues.push(BigInt(0));
-function isFalsy(val) {
-  return falsyValues.includes(val);
+import { nullishValues } from '../../misc/is-nullish/index.js';
+/** Array containing all falsy values for comparison. */
+const falsyValues = [...nullishValues, false, '', 0, -0, NaN];
+if (typeof BigInt === 'function')
+    falsyValues.push(BigInt(0));
+export { falsyValues };
+/**
+ * Type guard to check if a value is falsy.
+ *
+ * Checks if the value is one of: null, undefined, false, empty string, 0, -0, NaN, or 0n.
+ *
+ * @param val - The value to check.
+ * @returns `true` if the value is falsy, `false` otherwise.
+ */
+export function isFalsy(val) {
+    return falsyValues.includes(val);
 }
-function isNotFalsy(val) {
-  return !isFalsy(val);
+/**
+ * Type guard to check if a value is not falsy.
+ *
+ * @param val - The value to check.
+ * @returns `true` if the value is not falsy, `false` otherwise.
+ */
+export function isNotFalsy(val) {
+    return !isFalsy(val);
 }
-export {
-  falsyValues,
-  isFalsy,
-  isNotFalsy
-};

package/agnostic/booleans/is-falsy/index.test.js

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { isFalsy, isNotFalsy } from './index.js';
+describe('is-falsy', () => {
+    it('returns true on all falsy values', () => {
+        expect(isFalsy(null)).toBe(true);
+        expect(isFalsy(undefined)).toBe(true);
+        expect(isFalsy(false)).toBe(true);
+        expect(isFalsy('')).toBe(true);
+        expect(isFalsy(0)).toBe(true);
+        expect(isFalsy(-0)).toBe(true);
+        expect(isFalsy(NaN)).toBe(true);
+        expect(isFalsy(0n)).toBe(true);
+    });
+});
+describe('is-not-falsy', () => {
+    it('returns false on all falsy values', () => {
+        expect(isNotFalsy(null)).toBe(false);
+        expect(isNotFalsy(undefined)).toBe(false);
+        expect(isNotFalsy(false)).toBe(false);
+        expect(isNotFalsy('')).toBe(false);
+        expect(isNotFalsy(0)).toBe(false);
+        expect(isNotFalsy(-0)).toBe(false);
+        expect(isNotFalsy(NaN)).toBe(false);
+        expect(isNotFalsy(0n)).toBe(false);
+    });
+});