@simplysm/core-common 13.0.99 → 14.0.1

package/tests/utils/wait.spec.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { wait, TimeoutError } from "@simplysm/core-common";
-
-describe("Wait", () => {
-  //#region time
-
-  describe("time()", () => {
-    it("Waits for specified time", async () => {
-      const start = Date.now();
-      await wait.time(100);
-      const elapsed = Date.now() - start;
-
-      // 100ms ± tolerance - CI environment load and timer precision considered
-      expect(elapsed).toBeGreaterThanOrEqual(95);
-      expect(elapsed).toBeLessThan(250);
-    });
-  });
-
-  //#endregion
-
-  //#region until
-
-  describe("until()", () => {
-    it("Waits until condition becomes true", async () => {
-      let count = 0;
-
-      await wait.until(() => {
-        count++;
-        return count >= 3;
-      }, 10);
-
-      expect(count).toBe(3);
-    });
-
-    it("Supports async condition function", async () => {
-      let count = 0;
-
-      await wait.until(async () => {
-        await wait.time(10);
-        count++;
-        return count >= 3;
-      }, 10);
-
-      expect(count).toBe(3);
-    });
-
-    it("Returns immediately if condition already true", async () => {
-      const start = Date.now();
-      await wait.until(() => true, 100);
-      const elapsed = Date.now() - start;
-
-      expect(elapsed).toBeLessThan(50);
-    });
-
-    it("Throws TimeoutError on max attempts exceeded", async () => {
-      let count = 0;
-
-      await expect(async () => {
-        await wait.until(
-          () => {
-            count++;
-            return false;
-          },
-          10,
-          5,
-        );
-      }).rejects.toThrow(TimeoutError);
-
-      expect(count).toBe(5);
-    });
-
-    it("Waits indefinitely if maxCount undefined", async () => {
-      let count = 0;
-
-      // Unlimited wait but returns when condition true
-      await wait.until(
-        () => {
-          count++;
-          return count >= 10;
-        },
-        10,
-        undefined,
-      );
-
-      expect(count).toBe(10);
-    });
-
-    it("Default milliseconds is 100ms", async () => {
-      let count = 0;
-      const start = Date.now();
-
-      await wait.until(() => {
-        count++;
-        return count >= 3;
-      });
-
-      const elapsed = Date.now() - start;
-      // 100ms * 2 waits = 200ms (first check immediate), timer tolerance considered
-      expect(elapsed).toBeGreaterThanOrEqual(190);
-      expect(elapsed).toBeLessThan(350);
-    });
-
-    it("With maxCount=1, tries once then errors", async () => {
-      let count = 0;
-
-      await expect(async () => {
-        await wait.until(
-          () => {
-            count++;
-            return false;
-          },
-          10,
-          1,
-        );
-      }).rejects.toThrow(TimeoutError);
-
-      expect(count).toBe(1);
-    });
-
-  });
-
-  //#endregion
-});

package/tests/utils/xml.spec.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { xml } from "@simplysm/core-common";
-
-describe("XmlConvert", () => {
-  //#region parse
-
-  describe("parse()", () => {
-    it("Parses basic XML", () => {
-      const xmlStr = "<root><child>value</child></root>";
-      const result = xml.parse(xmlStr) as Record<string, unknown>;
-
-      expect(result).toHaveProperty("root");
-    });
-
-    it("Parses XML with attributes", () => {
-      const xmlStr = '<root id="1"><child name="test">value</child></root>';
-      const result = xml.parse(xmlStr) as {
-        root: {
-          $: { id: string };
-          child: Array<{ $: { name: string }; _: string }>;
-        };
-      };
-
-      expect(result.root.$.id).toBe("1");
-      expect(result.root.child[0].$.name).toBe("test");
-    });
-
-    it("Parses nested XML", () => {
-      const xmlStr = "<root><parent><child>value</child></parent></root>";
-      const result = xml.parse(xmlStr) as {
-        root: { parent: Array<{ child: string[] }> };
-      };
-
-      expect(result.root.parent[0].child[0]).toBe("value");
-    });
-
-    it("Parses text nodes as _ key", () => {
-      const xmlStr = '<item id="1">text content</item>';
-      const result = xml.parse(xmlStr) as {
-        item: { $: { id: string }; _: string };
-      };
-
-      expect(result.item._).toBe("text content");
-    });
-
-    it("Removes namespace prefix (stripTagPrefix: true)", () => {
-      const xmlStr = "<ns:root><ns:child>value</ns:child></ns:root>";
-      const result = xml.parse(xmlStr, { stripTagPrefix: true }) as {
-        root: { child: string[] };
-      };
-
-      expect(result).toHaveProperty("root");
-      expect(result.root).toHaveProperty("child");
-    });
-
-    it("Preserves namespace prefix (default)", () => {
-      const xmlStr = "<ns:root><ns:child>value</ns:child></ns:root>";
-      const result = xml.parse(xmlStr) as Record<string, unknown>;
-
-      expect(result).toHaveProperty("ns:root");
-    });
-
-    it("Parses multiple same tags as array", () => {
-      const xmlStr = "<root><item>1</item><item>2</item><item>3</item></root>";
-      const result = xml.parse(xmlStr) as { root: { item: string[] } };
-
-      expect(result.root.item).toEqual(["1", "2", "3"]);
-    });
-
-    it("Does not remove namespace prefix from attributes", () => {
-      const xmlStr = '<ns:root xmlns:ns="http://example.com"><ns:child>value</ns:child></ns:root>';
-      const result = xml.parse(xmlStr, { stripTagPrefix: true }) as {
-        root: { $: Record<string, string>; child: string[] };
-      };
-
-      expect(result.root.$).toHaveProperty("xmlns:ns");
-    });
-  });
-
-  //#endregion
-
-  //#region stringify
-
-  describe("stringify()", () => {
-    it("Serializes object to XML", () => {
-      const obj = { root: { child: "value" } };
-      const result = xml.stringify(obj);
-
-      expect(result).toContain("<root>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</root>");
-    });
-
-    it("Serializes object with attributes", () => {
-      const obj = { root: { $: { id: "1" }, child: "value" } };
-      const result = xml.stringify(obj);
-
-      expect(result).toContain('id="1"');
-      expect(result).toContain("<child>value</child>");
-    });
-
-    it("Serializes array as multiple tags", () => {
-      const obj = { root: { item: ["1", "2", "3"] } };
-      const result = xml.stringify(obj);
-
-      expect(result).toContain("<item>1</item>");
-      expect(result).toContain("<item>2</item>");
-      expect(result).toContain("<item>3</item>");
-    });
-
-    it("Serializes text node as _ key", () => {
-      const obj = { item: { $: { id: "1" }, _: "text content" } };
-      const result = xml.stringify(obj);
-
-      expect(result).toContain('id="1"');
-      expect(result).toContain("text content");
-    });
-
-    it("Serializes nested object", () => {
-      const obj = { root: { parent: { child: "value" } } };
-      const result = xml.stringify(obj);
-
-      expect(result).toContain("<parent>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</parent>");
-    });
-  });
-
-  //#endregion
-
-  //#region roundtrip
-
-  describe("parse/stringify roundtrip", () => {
-    it("Structure preserved after parse then stringify", () => {
-      const xmlStr = "<root><child>value</child></root>";
-      const parsed = xml.parse(xmlStr);
-      const result = xml.stringify(parsed);
-
-      expect(result).toContain("<root>");
-      expect(result).toContain("<child>value</child>");
-      expect(result).toContain("</root>");
-    });
-  });
-
-  //#endregion
-});

package/tests/utils/zip.spec.ts

@@ -1,221 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ZipArchive } from "@simplysm/core-common";
-
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-describe("ZipArchive", () => {
-  //#region write + compress
-
-  describe("write + compress", () => {
-    it("adds files with write and creates ZIP with compress", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-
-      const zipBuffer = await zip.compress();
-
-      expect(zipBuffer instanceof Uint8Array).toBe(true);
-      expect(zipBuffer.length).toBeGreaterThan(0);
-    });
-
-    it("handles filenames with special characters", async () => {
-      const zip = new ZipArchive();
-      zip.write("파일 이름.txt", encoder.encode("한글 내용"));
-      zip.write("file (1).txt", encoder.encode("괄호 포함"));
-      zip.write("file@#$.txt", encoder.encode("특수문자"));
-
-      const zipBuffer = await zip.compress();
-      const result = new ZipArchive(zipBuffer);
-
-      const content1 = await result.get("파일 이름.txt");
-      const content2 = await result.get("file (1).txt");
-      const content3 = await result.get("file@#$.txt");
-
-      expect(content1 != null ? decoder.decode(content1) : undefined).toBe("한글 내용");
-      expect(content2 != null ? decoder.decode(content2) : undefined).toBe("괄호 포함");
-      expect(content3 != null ? decoder.decode(content3) : undefined).toBe("특수문자");
-    });
-
-    it("can compress empty ZIP", async () => {
-      const zip = new ZipArchive();
-      const zipBuffer = await zip.compress();
-
-      expect(zipBuffer instanceof Uint8Array).toBe(true);
-    });
-
-    it("overwrites when writing same filename multiple times", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("first"));
-      zip.write("file.txt", encoder.encode("second"));
-
-      const zipBuffer = await zip.compress();
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("file.txt");
-
-      expect(content != null ? decoder.decode(content) : undefined).toBe("second");
-    });
-  });
-
-  //#endregion
-
-  //#region extractAll
-
-  describe("extractAll", () => {
-    it("extracts all compressed files", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const files = await result.extractAll();
-
-      expect(files.size).toBe(2);
-      expect(
-        files.get("file1.txt") != null ? decoder.decode(files.get("file1.txt")) : undefined,
-      ).toBe("content 1");
-      expect(
-        files.get("file2.txt") != null ? decoder.decode(files.get("file2.txt")) : undefined,
-      ).toBe("content 2");
-    });
-
-    it("calls progress callback", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("a".repeat(1000)));
-      zip.write("file2.txt", encoder.encode("b".repeat(1000)));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const progressCalls: Array<{ fileName: string; extractedSize: number }> = [];
-
-      await result.extractAll((progress) => {
-        progressCalls.push({
-          fileName: progress.fileName,
-          extractedSize: progress.extractedSize,
-        });
-      });
-
-      expect(progressCalls.length).toBeGreaterThan(0);
-      expect(progressCalls.some((p) => p.fileName === "file1.txt")).toBe(true);
-      expect(progressCalls.some((p) => p.fileName === "file2.txt")).toBe(true);
-    });
-
-    it("returns empty cache when reader is not available", async () => {
-      const zip = new ZipArchive();
-      const files = await zip.extractAll();
-
-      expect(files.size).toBe(0);
-    });
-  });
-
-  //#endregion
-
-  //#region get
-
-  describe("get", () => {
-    it("extracts specific file only", async () => {
-      const zip = new ZipArchive();
-      zip.write("file1.txt", encoder.encode("content 1"));
-      zip.write("file2.txt", encoder.encode("content 2"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("file1.txt");
-
-      expect(content != null ? decoder.decode(content) : undefined).toBe("content 1");
-    });
-
-    it("returns undefined for non-existent file", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content = await result.get("nonexistent.txt");
-
-      expect(content).toBe(undefined);
-    });
-
-    it("does not re-extract cached file", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const content1 = await result.get("file.txt");
-      const content2 = await result.get("file.txt");
-
-      expect(content1).toBe(content2); // Same reference
-    });
-
-    it("returns undefined when reader is not available", async () => {
-      const zip = new ZipArchive();
-      const content = await zip.get("file.txt");
-
-      expect(content).toBe(undefined);
-    });
-  });
-
-  //#endregion
-
-  //#region exists
-
-  describe("exists", () => {
-    it("checks file existence", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      const exists = await result.exists("file.txt");
-      const notExists = await result.exists("nonexistent.txt");
-
-      expect(exists).toBe(true);
-      expect(notExists).toBe(false);
-    });
-
-    it("returns false when reader is not available", async () => {
-      const zip = new ZipArchive();
-      const exists = await zip.exists("file.txt");
-
-      expect(exists).toBe(false);
-    });
-  });
-
-  //#endregion
-
-  //#region close
-
-  describe("close", () => {
-    it("closes reader", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      const result = new ZipArchive(zipBuffer);
-      // Call extractAll to load into cache
-      await result.extractAll();
-      await result.close();
-
-      // Cached data is still available after close
-      const content = await result.get("file.txt");
-      expect(content != null ? decoder.decode(content) : undefined).toBe("content");
-    });
-
-    it("automatically closes with await using statement", async () => {
-      const zip = new ZipArchive();
-      zip.write("file.txt", encoder.encode("content"));
-      const zipBuffer = await zip.compress();
-
-      {
-        await using result = new ZipArchive(zipBuffer);
-        await result.extractAll();
-        const content = await result.get("file.txt");
-        expect(decoder.decode(content)).toBe("content");
-      } // close called automatically when await using block ends
-    });
-  });
-
-  //#endregion
-});