wip: migrate to bun

test/create.spec.ts

@@ -0,0 +1,100 @@
+import assert from 'node:assert';
+import lodashStable from 'lodash';
+import { falsey, primitives, stubTrue } from './utils';
+import create from '../src/create';
+import keys from '../src/keys';
+
+describe('create', () => {
+    function Shape() {
+        this.x = 0;
+        this.y = 0;
+    }
+
+    function Circle() {
+        Shape.call(this);
+    }
+
+    it('should create an object that inherits from the given `prototype` object', () => {
+        Circle.prototype = create(Shape.prototype);
+        Circle.prototype.constructor = Circle;
+
+        const actual = new Circle();
+
+        assert.ok(actual instanceof Circle);
+        assert.ok(actual instanceof Shape);
+        assert.notStrictEqual(Circle.prototype, Shape.prototype);
+    });
+
+    it('should assign `properties` to the created object', () => {
+        const expected = { constructor: Circle, radius: 0 };
+        const properties = Object.keys(expected);
+        Circle.prototype = create(Shape.prototype, expected);
+
+        const actual = new Circle();
+
+        assert.ok(actual instanceof Circle);
+        assert.ok(actual instanceof Shape);
+        assert.deepStrictEqual(Object.keys(Circle.prototype), properties);
+        properties.forEach((property) => {
+            assert.strictEqual(Circle.prototype[property], expected[property]);
+        });
+    });
+
+    it('should assign own properties', () => {
+        function Foo() {
+            this.a = 1;
+            this.c = 3;
+        }
+        Foo.prototype.b = 2;
+
+        const actual = create({}, new Foo());
+        const expected = { a: 1, c: 3 };
+        const properties = Object.keys(expected);
+
+        assert.deepStrictEqual(Object.keys(actual), properties);
+        properties.forEach((property) => {
+            assert.strictEqual(actual[property], expected[property]);
+        });
+    });
+
+    it('should assign properties that shadow those of `prototype`', () => {
+        function Foo() {
+            this.a = 1;
+        }
+        const object = create(new Foo(), { a: 1 });
+        assert.deepStrictEqual(lodashStable.keys(object), ['a']);
+    });
+
+    it('should accept a falsey `prototype`', () => {
+        const actual = lodashStable.map(falsey, (prototype, index) =>
+            index ? create(prototype) : create(),
+        );
+
+        actual.forEach((value) => {
+            assert.ok(lodashStable.isObject(value));
+        });
+    });
+
+    it('should accept a primitive `prototype`', () => {
+        const actual = lodashStable.map(primitives, (value, index) =>
+            index ? create(value) : create(),
+        );
+
+        actual.forEach((value) => {
+            assert.ok(lodashStable.isObject(value));
+        });
+    });
+
+    it('should work as an iteratee for methods like `_.map`', () => {
+        const array = [{ a: 1 }, { a: 1 }, { a: 1 }],
+            expected = lodashStable.map(array, stubTrue),
+            objects = lodashStable.map(array, create);
+
+        const actual = lodashStable.map(
+            objects,
+            (object) => object.a === 1 && !keys(object).length,
+        );
+
+        assert.deepStrictEqual(actual, expected);
+    });
+});