rask-ui 0.2.4 → 0.2.6

package/dist/suspense.js

@@ -1,97 +0,0 @@
-import { getCurrentComponent } from "./component";
-import { createState } from "./createState";
-import { getCurrentObserver, Signal } from "./observation";
-export function createSuspense(promises) {
-    let currentComponent = getCurrentComponent();
-    if (!currentComponent) {
-        throw new Error("createSuspense must be used in the setup of a component");
-    }
-    const proxy = {};
-    for (const key in promises) {
-        const promise = promises[key];
-        const suspensePromise = isSuspensePromise(promise)
-            ? promise
-            : createSuspensePromise(promise);
-        currentComponent.notifyAsync(suspensePromise);
-        Object.defineProperty(proxy, key, {
-            get() {
-                return suspensePromise.value;
-            },
-        });
-    }
-    return proxy;
-}
-function isSuspensePromise(promise) {
-    return "status" in promise;
-}
-export function Suspense(props) {
-    const currentComponent = getCurrentComponent();
-    const state = createState({
-        suspendingPromises: [],
-    });
-    currentComponent.onAsync((promise) => {
-        state.suspendingPromises = state.suspendingPromises.concat(promise);
-    });
-    return () => {
-        const isAllResolved = state.suspendingPromises.every((promise) => promise.status === "resolved");
-        console.log(isAllResolved);
-        return isAllResolved ? props.children : props.fallback;
-    };
-}
-export function createSuspensePromise(promise) {
-    const signal = new Signal();
-    const state = {
-        error: null,
-        status: "pending",
-        value: null,
-    };
-    Object.defineProperty(promise, "value", {
-        get() {
-            const observer = getCurrentObserver();
-            if (observer) {
-                observer.subscribeSignal(signal);
-            }
-            return state.value;
-        },
-        set(newValue) {
-            state.value = newValue;
-            signal.notify();
-        },
-    });
-    Object.defineProperty(promise, "error", {
-        get() {
-            const observer = getCurrentObserver();
-            if (observer) {
-                observer.subscribeSignal(signal);
-            }
-            return state.error;
-        },
-    });
-    Object.defineProperty(promise, "status", {
-        get() {
-            const observer = getCurrentObserver();
-            if (observer) {
-                observer.subscribeSignal(signal);
-            }
-            return state.status;
-        },
-    });
-    promise
-        .then((value) => {
-        Object.assign(state, {
-            value,
-            error: null,
-            status: "resolved",
-        });
-        signal.notify();
-    })
-        .catch((error) => {
-        Object.assign(state, {
-            value: null,
-            error: String(error),
-            status: "rejected",
-        });
-        signal.notify();
-    });
-    return promise;
-}

package/dist/tests/class.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=class.test.d.ts.map

package/dist/tests/class.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class.test.d.ts","sourceRoot":"","sources":["../../src/tests/class.test.ts"],"names":[],"mappings":""}

package/dist/tests/class.test.js

@@ -1,185 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { jsx, render } from "../vdom";
-import { createState } from "../createState";
-describe("Class Property Support", () => {
-    it("should map string class to className", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: "test-class" }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("test-class");
-    });
-    it("should handle multiple classes as string", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: "class-1 class-2 class-3" }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("class-1 class-2 class-3");
-    });
-    it("should handle object notation with true values", () => {
-        const container = document.createElement("div");
-        render(jsx("div", {
-            class: {
-                active: true,
-                visible: true,
-                hidden: false,
-            },
-        }), container);
-        const div = container.querySelector("div");
-        expect(div?.classList.contains("active")).toBe(true);
-        expect(div?.classList.contains("visible")).toBe(true);
-        expect(div?.classList.contains("hidden")).toBe(false);
-    });
-    it("should handle mixed object notation", () => {
-        const container = document.createElement("div");
-        render(jsx("div", {
-            class: {
-                "class-1": true,
-                "class-2": false,
-                "class-3": true,
-                "class-4": false,
-            },
-        }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("class-1 class-3");
-    });
-    it("should handle empty object notation", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: {} }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should handle all false object notation", () => {
-        const container = document.createElement("div");
-        render(jsx("div", {
-            class: {
-                "class-1": false,
-                "class-2": false,
-            },
-        }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should update classes when object notation changes", async () => {
-        const container = document.createElement("div");
-        let stateFn;
-        const App = () => {
-            const state = createState({ isActive: true, isVisible: false });
-            stateFn = state;
-            return () => jsx("div", {
-                class: {
-                    active: state.isActive,
-                    visible: state.isVisible,
-                },
-            });
-        };
-        render(jsx(App, {}), container);
-        const div = container.querySelector("div");
-        expect(div?.classList.contains("active")).toBe(true);
-        expect(div?.classList.contains("visible")).toBe(false);
-        stateFn.isActive = false;
-        stateFn.isVisible = true;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(div?.classList.contains("active")).toBe(false);
-        expect(div?.classList.contains("visible")).toBe(true);
-    });
-    it("should handle hyphenated class names in object notation", () => {
-        const container = document.createElement("div");
-        render(jsx("div", {
-            class: {
-                "my-custom-class": true,
-                "another-class-name": true,
-                "disabled-class": false,
-            },
-        }), container);
-        const div = container.querySelector("div");
-        expect(div?.classList.contains("my-custom-class")).toBe(true);
-        expect(div?.classList.contains("another-class-name")).toBe(true);
-        expect(div?.classList.contains("disabled-class")).toBe(false);
-    });
-    it("should prefer class over className when both provided", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: "from-class", className: "from-className" }), container);
-        const div = container.querySelector("div");
-        // class should take precedence
-        expect(div?.className).toBe("from-class");
-    });
-    it("should work with nested components", () => {
-        const container = document.createElement("div");
-        const Child = () => {
-            return () => jsx("span", { class: "child-class" });
-        };
-        const Parent = () => {
-            return () => jsx("div", {
-                class: "parent-class",
-                children: jsx(Child, {}),
-            });
-        };
-        render(jsx(Parent, {}), container);
-        const parentDiv = container.querySelector("div");
-        const childSpan = container.querySelector("span");
-        expect(parentDiv?.className).toBe("parent-class");
-        expect(childSpan?.className).toBe("child-class");
-    });
-    it("should handle undefined and null class values", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: undefined }), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should remove class attribute when empty string is provided", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: "" }), container);
-        const div = container.querySelector("div");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should remove class attribute when null is provided", () => {
-        const container = document.createElement("div");
-        render(jsx("div", { class: null }), container);
-        const div = container.querySelector("div");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should remove class attribute when object notation results in empty string", () => {
-        const container = document.createElement("div");
-        render(jsx("div", {
-            class: {
-                active: false,
-                visible: false,
-            },
-        }), container);
-        const div = container.querySelector("div");
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should remove class attribute when updating from non-empty to empty string", async () => {
-        const container = document.createElement("div");
-        let stateFn;
-        const App = () => {
-            const state = createState({ className: "initial" });
-            stateFn = state;
-            return () => jsx("div", { class: state.className });
-        };
-        render(jsx(App, {}), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("initial");
-        expect(div?.hasAttribute("class")).toBe(true);
-        stateFn.className = "";
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(div?.hasAttribute("class")).toBe(false);
-    });
-    it("should handle dynamic string class updates", async () => {
-        const container = document.createElement("div");
-        let stateFn;
-        const App = () => {
-            const state = createState({ className: "initial" });
-            stateFn = state;
-            return () => jsx("div", { class: state.className });
-        };
-        render(jsx(App, {}), container);
-        const div = container.querySelector("div");
-        expect(div?.className).toBe("initial");
-        stateFn.className = "updated";
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(div?.className).toBe("updated");
-    });
-});

package/dist/tests/complex-rendering.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=complex-rendering.test.d.ts.map

package/dist/tests/complex-rendering.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"complex-rendering.test.d.ts","sourceRoot":"","sources":["../../src/tests/complex-rendering.test.ts"],"names":[],"mappings":""}