@simplysm/core-common 13.0.69 → 13.0.71

package/tests/utils/wait.spec.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect } from "vitest";
+import { waitTime as time, waitUntil as until, TimeoutError } from "@simplysm/core-common";
+
+describe("Wait", () => {
+  //#region time
+
+  describe("time()", () => {
+    it("Waits for specified time", async () => {
+      const start = Date.now();
+      await time(100);
+      const elapsed = Date.now() - start;
+
+      // 100ms ± tolerance - CI environment load and timer precision considered
+      expect(elapsed).toBeGreaterThanOrEqual(95);
+      expect(elapsed).toBeLessThan(250);
+    });
+
+    it("Works normally with 0ms wait", async () => {
+      const start = Date.now();
+      await time(0);
+      const elapsed = Date.now() - start;
+
+      expect(elapsed).toBeLessThan(50);
+    });
+  });
+
+  //#endregion
+
+  //#region until
+
+  describe("until()", () => {
+    it("Waits until condition becomes true", async () => {
+      let count = 0;
+
+      await until(() => {
+        count++;
+        return count >= 3;
+      }, 10);
+
+      expect(count).toBe(3);
+    });
+
+    it("Supports async condition function", async () => {
+      let count = 0;
+
+      await until(async () => {
+        await time(10);
+        count++;
+        return count >= 3;
+      }, 10);
+
+      expect(count).toBe(3);
+    });
+
+    it("Returns immediately if condition already true", async () => {
+      const start = Date.now();
+      await 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 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 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 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 until(
+          () => {
+            count++;
+            return false;
+          },
+          10,
+          1,
+        );
+      }).rejects.toThrow(TimeoutError);
+
+      expect(count).toBe(1);
+    });
+
+    it("Success if condition true within maxCount", async () => {
+      let count = 0;
+
+      await until(
+        () => {
+          count++;
+          return count >= 3;
+        },
+        10,
+        5,
+      );
+
+      expect(count).toBe(3);
+    });
+  });
+
+  //#endregion
+});

package/tests/utils/xml.spec.ts

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

package/tests/zip/sd-zip.spec.ts

@@ -0,0 +1,238 @@
+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 true for cached file", async () => {
+      const zip = new ZipArchive();
+      zip.write("file.txt", encoder.encode("content"));
+      const zipBuffer = await zip.compress();
+
+      const result = new ZipArchive(zipBuffer);
+      await result.get("file.txt"); // Load into cache
+      const exists = await result.exists("file.txt");
+
+      expect(exists).toBe(true);
+    });
+
+    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("works without error when reader is not available", async () => {
+      const zip = new ZipArchive();
+      await expect(zip.close()).resolves.not.toThrow();
+    });
+
+    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
+});