@wwawing/util 4.1.0-save-bug-fix.based-on.3.12.17.p.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 1996-2025 NAO
+Copyright (c) 2015-2025 WWA Wing Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/jest.config.ts

@@ -0,0 +1,27 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/configuration
+ */
+export default {
+  clearMocks: true,
+  moduleFileExtensions: [
+    "js",
+    "ts",
+    "json",
+  ],
+  roots: [
+    "<rootDir>/src"
+  ],
+  testEnvironment: "jsdom",
+  testPathIgnorePatterns: [
+    "/node_modules/"
+  ],
+  testRegex: ["__tests__/.*|\\.test\\.(js|ts)"],
+  transform: {
+    "^.+\\.(j|t)s$": ["@swc/jest", require("../../swcConfig")]
+  },
+  transformIgnorePatterns: [
+    "/node_modules/",
+  ],
+  unmockedModulePathPatterns: ["node_modules/*"],
+};

package/lib/__tests__/mapToObject-test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/mapToObject-test.js

@@ -0,0 +1,102 @@
+import { convertMapToObject } from "../mapToObject";
+describe("convertMapToObject", () => {
+    it("プリミティブを変換すると、同じ内容のプリミティブになる", () => {
+        expect(convertMapToObject(true)).toStrictEqual(true);
+        expect(convertMapToObject(false)).toStrictEqual(false);
+        expect(convertMapToObject(42)).toStrictEqual(42);
+        expect(convertMapToObject(1e99)).toStrictEqual(1e99);
+        expect(convertMapToObject(BigInt("12345678909876543210"))).toStrictEqual(BigInt("12345678909876543210"));
+        expect(convertMapToObject("🍣")).toStrictEqual("🍣");
+        expect(convertMapToObject(undefined)).toBeUndefined();
+        expect(convertMapToObject(null)).toBeNull();
+    });
+    it("配列を変換すると、同じ内容の配列になる", () => {
+        expect(convertMapToObject([1, 2, 3])).toStrictEqual([1, 2, 3]);
+    });
+    it("Mapを変換すると、オブジェクトになる", () => {
+        const result = convertMapToObject(new Map([
+            ["foo", "bar"],
+            ["hoge", 31415],
+        ]));
+        expect(result).toMatchObject({
+            foo: "bar",
+            hoge: 31415,
+        });
+    });
+    it("Mapを変換したとき、オブジェクトになっても同じ参照は維持される", () => {
+        const refA = new Map([
+            ["foo", new Map([["bar", null]])],
+        ]);
+        const result = convertMapToObject(new Map([
+            ["ref1", refA],
+            ["ref2", refA],
+            [
+                "ref3",
+                new Map([
+                    ["foo", new Map([["bar", null]])],
+                ]),
+            ],
+        ]));
+        expect(result.ref1 === result.ref2).toBeTruthy();
+        expect(result.ref1 === result.ref3).toBeFalsy();
+        expect(result.ref2 === result.ref3).toBeFalsy();
+    });
+    it("循環参照を変換できる", () => {
+        const refA = new Map();
+        refA.set("next", refA);
+        const result = convertMapToObject(refA);
+        expect(result.next === result).toBeTruthy();
+    });
+    it("空Mapを変換できる", () => {
+        const result = convertMapToObject(new Map());
+        expect(result).toMatchObject({});
+    });
+    it("配列とMapネストしていても変換できる", () => {
+        var _a, _b, _c;
+        const refA = new Map([
+            ["foo", new Map([["bar", null]])],
+        ]);
+        const refB = [
+            new Map([
+                ["ref1", refA],
+                ["ref2", refA],
+                [
+                    "ref3",
+                    new Map([
+                        ["foo", new Map([["bar", null]])],
+                    ]),
+                ],
+                [
+                    "ref4",
+                    [
+                        new Map([
+                            [
+                                "test1",
+                                new Map([
+                                    ["test2", new Map([["test3", new Map()]])],
+                                ]),
+                            ],
+                        ]),
+                    ],
+                ],
+            ]),
+            refA,
+        ];
+        (_a = refA.get("foo")) === null || _a === void 0 ? void 0 : _a.set("bar", refB);
+        const result = convertMapToObject(refB);
+        expect(result).toBeInstanceOf(Array);
+        const result0 = result[0];
+        expect(result0.ref1 === result0.ref2).toBeTruthy();
+        expect(result0.ref1 === result0.ref3).toBeFalsy();
+        expect(result0.ref2 === result0.ref3).toBeFalsy();
+        expect(result0.ref1 === result[1]).toBeTruthy();
+        expect(((_c = (_b = result0.ref1) === null || _b === void 0 ? void 0 : _b.foo) === null || _c === void 0 ? void 0 : _c.bar) === result).toBeTruthy();
+        expect(result0.ref4).toMatchObject([{
+                test1: {
+                    test2: {
+                        test3: {},
+                    },
+                },
+            }]);
+    });
+});

package/lib/__tests__/objectToMap-test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/objectToMap-test.js

@@ -0,0 +1,90 @@
+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([1, 2, 3])).toStrictEqual([1, 2, 3]);
+    });
+    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: 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("配列とオブジェクトがネストしていても変換できる", () => {
+        var _a, _b;
+        const refA = { foo: { bar: null } };
+        const refB = [{
+                ref1: refA,
+                ref2: refA,
+                ref3: { foo: { bar: null } },
+                ref4: [{ test1: { test2: { test3: {} } } }]
+            }, refA];
+        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 = (_b = (_a = resultRef4_0.get("test1")) === null || _a === void 0 ? void 0 : _a.get("test2")) === null || _b === void 0 ? void 0 : _b.get("test3");
+        if (!(maybeEmptyMap instanceof Map)) {
+            fail("変換結果の ref4[0].test1.test2.test3 が Map になっていません！");
+        }
+        expect(maybeEmptyMap.size).toBe(0);
+    });
+});

package/lib/_common/index.d.ts

@@ -0,0 +1 @@
+export type Primitive = number | string | boolean | bigint | undefined | null;

package/lib/_common/index.js

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { convertObjectToMap, type ObjectToMap } from "./objectToMap";
+export { convertMapToObject, } from "./mapToObject";

package/lib/index.js

@@ -0,0 +1,2 @@
+export { convertObjectToMap } from "./objectToMap";
+export { convertMapToObject, } from "./mapToObject";

package/lib/mapToObject.d.ts

@@ -0,0 +1,7 @@
+import type { Primitive } from "./_common";
+type SeenRefMap = WeakMap<Map<string, unknown> | Array<unknown>, unknown>;
+export declare function convertMapToObject<T extends Primitive>(input: T, seen?: SeenRefMap): T;
+export declare function convertMapToObject<T extends ReadonlyArray<unknown>>(input: T, seen?: SeenRefMap): ReadonlyArray<unknown>;
+export declare function convertMapToObject<T extends Array<unknown>>(input: T, seen?: SeenRefMap): Array<unknown>;
+export declare function convertMapToObject<T extends Map<string, unknown>>(input: T, seen?: SeenRefMap): Record<string, unknown>;
+export {};

package/lib/mapToObject.js

@@ -0,0 +1,31 @@
+export function convertMapToObject(input, seen = new WeakMap()) {
+    if (typeof input === "symbol") {
+        throw new TypeError("symbol は変換対象外です");
+    }
+    if (input instanceof Map) {
+        if (seen.has(input)) {
+            return seen.get(input);
+        }
+        const obj = Object.create(null);
+        seen.set(input, obj);
+        for (const [key, value] of input.entries()) {
+            obj[key] = convertMapToObject(value, seen);
+        }
+        return obj;
+    }
+    if (Array.isArray(input)) {
+        if (seen.has(input)) {
+            return seen.get(input);
+        }
+        const arr = [];
+        seen.set(input, arr);
+        for (const item of input) {
+            arr.push(convertMapToObject(item, seen));
+        }
+        return arr;
+    }
+    if (typeof input === 'object' && input !== null) {
+        throw new TypeError("Mapおよび配列でないオブジェクトは変換対象外です");
+    }
+    return input;
+}

package/lib/objectToMap.d.ts

@@ -0,0 +1,10 @@
+import type { Primitive } from "./_common";
+type SeenRefMap = WeakMap<object, unknown>;
+export type ObjectToMap<T> = UnionToIntersection<T extends Primitive ? T : T extends ReadonlyArray<infer U> ? ReadonlyArray<ObjectToMap<U>> : T extends Array<infer U> ? Array<ObjectToMap<U>> : T extends object ? Record<never, never> extends T ? Map<string, never> : {
+    [K in keyof T]: Map<K, ObjectToMap<T[K]>>;
+}[keyof T] : never>;
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer R) => void ? R : never;
+export declare function convertObjectToMap<T extends Primitive>(input: T, seen?: SeenRefMap): T;
+export declare function convertObjectToMap<T extends Array<unknown>>(input: T, seen?: SeenRefMap): T;
+export declare function convertObjectToMap<T extends Exclude<object, null>>(input: T, seen?: SeenRefMap): ObjectToMap<T>;
+export {};

package/lib/objectToMap.js

@@ -0,0 +1,28 @@
+export function convertObjectToMap(input, seen = new WeakMap()) {
+    if (typeof input === "symbol") {
+        throw new TypeError("symbol は変換対象外です");
+    }
+    if (typeof input !== "object" || input === null) {
+        return input;
+    }
+    if (seen.has(input)) {
+        return seen.get(input);
+    }
+    if (Array.isArray(input)) {
+        const arr = [];
+        seen.set(input, arr);
+        for (const item of input) {
+            arr.push(convertObjectToMap(item, seen));
+        }
+        return arr;
+    }
+    const map = new Map();
+    seen.set(input, map);
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof key !== "string") {
+            throw new TypeError("文字列以外のキーは変換できません");
+        }
+        map.set(key, convertObjectToMap(value, seen));
+    }
+    return map;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@wwawing/util",
+  "version": "4.1.0-save-bug-fix.based-on.3.12.17.p.1",
+  "description": "WWA Wing utility package",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "shx rm -rf lib && tsc -p .",
+    "test": "jest"
+  },
+  "author": "WWA Wing Team",
+  "license": "MIT",
+  "devDependencies": {
+    "@swc/core": "^1.10.4",
+    "@swc/jest": "^0.2.37",
+    "jest": "^29.5.0",
+    "jest-cli": "^29.5.0",
+    "jest-environment-jsdom": "^29.5.0",
+    "shelljs": "^0.9.2",
+    "shx": "^0.4.0",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "eeda902be8443fb2eb84694501dbe7a2552cb5ce"
+}

package/src/__tests__/mapToObject-test.ts

@@ -0,0 +1,116 @@
+import { convertMapToObject } from "../mapToObject";
+
+describe("convertMapToObject", () => {
+  it("プリミティブを変換すると、同じ内容のプリミティブになる", () => {
+    expect(convertMapToObject(true)).toStrictEqual(true);
+    expect(convertMapToObject(false)).toStrictEqual(false);
+    expect(convertMapToObject(42)).toStrictEqual(42);
+    expect(convertMapToObject(1e99)).toStrictEqual(1e99);
+    expect(convertMapToObject(BigInt("12345678909876543210"))).toStrictEqual(
+      BigInt("12345678909876543210")
+    );
+    expect(convertMapToObject("🍣")).toStrictEqual("🍣");
+    expect(convertMapToObject(undefined)).toBeUndefined();
+    expect(convertMapToObject(null)).toBeNull();
+  });
+  it("配列を変換すると、同じ内容の配列になる", () => {
+    expect(convertMapToObject([1, 2, 3])).toStrictEqual([1, 2, 3]);
+  });
+  it("Mapを変換すると、オブジェクトになる", () => {
+    const result = convertMapToObject(
+      new Map<string, unknown>([
+        ["foo", "bar"],
+        ["hoge", 31415],
+      ])
+    );
+    expect(result).toMatchObject({
+      foo: "bar",
+      hoge: 31415,
+    });
+  });
+  it("Mapを変換したとき、オブジェクトになっても同じ参照は維持される", () => {
+    const refA = new Map<string, unknown>([
+      ["foo", new Map<string, unknown>([["bar", null]])],
+    ]);
+    const result = convertMapToObject(
+      new Map<string, unknown>([
+        ["ref1", refA],
+        ["ref2", refA],
+        [
+          "ref3",
+          new Map<string, unknown>([
+            ["foo", new Map<string, unknown>([["bar", null]])],
+          ]),
+        ], // 異なる参照
+      ])
+    );
+    expect(result.ref1 === result.ref2).toBeTruthy();
+    expect(result.ref1 === result.ref3).toBeFalsy();
+    expect(result.ref2 === result.ref3).toBeFalsy();
+  });
+  it("循環参照を変換できる", () => {
+    const refA = new Map();
+    refA.set("next", refA);
+    const result = convertMapToObject(refA);
+    expect(result.next === result).toBeTruthy();
+  });
+  it("空Mapを変換できる", () => {
+    const result = convertMapToObject(new Map());
+    expect(result).toMatchObject({});
+  });
+  it("配列とMapネストしていても変換できる", () => {
+    const refA = new Map<"foo", Map<"bar", unknown>>([
+      ["foo", new Map([["bar", null]])],
+    ]);
+    const refB = [
+      new Map<"ref1" | "ref2" | "ref3" | "ref4", unknown>([
+        ["ref1", refA],
+        ["ref2", refA],
+        [
+          "ref3",
+          new Map<string, unknown>([
+            ["foo", new Map([["bar", null]])],
+          ]),
+        ],
+        [
+          "ref4",
+          [
+            new Map<"test1", Map<"test2", Map<"test3", unknown>>>([
+              [
+                "test1",
+                new Map([
+                  ["test2", new Map([["test3", new Map()]])],
+                ]),
+              ],
+            ]),
+          ],
+        ],
+      ]),
+      refA,
+    ];
+    refA.get("foo")?.set("bar", refB);
+    const result = convertMapToObject(refB);
+    expect(result).toBeInstanceOf(Array);
+    // convertMapToObject の戻り値の型は妥協しているので仕方ない
+    // また、Map に一度変換している関係で, 値は Optional になる
+    // 本来は値を評価する前にバリデーションをするのが望ましいが、まぁテストなので...
+    const result0 = result[0] as {
+      ref1?: { foo?: { bar?: unknown } };
+      ref2?: { foo?: { bar?: unknown } };
+      ref3?: { foo?: { bar?: unknown } };
+      ref4?: unknown;
+    };
+    expect(result0.ref1 === result0.ref2).toBeTruthy();
+    expect(result0.ref1 === result0.ref3).toBeFalsy();
+    expect(result0.ref2 === result0.ref3).toBeFalsy();
+    expect(result0.ref1 === result[1]).toBeTruthy();
+    expect(result0.ref1?.foo?.bar === result).toBeTruthy();
+    expect(result0.ref4).toMatchObject([{
+      test1: {
+        test2: {
+          test3: {},
+        },
+      },
+    }]);
+  });
+});

package/src/__tests__/objectToMap-test.ts

@@ -0,0 +1,91 @@
+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([1, 2, 3])).toStrictEqual([1, 2, 3])
+    });
+    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);
+    })
+
+})

package/src/_common/index.ts

@@ -0,0 +1,2 @@
+// symbol は対象外です
+export type Primitive = number | string | boolean | bigint | undefined | null;

package/src/index.ts

@@ -0,0 +1,2 @@
+export { convertObjectToMap, type ObjectToMap } from "./objectToMap";
+export { convertMapToObject, } from "./mapToObject";

package/src/mapToObject.ts

@@ -0,0 +1,58 @@
+import type { Primitive } from "./_common";
+
+type SeenRefMap = WeakMap<Map<string, unknown> | Array<unknown>, unknown>;
+
+// WWA ではパスワードセーブに利用されるのみであり、雑な型をつけても特に差し支えない。
+// 保守コストを下げる意味でも雑な型を付けるに留める。
+export function convertMapToObject<T extends Primitive>(
+  input: T,
+  seen?: SeenRefMap 
+): T;
+export function convertMapToObject<T extends ReadonlyArray<unknown>>(
+  input: T,
+  seen?:SeenRefMap 
+): ReadonlyArray<unknown>;
+export function convertMapToObject<T extends Array<unknown>>(
+  input: T,
+  seen?:SeenRefMap 
+): Array<unknown>;
+export function convertMapToObject<T extends Map<string, unknown>>(
+  input: T,
+  seen?:SeenRefMap
+): Record<string, unknown>;
+export function convertMapToObject(input: unknown, seen = new WeakMap<Map<string, unknown> | Array<unknown>, unknown>()): any {
+  if (typeof input === "symbol") {
+    throw new TypeError("symbol は変換対象外です")
+  }
+
+  if (input instanceof Map) {
+    if (seen.has(input)) {
+        return seen.get(input);
+    }
+    const obj: { [key: string]: unknown } = Object.create(null);
+    seen.set(input, obj);
+    for (const [key, value] of input.entries()) {
+      obj[key] = convertMapToObject(value, seen);
+    }
+    return obj;
+  }
+
+  if (Array.isArray(input)) {
+    if (seen.has(input)) {
+      return seen.get(input);
+    }
+    const arr: unknown[] = [];
+    seen.set(input, arr);
+    for (const item of input) {
+      arr.push(convertMapToObject(item, seen));
+    }
+    return arr;
+  }
+
+  if (typeof input === 'object' && input !== null) {
+    throw new TypeError("Mapおよび配列でないオブジェクトは変換対象外です");
+  } 
+
+  // プリミティブ
+  return input; 
+}

package/src/objectToMap.ts

@@ -0,0 +1,69 @@
+import type { Primitive } from "./_common";
+
+type SeenRefMap = WeakMap<object, unknown>;
+export type ObjectToMap<T> = UnionToIntersection<
+  T extends Primitive
+    ? T
+    : T extends ReadonlyArray<infer U>
+    ? ReadonlyArray<ObjectToMap<U>>
+    : T extends Array<infer U>
+    ? Array<ObjectToMap<U>>
+    : T extends object
+    ? Record<never, never> extends T
+      ? Map<string, never>
+      : {
+          [K in keyof T]: Map<K, ObjectToMap<T[K]>>;
+        }[keyof T]
+    : never
+>;
+
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (
+  x: infer R
+) => void
+  ? R
+  : never;
+
+export function convertObjectToMap<T extends Primitive>(
+  input: T,
+  seen?: SeenRefMap
+): T;
+export function convertObjectToMap<T extends Array<unknown>>(
+  input: T,
+  seen?: SeenRefMap
+): T;
+export function convertObjectToMap<T extends Exclude<object, null>>(
+  input: T,
+  seen?: SeenRefMap
+): ObjectToMap<T>;
+export function convertObjectToMap(
+  input: unknown,
+  seen = new WeakMap<object, unknown>()
+): unknown {
+  if (typeof input === "symbol") {
+    throw new TypeError("symbol は変換対象外です")
+  }
+  if (typeof input !== "object" || input === null) {
+    return input;
+  }
+  if (seen.has(input)) {
+    return seen.get(input);
+  }
+  if (Array.isArray(input)) {
+    const arr: unknown[] = [];
+    seen.set(input, arr);
+    for (const item of input) {
+      arr.push(convertObjectToMap(item, seen));
+    }
+    return arr;
+  }
+
+  const map = new Map<string, unknown>();
+  seen.set(input, map);
+  for (const [key, value] of Object.entries(input)) {
+    if (typeof key !== "string") {
+      throw new TypeError("文字列以外のキーは変換できません");
+    }
+    map.set(key, convertObjectToMap(value, seen));
+  }
+  return map;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./lib",
+    "module": "esnext",
+    "strict": true,
+    "noImplicitAny": true,
+  },
+  "include": [
+    "src/**/*.ts",
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}