wip: migrate to bun

test/zipObject-methods.spec.ts

@@ -0,0 +1,43 @@
+import assert from 'node:assert';
+import lodashStable from 'lodash';
+import { _, LARGE_ARRAY_SIZE, square, isEven } from './utils';
+
+describe('zipObject methods', () => {
+    lodashStable.each(['zipObject', 'zipObjectDeep'], (methodName) => {
+        const func = _[methodName],
+            object = { barney: 36, fred: 40 },
+            isDeep = methodName == 'zipObjectDeep';
+
+        it(`\`_.${methodName}\` should zip together key/value arrays into an object`, () => {
+            const actual = func(['barney', 'fred'], [36, 40]);
+            assert.deepStrictEqual(actual, object);
+        });
+
+        it(`\`_.${methodName}\` should ignore extra \`values\``, () => {
+            assert.deepStrictEqual(func(['a'], [1, 2]), { a: 1 });
+        });
+
+        it(`\`_.${methodName}\` should assign \`undefined\` values for extra \`keys\``, () => {
+            assert.deepStrictEqual(func(['a', 'b'], [1]), { a: 1, b: undefined });
+        });
+
+        it(`\`_.${methodName}\` should ${isDeep ? '' : 'not '}support deep paths`, () => {
+            lodashStable.each(['a.b.c', ['a', 'b', 'c']], (path, index) => {
+                const expected = isDeep
+                    ? { a: { b: { c: 1 } } }
+                    : index
+                    ? { 'a,b,c': 1 }
+                    : { 'a.b.c': 1 };
+                assert.deepStrictEqual(func([path], [1]), expected);
+            });
+        });
+
+        it(`\`_.${methodName}\` should work in a lazy sequence`, () => {
+            const values = lodashStable.range(LARGE_ARRAY_SIZE),
+                props = lodashStable.map(values, (value) => `key${value}`),
+                actual = _(props)[methodName](values).map(square).filter(isEven).take().value();
+
+            assert.deepEqual(actual, _.take(_.filter(_.map(func(props, values), square), isEven)));
+        });
+    });
+});