mod2dom 1.1.1 → 1.2.0

package/Makefile

@@ -8,7 +8,7 @@ prod:
 	@npm run buildprod
 
 test:
-	@npm run test
+	@npm run test -- --slowTestThreshold 5 --retry 2 --logHeapUsage --reporter verbose
 
 updateMinor:
 	npm version minor

package/config/vitest.config.ts

@@ -1,7 +1,14 @@
-import { defineConfig } from "vitest/config"
+import { defineConfig } from "vitest/config";
+import path from "path";
 
 export default defineConfig({
-  test: {
-    environment: "jsdom"
-  }
+    resolve: {
+        alias: {
+            "@utils": path.resolve(__dirname, "../src/utils"),
+        },
+    },
+
+    test: {
+        environment: "jsdom",
+    },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mod2dom",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/localServices/clipboard.ts

@@ -1,17 +1,57 @@
-const mapAsync = async (array: Array<any>, callback: (item: any) => Promise<void>) => {
-    const newArray = new Array();
-    for (const item of array) {
-        newArray.push(await callback(item));
+import { mapAsync } from "@utils";
+
+export class CLItem {
+    raw: ClipboardItem
+
+    constructor(item: ClipboardItem) {
+        this.raw = item;
+    }
+
+    get text() {
+        return (async () => {
+            if (this.raw.types[0]?.match(/text\/.+/g)) {
+                return await (await this.raw.getType(this.raw.types[0])).text();
+            } else {
+                return undefined;
+            }
+        })();
+    }
+
+    get type() {
+        return this.raw.types[0];
+    }
+
+    get types() {
+        return this.raw.types;
     }
 }
 
 export const clipboard = {
-    readAll: async function readAll() {
+    ClipboardItem: CLItem,
+
+    raw: async function raw(): Promise<Array<CLItem>> {
         const r = await navigator.clipboard.read();
-        return await mapAsync(r, async (l) => {
-            const blob = await l.getType("text/plain");
-            const text = await blob.text();
-            return text;
-        });
-    }
+
+        return r.map((l) => new this.ClipboardItem(l));
+    },
+
+    readAll: async function readAll() {
+        const r = await this.raw();
+        
+        return (await mapAsync(r, async (l) => {
+            return await l.text;
+        })).filter((v) => v !== undefined);
+    },
+
+    read: async function read() {
+        return (await this.readAll()).at(-1);
+    },
+
+    write: async function write(text: string) {
+        return await navigator.clipboard.writeText(text);
+    },
+
+    writeRaw: async function write(...raw: ClipboardItems) {
+        return await navigator.clipboard.write(raw);
+    },
 }

package/src/types.ts

@@ -1,2 +1,3 @@
 export type DNode = Document | HTMLElement | Element | Node;
 export type { QueryType, QueryOption, QueryOptions } from "./query.js";
+export { CLItem } from "./localServices/clipboard.js";

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export const mapAsync = async (array: Array<any>, callback: (item: any) => Promise<void>) => {
+    const newArray = new Array();
+    for (const item of array) {
+        newArray.push(await callback(item));
+    }
+    return newArray;
+}

package/tests/clipboard/simple.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, vi, beforeEach, expect } from "vitest";
+import { clipboard } from "../../src/localServices/clipboard.js";
+import { CLItem } from "../../src/localServices/clipboard.js";
+
+describe("read", () => {
+    describe("text", () => {
+        let navigatorMock = {
+            clipboard: {
+                read: vi.fn()
+            }
+        }
+        let makeClipboardItemMock = (types: any, blob: any) => {
+            return {
+                types: types,
+                getType: vi.fn().mockResolvedValue(blob)
+            };
+        }
+        beforeEach(() => {
+            vi.resetAllMocks();
+
+            vi.stubGlobal("navigator", navigatorMock);
+        })
+
+
+        it("Normal Read (1)", async () => {
+            const mockBlob = new Blob(["hello world"], {
+                type: "text/plain",
+            });
+
+            const mockClipboardItem = makeClipboardItemMock(["text/plain"], mockBlob);
+            navigatorMock.clipboard.read.mockResolvedValue([mockClipboardItem]);
+
+            const result = await clipboard.read();
+
+            expect(mockClipboardItem.getType).toHaveBeenCalledOnce();
+            expect(navigatorMock.clipboard.read).toHaveBeenCalledOnce();
+            expect(result).toBe("hello world");
+        });
+
+        it("Normal Read (2)", async () => {
+            const wrongBlob = new Blob(["wrong"], {
+                type: "text/plain"
+            });
+            const wrongClipboardItem = makeClipboardItemMock(["text/plain"], wrongBlob);
+
+            const mockBlob = new Blob(["hello world"], {
+                type: "text/html",
+            });
+
+            const mockClipboardItem = makeClipboardItemMock(["text/html"], mockBlob);
+            navigatorMock.clipboard.read.mockResolvedValue([wrongClipboardItem, mockClipboardItem]);
+
+            const result = await clipboard.read();
+
+            expect(wrongClipboardItem.getType).toHaveBeenCalledOnce();
+            expect(mockClipboardItem.getType).toHaveBeenCalledOnce();
+            expect(navigatorMock.clipboard.read).toHaveBeenCalledOnce();
+            expect(result).toBe("hello world");
+        });
+    })
+})

package/tests/dom/error.test.ts

@@ -3,7 +3,7 @@ import { DOMParser } from "../../src/index";
 import { TagName as IDName, Element, ClassName } from "../../src/query";
 
 describe("invalidClass.empty.none", () => {
-    it("finds an element", () => {
+    it("fails to find an element", () => {
         document.body.innerHTML = `
             <div>
             <button id="x" class="test">Hello, World!</button>
@@ -22,7 +22,7 @@ describe("invalidClass.empty.none", () => {
 });
 
 describe("invalidClass.empty.whitespace", () => {
-    it("finds an element", () => {
+    it("fails to find an element", () => {
         document.body.innerHTML = `
             <div>
             <button id="x" class="test">Hello, World!</button>
@@ -41,7 +41,7 @@ describe("invalidClass.empty.whitespace", () => {
 });
 
 describe("invalidClass.character(1)", () => {
-    it("finds an element", () => {
+    it("fails to find an element", () => {
         document.body.innerHTML = `
             <div>
             <button id="x" class="test">Hello, World!</button>
@@ -60,7 +60,7 @@ describe("invalidClass.character(1)", () => {
 });
 
 describe("invalidClass.character(2)", () => {
-    it("finds an element", () => {
+    it("fails to find an element", () => {
         document.body.innerHTML = `
             <div>
             <button id="x" class="test">Hello, World!</button>

package/tests/dom/simple.test.ts

@@ -10,6 +10,16 @@ describe("findTheButton", () => {
 
         const btn = DOMParser.find(Element('button', {}, IDName("x"), ClassName("test")));
 
+        expect(btn?.textContent).toBe("Hello, World!")
+    });
+
+    it("finds an element based on an array query", () => {
+        document.body.innerHTML = `
+            <button id="x" class="test">Hello, World!</button>
+        `
+
+        const btn = DOMParser.find([Element('button', {}, IDName("x"), ClassName("test"))]);
+
         expect(btn?.textContent).toBe("Hello, World!")
     })
 });

package/tsconfig.json

@@ -40,7 +40,11 @@
     "isolatedModules": true,
     "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "paths": {
+      "@utils": ["./src/utils/index.ts"],
+      "@/*": ["./src/*"]
+    }
   },
 
   "include": [