wip: migrate to bun

test/pullAt.spec.ts

@@ -0,0 +1,126 @@
+import assert from 'node:assert';
+import lodashStable from 'lodash';
+import { empties, stubOne, noop, falsey } from './utils';
+import pullAt from '../src/pullAt';
+
+describe('pullAt', () => {
+    it('should modify the array and return removed elements', () => {
+        const array = [1, 2, 3],
+            actual = pullAt(array, [0, 1]);
+
+        assert.deepStrictEqual(array, [3]);
+        assert.deepStrictEqual(actual, [1, 2]);
+    });
+
+    it('should work with unsorted indexes', () => {
+        const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
+            actual = pullAt(array, [1, 3, 11, 7, 5, 9]);
+
+        assert.deepStrictEqual(array, [1, 3, 5, 7, 9, 11]);
+        assert.deepStrictEqual(actual, [2, 4, 12, 8, 6, 10]);
+    });
+
+    it('should work with repeated indexes', () => {
+        const array = [1, 2, 3, 4],
+            actual = pullAt(array, [0, 2, 0, 1, 0, 2]);
+
+        assert.deepStrictEqual(array, [4]);
+        assert.deepStrictEqual(actual, [1, 3, 1, 2, 1, 3]);
+    });
+
+    it('should use `undefined` for nonexistent indexes', () => {
+        const array = ['a', 'b', 'c'],
+            actual = pullAt(array, [2, 4, 0]);
+
+        assert.deepStrictEqual(array, ['b']);
+        assert.deepStrictEqual(actual, ['c', undefined, 'a']);
+    });
+
+    it('should flatten `indexes`', () => {
+        let array = ['a', 'b', 'c'];
+        assert.deepStrictEqual(pullAt(array, 2, 0), ['c', 'a']);
+        assert.deepStrictEqual(array, ['b']);
+
+        array = ['a', 'b', 'c', 'd'];
+        assert.deepStrictEqual(pullAt(array, [3, 0], 2), ['d', 'a', 'c']);
+        assert.deepStrictEqual(array, ['b']);
+    });
+
+    it('should return an empty array when no indexes are given', () => {
+        let array = ['a', 'b', 'c'],
+            actual = pullAt(array);
+
+        assert.deepStrictEqual(array, ['a', 'b', 'c']);
+        assert.deepStrictEqual(actual, []);
+
+        actual = pullAt(array, [], []);
+
+        assert.deepStrictEqual(array, ['a', 'b', 'c']);
+        assert.deepStrictEqual(actual, []);
+    });
+
+    it('should work with non-index paths', () => {
+        const values = lodashStable
+            .reject(empties, (value) => value === 0 || lodashStable.isArray(value))
+            .concat(-1, 1.1);
+
+        const array = lodashStable.transform(
+            values,
+            (result, value) => {
+                result[value] = 1;
+            },
+            [],
+        );
+
+        let expected = lodashStable.map(values, stubOne),
+            actual = pullAt(array, values);
+
+        assert.deepStrictEqual(actual, expected);
+
+        expected = lodashStable.map(values, noop);
+        actual = lodashStable.at(array, values);
+
+        assert.deepStrictEqual(actual, expected);
+    });
+
+    it('should preserve the sign of `0`', () => {
+        const props = [-0, Object(-0), 0, Object(0)];
+
+        const actual = lodashStable.map(props, (key) => {
+            const array = [-1];
+            array['-0'] = -2;
+            return pullAt(array, key);
+        });
+
+        assert.deepStrictEqual(actual, [[-2], [-2], [-1], [-1]]);
+    });
+
+    it('should support deep paths', () => {
+        const array = [];
+        array.a = { b: 2 };
+
+        let actual = pullAt(array, 'a.b');
+
+        assert.deepStrictEqual(actual, [2]);
+        assert.deepStrictEqual(array.a, {});
+
+        try {
+            actual = pullAt(array, 'a.b.c');
+        } catch (e) {}
+
+        assert.deepStrictEqual(actual, [undefined]);
+    });
+
+    it('should work with a falsey `array` when keys are given', () => {
+        const values = falsey.slice(),
+            expected = lodashStable.map(values, lodashStable.constant(Array(4)));
+
+        const actual = lodashStable.map(values, (array) => {
+            try {
+                return pullAt(array, 0, 1, 'pop', 'push');
+            } catch (e) {}
+        });
+
+        assert.deepStrictEqual(actual, expected);
+    });
+});