wip: migrate to bun

test/invokeMap.spec.ts

@@ -0,0 +1,125 @@
+import assert from 'node:assert';
+import lodashStable from 'lodash';
+import { slice, stubOne } from './utils';
+import invokeMap from '../src/invokeMap';
+
+describe('invokeMap', () => {
+    it('should invoke a methods on each element of `collection`', () => {
+        const array = ['a', 'b', 'c'],
+            actual = invokeMap(array, 'toUpperCase');
+
+        assert.deepStrictEqual(actual, ['A', 'B', 'C']);
+    });
+
+    it('should support invoking with arguments', () => {
+        const array = [
+                function () {
+                    return slice.call(arguments);
+                },
+            ],
+            actual = invokeMap(array, 'call', null, 'a', 'b', 'c');
+
+        assert.deepStrictEqual(actual, [['a', 'b', 'c']]);
+    });
+
+    it('should work with a function for `methodName`', () => {
+        const array = ['a', 'b', 'c'];
+
+        const actual = invokeMap(
+            array,
+            function (left, right) {
+                return left + this.toUpperCase() + right;
+            },
+            '(',
+            ')',
+        );
+
+        assert.deepStrictEqual(actual, ['(A)', '(B)', '(C)']);
+    });
+
+    it('should work with an object for `collection`', () => {
+        const object = { a: 1, b: 2, c: 3 },
+            actual = invokeMap(object, 'toFixed', 1);
+
+        assert.deepStrictEqual(actual, ['1.0', '2.0', '3.0']);
+    });
+
+    it('should treat number values for `collection` as empty', () => {
+        assert.deepStrictEqual(invokeMap(1), []);
+    });
+
+    it('should not error on nullish elements', () => {
+        const array = ['a', null, undefined, 'd'];
+
+        try {
+            var actual = invokeMap(array, 'toUpperCase');
+        } catch (e) {}
+
+        assert.deepStrictEqual(actual, ['A', undefined, undefined, 'D']);
+    });
+
+    it('should not error on elements with missing properties', () => {
+        const objects = lodashStable.map([null, undefined, stubOne], (value) => ({ a: value }));
+
+        const expected = lodashStable.map(objects, (object) => (object.a ? object.a() : undefined));
+
+        try {
+            var actual = invokeMap(objects, 'a');
+        } catch (e) {}
+
+        assert.deepStrictEqual(actual, expected);
+    });
+
+    it('should invoke deep property methods with the correct `this` binding', () => {
+        const object = {
+            a: {
+                b: function () {
+                    return this.c;
+                },
+                c: 1,
+            },
+        };
+
+        lodashStable.each(['a.b', ['a', 'b']], (path) => {
+            assert.deepStrictEqual(invokeMap([object], path), [1]);
+        });
+    });
+
+    it('should return a wrapped value when chaining', () => {
+        let array = ['a', 'b', 'c'],
+            wrapped = _(array),
+            actual = wrapped.invokeMap('toUpperCase');
+
+        assert.ok(actual instanceof _);
+        assert.deepEqual(actual.valueOf(), ['A', 'B', 'C']);
+
+        actual = wrapped.invokeMap(
+            function (left, right) {
+                return left + this.toUpperCase() + right;
+            },
+            '(',
+            ')',
+        );
+
+        assert.ok(actual instanceof _);
+        assert.deepEqual(actual.valueOf(), ['(A)', '(B)', '(C)']);
+    });
+
+    it('should support shortcut fusion', () => {
+        let count = 0,
+            method = function () {
+                count++;
+                return this.index;
+            };
+
+        const array = lodashStable.times(LARGE_ARRAY_SIZE, (index) => ({
+            index: index,
+            method: method,
+        }));
+
+        const actual = _(array).invokeMap('method').take(1).value();
+
+        assert.strictEqual(count, 1);
+        assert.deepEqual(actual, [0]);
+    });
+});