@wwawing/util 4.1.0-save-bug-fix.based-on.3.12.18.p.4 → 4.1.0-unstable.based-on.3.12.18.p.2

package/lib/__tests__/objectToMap-test.js

@@ -4,7 +4,7 @@ describe("convertObjectToMap", () => {
         expect(convertObjectToMap(true)).toStrictEqual(true);
         expect(convertObjectToMap(false)).toStrictEqual(false);
         expect(convertObjectToMap(42)).toStrictEqual(42);
-        expect(convertObjectToMap(1e+99)).toStrictEqual(1e+99);
+        expect(convertObjectToMap(1e99)).toStrictEqual(1e99);
         expect(convertObjectToMap(BigInt("12345678909876543210"))).toStrictEqual(BigInt("12345678909876543210"));
         expect(convertObjectToMap("🍣")).toStrictEqual("🍣");
         expect(convertObjectToMap(undefined)).toBeUndefined();
@@ -16,7 +16,7 @@ describe("convertObjectToMap", () => {
     it("オブジェクトを変換すると、Mapになる", () => {
         const result = convertObjectToMap({
             foo: "bar",
-            hoge: 31415
+            hoge: 31415,
         });
         expect(result).toBeInstanceOf(Map);
         expect(result.get("foo")).toEqual("bar");
@@ -49,12 +49,15 @@ describe("convertObjectToMap", () => {
     it("配列とオブジェクトがネストしていても変換できる", () => {
         var _a, _b;
         const refA = { foo: { bar: null } };
-        const refB = [{
+        const refB = [
+            {
                 ref1: refA,
                 ref2: refA,
                 ref3: { foo: { bar: null } },
-                ref4: [{ test1: { test2: { test3: {} } } }]
-            }, refA];
+                ref4: [{ test1: { test2: { test3: {} } } }],
+            },
+            refA,
+        ];
         refA.foo.bar = refB;
         const result = convertObjectToMap(refB);
         expect(result).toBeInstanceOf(Array);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwawing/util",
-  "version": "4.1.0-save-bug-fix.based-on.3.12.18.p.4",
+  "version": "4.1.0-unstable.based-on.3.12.18.p.2",
   "description": "WWA Wing utility package",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5fb0e7d3170e06bfc1e626fbb8f32b28c11de4d5"
+  "gitHead": "55a800eaaf1d95169d9c5f359240457ca3fd612f"
 }

package/src/__tests__/objectToMap-test.ts

@@ -1,91 +1,95 @@
-import { convertObjectToMap } from "../objectToMap"
+import { convertObjectToMap } from "../objectToMap";
 
 describe("convertObjectToMap", () => {
-    it("プリミティブを変換すると、同じ内容のプリミティブになる", () => {
-        expect(convertObjectToMap(true)).toStrictEqual(true);
-        expect(convertObjectToMap(false)).toStrictEqual(false);
-        expect(convertObjectToMap(42)).toStrictEqual(42);
-        expect(convertObjectToMap(1e+99)).toStrictEqual(1e+99);
-        expect(convertObjectToMap(BigInt("12345678909876543210"))).toStrictEqual(BigInt("12345678909876543210"));
-        expect(convertObjectToMap("🍣")).toStrictEqual("🍣");
-        expect(convertObjectToMap(undefined)).toBeUndefined();
-        expect(convertObjectToMap(null)).toBeNull();
+  it("プリミティブを変換すると、同じ内容のプリミティブになる", () => {
+    expect(convertObjectToMap(true)).toStrictEqual(true);
+    expect(convertObjectToMap(false)).toStrictEqual(false);
+    expect(convertObjectToMap(42)).toStrictEqual(42);
+    expect(convertObjectToMap(1e99)).toStrictEqual(1e99);
+    expect(convertObjectToMap(BigInt("12345678909876543210"))).toStrictEqual(
+      BigInt("12345678909876543210")
+    );
+    expect(convertObjectToMap("🍣")).toStrictEqual("🍣");
+    expect(convertObjectToMap(undefined)).toBeUndefined();
+    expect(convertObjectToMap(null)).toBeNull();
+  });
+  it("配列を変換すると、同じ内容の配列になる", () => {
+    expect(convertObjectToMap([1, 2, 3])).toStrictEqual([1, 2, 3]);
+  });
+  it("オブジェクトを変換すると、Mapになる", () => {
+    const result = convertObjectToMap({
+      foo: "bar",
+      hoge: 31415,
     });
-    it("配列を変換すると、同じ内容の配列になる", () => {
-        expect(convertObjectToMap([1, 2, 3])).toStrictEqual([1, 2, 3])
+    expect(result).toBeInstanceOf(Map);
+    expect(result.get("foo")).toEqual("bar");
+    expect(result.get("hoge")).toEqual(31415);
+  });
+  it("オブジェクトを変換したとき、Mapになっても同じ参照は維持される", () => {
+    const refA = { foo: { bar: null } };
+    const result = convertObjectToMap({
+      ref1: refA,
+      ref2: refA,
+      ref3: { foo: { bar: null } }, // 異なる参照
     });
-    it("オブジェクトを変換すると、Mapになる", () => {
-        const result = convertObjectToMap({
-            foo: "bar",
-            hoge: 31415
-        });
-        expect(result).toBeInstanceOf(Map);
-        expect(result.get("foo")).toEqual("bar");
-        expect(result.get("hoge")).toEqual(31415);
-    });
-    it("オブジェクトを変換したとき、Mapになっても同じ参照は維持される", () => {
-        const refA = { foo: { bar: null } };
-        const result = convertObjectToMap({
-          ref1: refA,
-          ref2: refA,
-          ref3: { foo: { bar: null } }, // 異なる参照
-        });
-        expect(result).toBeInstanceOf(Map);
-        expect(result.get("ref1") === result.get("ref2")).toBeTruthy();
-        expect(result.get("ref1") === result.get("ref3")).toBeFalsy();
-        expect(result.get("ref2") === result.get("ref3")).toBeFalsy();
-    });
-    it("循環参照を変換できる", () => {
-        const refA: { next: unknown } = { next: null };
-        refA.next = refA;
-        const result = convertObjectToMap(refA);
-        expect(result).toBeInstanceOf(Map);
-        expect(result.get("next") === result).toBeTruthy();
-    })
-    it("空オブジェクトを変換できる", () => {
-        const result = convertObjectToMap({});
-        expect(result).toBeInstanceOf(Map);
-        expect(result.size).toBe(0);
-    })
-    it("配列とオブジェクトがネストしていても変換できる", () => {
-        const refA = { foo: { bar: null as unknown } };
-        const refB = [{
-                ref1: refA,
-                ref2: refA,
-                ref3: { foo: { bar: null } }, 
-                ref4: [{test1: { test2: { test3: {} }}}]
-            }, refA] as const;
-        refA.foo.bar = refB;
-        const result = convertObjectToMap(refB)
-        expect(result).toBeInstanceOf(Array);
-        expect(result[0]).toBeInstanceOf(Map);
-        expect(result[0]).toBeInstanceOf(Map);
-        expect(result[0].get("ref1") === result[0].get("ref2")).toBeTruthy();
-        expect(result[0].get("ref1") === result[0].get("ref3")).toBeFalsy();
-        expect(result[0].get("ref2") === result[0].get("ref3")).toBeFalsy();
-        expect(result[0].get("ref1") === result[1]).toBeTruthy();
-        const resultRef1 = result[0].get("ref1");
-        if (!(resultRef1 instanceof Map)) {
-            fail("変換結果の ref1 が Map になっていません！");
-        }
-        const resultFoo = resultRef1.get("foo");
-        if (!(resultFoo instanceof Map)) {
-            fail("変換結果の foo が Map になっていません！");
-        }
-        expect(resultFoo.get("bar") === result).toBeTruthy();
-        const resultRef4 = result[0].get("ref4");
-        if (!(resultRef4 instanceof Array)) {
-            fail("変換結果の ref4 が Map になっていません！");
-        }
-        const resultRef4_0 = resultRef4[0];
-        if (!(resultRef4_0 instanceof Map)) {
-            fail("変換結果の ref4[0] が Map になっていません！");
-        }
-        const maybeEmptyMap = resultRef4_0.get("test1")?.get("test2")?.get("test3");
-        if (!(maybeEmptyMap instanceof Map)) {
-            fail("変換結果の ref4[0].test1.test2.test3 が Map になっていません！");
-        }
-        expect(maybeEmptyMap.size).toBe(0);
-    })
-
-})
+    expect(result).toBeInstanceOf(Map);
+    expect(result.get("ref1") === result.get("ref2")).toBeTruthy();
+    expect(result.get("ref1") === result.get("ref3")).toBeFalsy();
+    expect(result.get("ref2") === result.get("ref3")).toBeFalsy();
+  });
+  it("循環参照を変換できる", () => {
+    const refA: { next: unknown } = { next: null };
+    refA.next = refA;
+    const result = convertObjectToMap(refA);
+    expect(result).toBeInstanceOf(Map);
+    expect(result.get("next") === result).toBeTruthy();
+  });
+  it("空オブジェクトを変換できる", () => {
+    const result = convertObjectToMap({});
+    expect(result).toBeInstanceOf(Map);
+    expect(result.size).toBe(0);
+  });
+  it("配列とオブジェクトがネストしていても変換できる", () => {
+    const refA = { foo: { bar: null as unknown } };
+    const refB = [
+      {
+        ref1: refA,
+        ref2: refA,
+        ref3: { foo: { bar: null } },
+        ref4: [{ test1: { test2: { test3: {} } } }],
+      },
+      refA,
+    ] as const;
+    refA.foo.bar = refB;
+    const result = convertObjectToMap(refB);
+    expect(result).toBeInstanceOf(Array);
+    expect(result[0]).toBeInstanceOf(Map);
+    expect(result[0]).toBeInstanceOf(Map);
+    expect(result[0].get("ref1") === result[0].get("ref2")).toBeTruthy();
+    expect(result[0].get("ref1") === result[0].get("ref3")).toBeFalsy();
+    expect(result[0].get("ref2") === result[0].get("ref3")).toBeFalsy();
+    expect(result[0].get("ref1") === result[1]).toBeTruthy();
+    const resultRef1 = result[0].get("ref1");
+    if (!(resultRef1 instanceof Map)) {
+      fail("変換結果の ref1 が Map になっていません！");
+    }
+    const resultFoo = resultRef1.get("foo");
+    if (!(resultFoo instanceof Map)) {
+      fail("変換結果の foo が Map になっていません！");
+    }
+    expect(resultFoo.get("bar") === result).toBeTruthy();
+    const resultRef4 = result[0].get("ref4");
+    if (!(resultRef4 instanceof Array)) {
+      fail("変換結果の ref4 が Map になっていません！");
+    }
+    const resultRef4_0 = resultRef4[0];
+    if (!(resultRef4_0 instanceof Map)) {
+      fail("変換結果の ref4[0] が Map になっていません！");
+    }
+    const maybeEmptyMap = resultRef4_0.get("test1")?.get("test2")?.get("test3");
+    if (!(maybeEmptyMap instanceof Map)) {
+      fail("変換結果の ref4[0].test1.test2.test3 が Map になっていません！");
+    }
+    expect(maybeEmptyMap.size).toBe(0);
+  });
+});