rask-ui 0.21.0 → 0.23.0

package/dist/createTask.js

@@ -1,79 +0,0 @@
-import { createCleanup, getCurrentComponent } from "./component";
-import { assignState, createState } from "./createState";
-export function createTask(task) {
-    const currentComponent = getCurrentComponent();
-    if (!currentComponent || currentComponent.isRendering) {
-        throw new Error("Only use createTask in component setup");
-    }
-    const state = createState({
-        isRunning: false,
-        result: null,
-        error: null,
-        params: null,
-    });
-    let currentAbortController;
-    const fetch = (params) => {
-        currentAbortController?.abort();
-        const abortController = (currentAbortController = new AbortController());
-        const promise = task(params, abortController.signal);
-        promise
-            .then((result) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assignState(state, {
-                isRunning: false,
-                result,
-                error: null,
-                params: null,
-            });
-        })
-            .catch((error) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assignState(state, {
-                isRunning: false,
-                result: null,
-                error: String(error),
-                params: null,
-            });
-        });
-        return promise;
-    };
-    createCleanup(() => currentAbortController?.abort());
-    return {
-        get isRunning() {
-            return state.isRunning;
-        },
-        get result() {
-            return state.result;
-        },
-        get error() {
-            return state.error;
-        },
-        get params() {
-            return state.params;
-        },
-        run(params) {
-            const promise = fetch(params);
-            assignState(state, {
-                isRunning: true,
-                result: null,
-                error: null,
-                params: (params || null),
-            });
-            return promise;
-        },
-        rerun(params) {
-            const promise = fetch(params);
-            assignState(state, {
-                isRunning: true,
-                result: state.result,
-                error: null,
-                params: (params || null),
-            });
-            return promise;
-        },
-    };
-}

package/dist/patchInferno.d.ts

@@ -1,6 +0,0 @@
-/**
- * Temporarily patches document.addEventListener during render to capture
- * and wrap Inferno's delegated event listeners with syncBatch
- */
-export declare function patchInfernoEventHandling(renderFn: () => void): void;
-//# sourceMappingURL=patchInferno.d.ts.map

package/dist/patchInferno.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patchInferno.d.ts","sourceRoot":"","sources":["../src/patchInferno.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,QA0D7D"}

package/dist/patchInferno.js

@@ -1,53 +0,0 @@
-import { syncBatch } from "./batch";
-/**
- * Temporarily patches document.addEventListener during render to capture
- * and wrap Inferno's delegated event listeners with syncBatch
- */
-export function patchInfernoEventHandling(renderFn) {
-    const originalAddEventListener = document.addEventListener.bind(document);
-    const patchedEvents = new Set();
-    // Inferno's delegated events
-    const INFERNO_EVENTS = [
-        "click",
-        "dblclick",
-        "focusin",
-        "focusout",
-        "keydown",
-        "keypress",
-        "keyup",
-        "mousedown",
-        "mousemove",
-        "mouseup",
-        "touchend",
-        "touchmove",
-        "touchstart",
-        "change",
-        "input",
-        "submit",
-    ];
-    // Temporarily replace addEventListener
-    document.addEventListener = function (type, listener, options) {
-        // Only wrap Inferno's delegated event listeners
-        if (INFERNO_EVENTS.includes(type) &&
-            typeof listener === "function" &&
-            !patchedEvents.has(type)) {
-            patchedEvents.add(type);
-            const wrappedListener = function (event) {
-                syncBatch(() => {
-                    listener.call(this, event);
-                });
-            };
-            return originalAddEventListener(type, wrappedListener, options);
-        }
-        // @ts-ignore
-        return originalAddEventListener(type, listener, options);
-    };
-    try {
-        // Call render - Inferno will synchronously attach its listeners
-        renderFn();
-    }
-    finally {
-        // Restore original addEventListener
-        document.addEventListener = originalAddEventListener;
-    }
-}

package/dist/scheduler.d.ts

@@ -1,4 +0,0 @@
-export declare function markDirty(): void;
-export declare function enqueueUpdateFromSetter(): void;
-export declare function installGlobalBatching(target?: EventTarget): () => void;
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,SAExB;AAeD,wBAAgB,uBAAuB,SAWtC;AAmED,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,WAAoB,cAoBjE"}

package/dist/scheduler.js

@@ -1,107 +0,0 @@
-let depth = 0; // batching scope nesting
-let dirty = false; // has any state update been enqueued?
-let scheduled = false; // async flush scheduled?
-export function markDirty() {
-    dirty = true;
-}
-function performWork() {
-    // TODO: call your Inferno render/commit once.
-    // infernoRender(vnode, container);
-}
-function flushNow() {
-    scheduled = false;
-    if (!dirty)
-        return;
-    dirty = false;
-    performWork();
-}
-// Called by setters after enqueueing their state change
-export function enqueueUpdateFromSetter() {
-    dirty = true;
-    if (depth > 0) {
-        // We're inside a batched input event; we'll flush on exit (same frame).
-        return;
-    }
-    if (!scheduled) {
-        scheduled = true;
-        queueMicrotask(flushNow); // one flush per task
-    }
-}
-// Batch-scope control used by the global capture listeners
-function enter() {
-    depth++;
-}
-function exit() {
-    if (--depth === 0) {
-        // End of the event propagation; commit now (before next paint).
-        flushNow();
-    }
-}
-// eventBatching.ts
-const INTERACTIVE_EVENTS = [
-    // Pointer + mouse
-    "click",
-    "dblclick",
-    "contextmenu",
-    "mousedown",
-    "mouseup",
-    "mousemove",
-    "pointerdown",
-    "pointerup",
-    "pointermove",
-    "touchstart",
-    "touchmove",
-    "touchend",
-    "touchcancel",
-    "dragstart",
-    "drag",
-    "dragend",
-    "dragenter",
-    "dragleave",
-    "dragover",
-    "drop",
-    "wheel",
-    // Keyboard
-    "keydown",
-    "keypress",
-    "keyup",
-    // Focus & input
-    "focus",
-    "blur",
-    "focusin",
-    "focusout",
-    "input",
-    "beforeinput",
-    "change",
-    "compositionstart",
-    "compositionupdate",
-    "compositionend",
-    // Forms
-    "submit",
-    "reset",
-    // Selection / clipboard
-    "select",
-    "selectionchange",
-    "copy",
-    "cut",
-    "paste",
-];
-export function installGlobalBatching(target = window) {
-    const handlers = [];
-    INTERACTIVE_EVENTS.forEach((type) => {
-        const onCapture = () => {
-            enter();
-            // Close the scope after all handlers (capture→target→bubble) have run.
-            queueMicrotask(exit);
-        };
-        target.addEventListener(type, onCapture, { capture: true });
-        handlers.push([onCapture, { capture: true }]);
-    });
-    // Return a disposer so you can remove on unmount
-    return () => {
-        INTERACTIVE_EVENTS.forEach((type, i) => {
-            const [fn, opts] = handlers[i];
-            target.removeEventListener(type, fn, opts);
-        });
-    };
-}

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

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

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

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

package/dist/tests/batch.test.js

@@ -1,244 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { syncBatch } from "../batch";
-import { createState } from "../createState";
-import { Observer } from "../observation";
-describe("syncBatch", () => {
-    it("should batch multiple state changes into a single notification", () => {
-        const state = createState({ count: 0, name: "Alice" });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track count
-        state.name; // Track name
-        dispose();
-        // Make multiple changes in a batch
-        syncBatch(() => {
-            state.count = 1;
-            state.name = "Bob";
-            state.count = 2;
-        });
-        // Should only notify once despite multiple changes, and synchronously
-        expect(notifyCount).toBe(1);
-        expect(state.count).toBe(2);
-        expect(state.name).toBe("Bob");
-        observer.dispose();
-    });
-    it("should handle nested batches correctly", () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track
-        dispose();
-        syncBatch(() => {
-            state.count = 1;
-            syncBatch(() => {
-                state.count = 2;
-            });
-            state.count = 3;
-        });
-        // Should still only notify once for nested batches
-        expect(notifyCount).toBe(1);
-        expect(state.count).toBe(3);
-        observer.dispose();
-    });
-    it("should handle multiple observers with syncBatch", () => {
-        const state = createState({ count: 0 });
-        let notifyCount1 = 0;
-        let notifyCount2 = 0;
-        const observer1 = new Observer(() => {
-            notifyCount1++;
-        });
-        const observer2 = new Observer(() => {
-            notifyCount2++;
-        });
-        const dispose1 = observer1.observe();
-        state.count; // Track in observer1
-        dispose1();
-        const dispose2 = observer2.observe();
-        state.count; // Track in observer2
-        dispose2();
-        syncBatch(() => {
-            state.count = 1;
-            state.count = 2;
-            state.count = 3;
-        });
-        // Both observers should be notified exactly once
-        expect(notifyCount1).toBe(1);
-        expect(notifyCount2).toBe(1);
-        observer1.dispose();
-        observer2.dispose();
-    });
-    it("should maintain correct state values after syncBatch", () => {
-        const state = createState({
-            count: 0,
-            name: "Alice",
-            items: [1, 2, 3],
-        });
-        syncBatch(() => {
-            state.count = 10;
-            state.name = "Bob";
-            state.items.push(4);
-            state.items[0] = 100;
-        });
-        expect(state.count).toBe(10);
-        expect(state.name).toBe("Bob");
-        expect(state.items).toEqual([100, 2, 3, 4]);
-    });
-    it("should not flush if exception thrown within syncBatch", () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track
-        dispose();
-        try {
-            syncBatch(() => {
-                state.count = 1;
-                throw new Error("Test error");
-            });
-        }
-        catch (e) {
-            // Expected error
-        }
-        // Should NOT have flushed since the batch was interrupted
-        expect(notifyCount).toBe(0);
-        // But state change still occurred
-        expect(state.count).toBe(1);
-        observer.dispose();
-    });
-    it("should deduplicate notifications for the same observer", () => {
-        const state = createState({ count: 0, name: "Alice" });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track
-        state.name; // Track
-        dispose();
-        syncBatch(() => {
-            state.count = 1; // Triggers observer
-            state.name = "Bob"; // Triggers same observer again
-            state.count = 2; // Triggers observer yet again
-        });
-        // Should deduplicate and only notify once
-        expect(notifyCount).toBe(1);
-        observer.dispose();
-    });
-});
-describe("queue (async batching)", () => {
-    it("should queue updates and flush on microtask", async () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count; // Track
-        dispose();
-        // Make changes that will be queued
-        state.count = 1;
-        state.count = 2;
-        state.count = 3;
-        // Not yet notified (queued)
-        expect(notifyCount).toBe(0);
-        // Wait for microtask flush
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        // Should have notified once after flush
-        expect(notifyCount).toBe(1);
-        expect(state.count).toBe(3);
-        observer.dispose();
-    });
-    it("should batch multiple async updates into one notification", async () => {
-        const state = createState({ count: 0, name: "Alice" });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count;
-        state.name;
-        dispose();
-        state.count = 1;
-        state.name = "Bob";
-        state.count = 2;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        // Should batch all updates into single notification
-        expect(notifyCount).toBe(1);
-        observer.dispose();
-    });
-    it("should handle separate async batches", async () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count;
-        dispose();
-        state.count = 1;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        const afterFirst = notifyCount;
-        state.count = 2;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        const afterSecond = notifyCount;
-        expect(afterFirst).toBe(1);
-        expect(afterSecond).toBe(2);
-        observer.dispose();
-    });
-});
-describe("syncBatch with nested async updates", () => {
-    it("should handle syncBatch inside async context", async () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count;
-        dispose();
-        // Async update
-        state.count = 1;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(notifyCount).toBe(1);
-        // Sync batch after async
-        syncBatch(() => {
-            state.count = 2;
-            state.count = 3;
-        });
-        expect(notifyCount).toBe(2); // +1 from sync batch
-        observer.dispose();
-    });
-    it("should handle async updates inside syncBatch callback", async () => {
-        const state = createState({ count: 0 });
-        let notifyCount = 0;
-        const observer = new Observer(() => {
-            notifyCount++;
-        });
-        const dispose = observer.observe();
-        state.count;
-        dispose();
-        syncBatch(() => {
-            state.count = 1;
-            // Trigger an async update from within syncBatch
-            setTimeout(() => {
-                state.count = 2;
-            }, 0);
-        });
-        // Sync batch should flush immediately
-        expect(notifyCount).toBe(1);
-        expect(state.count).toBe(1);
-        // Wait for async update
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(notifyCount).toBe(2);
-        expect(state.count).toBe(2);
-        observer.dispose();
-    });
-});

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

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

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

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