rask-ui 0.2.4 → 0.2.6

package/dist/component.js

@@ -1,130 +0,0 @@
-import { thunk } from "snabbdom";
-import { getCurrentObserver, Observer, Signal } from "./observation";
-import { jsx, patch } from "./render";
-import { createState } from "./createState";
-const componentStack = [];
-export function getCurrentComponent() {
-    return componentStack[0] || null;
-}
-export function onMount(cb) {
-    const current = componentStack[0];
-    if (!current) {
-        throw new Error("Only use onMount in component setup");
-    }
-    current.onMounts.push(cb);
-}
-export function onCleanup(cb) {
-    const current = componentStack[0];
-    if (!current) {
-        throw new Error("Only use onCleanup in component setup");
-    }
-    current.onCleanups.push(cb);
-}
-const hook = {
-    insert(vnode) {
-        componentStack.shift();
-        vnode.data.componentInstance.onMounts.forEach((cb) => cb());
-    },
-    destroy(vnode) {
-        vnode.data.componentInstance.onCleanups.forEach((cb) => cb());
-    },
-    prepatch(oldVnode, thunk) {
-        copyToThunk(oldVnode, thunk);
-        componentStack.unshift(thunk.data.componentInstance);
-    },
-    postpatch(_, newNode) {
-        const componentInstance = newNode.data.componentInstance;
-        componentStack.shift();
-        const props = newNode.data.args[0];
-        const children = newNode.data.args[1];
-        for (const key in props) {
-            componentInstance.reactiveProps[key] = props[key];
-        }
-        componentInstance.reactiveProps.children = children;
-    },
-    init(thunk) {
-        const component = thunk.data.fn;
-        const args = thunk.data.args;
-        let errorSignal;
-        let error;
-        const executeRender = () => {
-            const stopObserving = instance.observer.observe();
-            let renderResult = null;
-            try {
-                renderResult = render();
-            }
-            catch (error) {
-                instance.notifyError(error);
-            }
-            finally {
-                stopObserving();
-            }
-            return jsx("component", {
-                hook: {
-                    insert: hook.insert,
-                    destroy: hook.destroy,
-                },
-                "data-name": component.name,
-            }, Array.isArray(renderResult) ? renderResult : [renderResult]);
-        };
-        const instance = {
-            parent: thunk.data.parentComponent || null,
-            component,
-            contexts: null,
-            onMounts: [],
-            onCleanups: [],
-            observer: new Observer(() => {
-                const renderResult = executeRender();
-                instance.hostNode = patch(instance.hostNode, renderResult);
-            }),
-            reactiveProps: createState({
-                ...args[0],
-                children: args[1],
-            }),
-            get error() {
-                if (!errorSignal) {
-                    errorSignal = new Signal();
-                }
-                const observer = getCurrentObserver();
-                if (observer) {
-                    observer.subscribeSignal(errorSignal);
-                }
-                return error;
-            },
-            notifyError(childError) {
-                if (errorSignal) {
-                    error = childError;
-                    errorSignal.notify();
-                }
-                else if (instance.parent) {
-                    instance.parent.notifyError(childError);
-                }
-                else {
-                    throw childError;
-                }
-            },
-        };
-        componentStack.unshift(instance);
-        const render = component(instance.reactiveProps);
-        const renderResult = executeRender();
-        renderResult.data.componentInstance = instance;
-        copyToThunk(renderResult, thunk);
-        instance.hostNode = thunk;
-    },
-};
-export function createComponent(component, props, children) {
-    const thunkNode = thunk("component", props.key, component, [props, children]);
-    Object.assign(thunkNode.data.hook, hook);
-    // Capture the parent component at vnode creation time (during render)
-    // rather than at init time, to ensure correct parent relationships
-    thunkNode.data.parentComponent = getCurrentComponent();
-    return thunkNode;
-}
-function copyToThunk(vnode, thunk) {
-    vnode.data.fn = thunk.data.fn;
-    vnode.data.args = thunk.data.args;
-    thunk.data = vnode.data;
-    thunk.children = vnode.children;
-    thunk.text = vnode.text;
-    thunk.elm = vnode.elm;
-}

package/dist/context.d.ts

@@ -1,5 +0,0 @@
-export declare function createContext<T extends object>(): {
-    set(value: T): void;
-    get(): T;
-};
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM;eAE/B,CAAC;WAaL,CAAC;EAmBX"}

package/dist/context.js

@@ -1,29 +0,0 @@
-import { getCurrentComponent } from "./component";
-export function createContext() {
-    const context = {
-        set(value) {
-            const currentComponent = getCurrentComponent();
-            if (!currentComponent) {
-                throw new Error("You can not set context out component setup");
-            }
-            if (!currentComponent.contexts) {
-                currentComponent.contexts = new Map();
-            }
-            currentComponent.contexts.set(context, value);
-        },
-        get() {
-            let currentComponent = getCurrentComponent();
-            if (!currentComponent) {
-                throw new Error("You can not set context out component setup");
-            }
-            while (currentComponent) {
-                if (currentComponent.contexts?.has(context)) {
-                    return currentComponent.contexts.get(context);
-                }
-                currentComponent = currentComponent.parent;
-            }
-            throw new Error("Could not find context in parent components");
-        },
-    };
-    return context;
-}

package/dist/createAsync.test.d.ts

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

package/dist/createAsync.test.d.ts.map

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

package/dist/createAsync.test.js

@@ -1,110 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createAsync } from './createAsync';
-describe('createAsync', () => {
-    it('should start in pending state', () => {
-        const promise = new Promise(() => { });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        expect(async.value).toBeNull();
-        expect(async.error).toBeNull();
-    });
-    it('should resolve to value state on success', async () => {
-        const promise = Promise.resolve('success');
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('success');
-        expect(async.error).toBeNull();
-    });
-    it('should resolve to error state on rejection', async () => {
-        const promise = Promise.reject(new Error('failed'));
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        // Wait for state update
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBeNull();
-        expect(async.error).toContain('failed');
-    });
-    it('should handle numeric values', async () => {
-        const promise = Promise.resolve(42);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toBe(42);
-    });
-    it('should handle object values', async () => {
-        const data = { id: 1, name: 'Test' };
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it('should handle array values', async () => {
-        const data = [1, 2, 3, 4, 5];
-        const promise = Promise.resolve(data);
-        const async = createAsync(promise);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.value).toEqual(data);
-    });
-    it('should convert error to string', async () => {
-        const promise = Promise.reject('string error');
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(typeof async.error).toBe('string');
-        expect(async.error).toBe('string error');
-    });
-    it('should handle error objects', async () => {
-        const error = new Error('Something went wrong');
-        const promise = Promise.reject(error);
-        const async = createAsync(promise);
-        try {
-            await promise;
-        }
-        catch {
-            // Ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.error).toContain('Something went wrong');
-    });
-    it('should create reactive state', async () => {
-        const promise = new Promise((resolve) => {
-            setTimeout(() => resolve('delayed'), 10);
-        });
-        const async = createAsync(promise);
-        expect(async.isPending).toBe(true);
-        await promise;
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('delayed');
-    });
-    it('should handle immediate resolution', async () => {
-        const async = createAsync(Promise.resolve('immediate'));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.value).toBe('immediate');
-    });
-    it('should handle immediate rejection', async () => {
-        const async = createAsync(Promise.reject('immediate error'));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(async.isPending).toBe(false);
-        expect(async.error).toBe('immediate error');
-    });
-});

package/dist/createAsyncState.d.ts

@@ -1,16 +0,0 @@
-type AsyncState<T> = {
-    isPending: true;
-    value: null;
-    error: null;
-} | {
-    isPending: false;
-    value: T;
-    error: null;
-} | {
-    isPending: false;
-    value: null;
-    error: string;
-};
-export declare function createAsyncState<T>(promise: Promise<T>): AsyncState<T>;
-export {};
-//# sourceMappingURL=createAsyncState.d.ts.map

package/dist/createAsyncState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createAsyncState.d.ts","sourceRoot":"","sources":["../src/createAsyncState.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IACb;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,KAAK,EAAE,IAAI,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,iBAwBtD"}

package/dist/createAsyncState.js

@@ -1,24 +0,0 @@
-import { createState } from "./createState";
-export function createAsyncState(promise) {
-    const state = createState({
-        isPending: true,
-        error: null,
-        value: null,
-    });
-    promise
-        .then((value) => {
-        Object.assign(state, {
-            value,
-            error: null,
-            isPending: false,
-        });
-    })
-        .catch((error) => {
-        Object.assign(state, {
-            value: null,
-            error: String(error),
-            isPending: false,
-        });
-    });
-    return state;
-}

package/dist/createContext.test.d.ts

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

package/dist/createContext.test.d.ts.map

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

package/dist/createContext.test.js

@@ -1,136 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "./jsx-runtime";
-import { describe, it, expect } from "vitest";
-import { createContext } from "./createContext";
-import { render } from "./vdom";
-describe("createContext", () => {
-    it("should create a context object", () => {
-        const context = createContext();
-        expect(context).toHaveProperty("inject");
-        expect(context).toHaveProperty("get");
-    });
-    it("should allow setting and getting context values", () => {
-        const ThemeContext = createContext();
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            return () => _jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            return () => _jsx("div", { children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("dark");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should traverse parent components to find context", () => {
-        const ThemeContext = createContext();
-        function GrandParent() {
-            ThemeContext.inject({ theme: "light" });
-            return () => _jsx(Parent, {});
-        }
-        function Parent() {
-            return () => _jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            return () => _jsx("div", { children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(GrandParent, {}), container);
-        expect(vnode.elm.textContent).toContain("light");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should throw error when context is not found", () => {
-        const ThemeContext = createContext();
-        function Child() {
-            expect(() => {
-                ThemeContext.get();
-            }).toThrow("Could not find context in parent components");
-            return () => _jsx("div", { children: "Child" });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(Child, {}), container);
-        document.body.removeChild(vnode.elm);
-    });
-    it("should throw error when setting context outside component", () => {
-        const ThemeContext = createContext();
-        expect(() => {
-            ThemeContext.inject({ theme: "dark" });
-        }).toThrow("No current root");
-    });
-    it("should throw error when getting context outside component", () => {
-        const ThemeContext = createContext();
-        expect(() => {
-            ThemeContext.get();
-        }).toThrow("No current root");
-    });
-    it("should allow overriding context in nested components", () => {
-        const ThemeContext = createContext();
-        function GrandParent() {
-            ThemeContext.inject({ theme: "light" });
-            return () => (_jsxs("div", { children: [_jsx(Parent, {}), _jsx(ChildOfGrandParent, {})] }));
-        }
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            return () => _jsx(ChildOfParent, {});
-        }
-        function ChildOfParent() {
-            const theme = ThemeContext.get();
-            return () => _jsx("div", { class: "child-of-parent", children: theme.theme });
-        }
-        function ChildOfGrandParent() {
-            const theme = ThemeContext.get();
-            return () => _jsx("div", { class: "child-of-grandparent", children: theme.theme });
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(GrandParent, {}), container);
-        const childOfParent = document.querySelector(".child-of-parent");
-        const childOfGrandParent = document.querySelector(".child-of-grandparent");
-        expect(childOfParent?.textContent).toBe("dark");
-        expect(childOfGrandParent?.textContent).toBe("light");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should support multiple different contexts", () => {
-        const ThemeContext = createContext();
-        const UserContext = createContext();
-        function Parent() {
-            ThemeContext.inject({ theme: "dark" });
-            UserContext.inject({ name: "Alice" });
-            return () => _jsx(Child, {});
-        }
-        function Child() {
-            const theme = ThemeContext.get();
-            const user = UserContext.get();
-            return () => (_jsxs("div", { children: [theme.theme, " - ", user.name] }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("dark - Alice");
-        document.body.removeChild(vnode.elm);
-    });
-    it("should handle context values of different types", () => {
-        const NumberContext = createContext();
-        const ArrayContext = createContext();
-        function Parent() {
-            NumberContext.inject(42);
-            ArrayContext.inject(["a", "b", "c"]);
-            return () => _jsx(Child, {});
-        }
-        function Child() {
-            const num = NumberContext.get();
-            const arr = ArrayContext.get();
-            return () => (_jsxs("div", { children: [num, " - ", arr.join(",")] }));
-        }
-        const container = document.createElement("div");
-        document.body.appendChild(container);
-        const vnode = render(_jsx(Parent, {}), container);
-        expect(vnode.elm.textContent).toContain("42 - a,b,c");
-        document.body.removeChild(vnode.elm);
-    });
-});

package/dist/createMutation.test.d.ts

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

package/dist/createMutation.test.d.ts.map

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

package/dist/createMutation.test.js

@@ -1,168 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createMutation } from './createMutation';
-describe('createMutation', () => {
-    it('should start in idle state', () => {
-        const mutator = vi.fn(() => Promise.resolve(null));
-        const mutation = createMutation(mutator);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        expect(mutator).not.toHaveBeenCalled();
-    });
-    it('should execute mutator when mutate is called', async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe('test');
-        expect(mutator).toHaveBeenCalledWith('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle successful mutations', async () => {
-        const mutator = (params) => Promise.resolve(params);
-        const mutation = createMutation(mutator);
-        mutation.mutate({ id: 1 });
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle mutation errors', async () => {
-        const mutator = (params) => Promise.reject(new Error('Mutation failed'));
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        expect(mutation.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toContain('Mutation failed');
-        expect(mutation.params).toBeNull();
-    });
-    it('should cancel previous mutation on new mutate call', async () => {
-        let resolveFirst;
-        let resolveSecond;
-        const firstPromise = new Promise((resolve) => {
-            resolveFirst = resolve;
-        });
-        const secondPromise = new Promise((resolve) => {
-            resolveSecond = resolve;
-        });
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(firstPromise)
-            .mockReturnValueOnce(secondPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate('first');
-        expect(mutation.params).toBe('first');
-        // Trigger second mutation before first completes
-        mutation.mutate('second');
-        expect(mutation.params).toBe('second');
-        // Resolve first (should be ignored due to cancellation)
-        resolveFirst('first');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(true); // Still pending second
-        // Resolve second
-        resolveSecond('second');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should handle rapid successive mutations', async () => {
-        let counter = 0;
-        const mutator = vi.fn(() => Promise.resolve(++counter));
-        const mutation = createMutation(mutator);
-        // Rapid mutations
-        mutation.mutate('1');
-        mutation.mutate('2');
-        mutation.mutate('3');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Only the last mutation should complete
-        expect(mutator).toHaveBeenCalledTimes(3);
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-    it('should clear error on successful retry', async () => {
-        const mutator = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('First error'))
-            .mockResolvedValueOnce('success');
-        const mutation = createMutation(mutator);
-        mutation.mutate('attempt1');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toContain('First error');
-        mutation.mutate('attempt2');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(mutation.error).toBeNull();
-        expect(mutation.isPending).toBe(false);
-    });
-    it('should handle different parameter types', async () => {
-        const mutator = vi.fn((params) => Promise.resolve(params));
-        const mutation = createMutation(mutator);
-        // Object params
-        mutation.mutate({ id: 1, name: 'test' });
-        expect(mutation.params).toEqual({ id: 1, name: 'test' });
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Array params
-        const mutation2 = createMutation(mutator);
-        mutation2.mutate([1, 2, 3]);
-        expect(mutation2.params).toEqual([1, 2, 3]);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // String params
-        const mutation3 = createMutation(mutator);
-        mutation3.mutate('string');
-        expect(mutation3.params).toBe('string');
-    });
-    it('should convert errors to strings', async () => {
-        const mutator = (params) => Promise.reject('string error');
-        const mutation = createMutation(mutator);
-        mutation.mutate('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(typeof mutation.error).toBe('string');
-        expect(mutation.error).toBe('string error');
-    });
-    it('should handle AbortController cancellation correctly', async () => {
-        const abortedPromise = new Promise((_, reject) => {
-            const error = new Error('Aborted');
-            error.name = 'AbortError';
-            setTimeout(() => reject(error), 5);
-        });
-        const successPromise = Promise.resolve('success');
-        const mutator = vi
-            .fn()
-            .mockReturnValueOnce(abortedPromise)
-            .mockReturnValueOnce(successPromise);
-        const mutation = createMutation(mutator);
-        mutation.mutate('first');
-        // Immediately trigger second mutation to abort first
-        mutation.mutate('second');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.error).toBeNull();
-    });
-    it('should track params during pending state', () => {
-        const mutator = () => new Promise((resolve) => setTimeout(() => resolve(null), 100));
-        const mutation = createMutation(mutator);
-        const params = { id: 123, action: 'update' };
-        mutation.mutate(params);
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toEqual(params);
-    });
-    it('should expose reactive getters', async () => {
-        const mutator = () => Promise.resolve('data');
-        const mutation = createMutation(mutator);
-        // Access getters before mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-        expect(mutation.error).toBeNull();
-        mutation.mutate('test');
-        // Access getters during mutation
-        expect(mutation.isPending).toBe(true);
-        expect(mutation.params).toBe('test');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Access getters after mutation
-        expect(mutation.isPending).toBe(false);
-        expect(mutation.params).toBeNull();
-    });
-});

package/dist/createQuery.test.d.ts

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

package/dist/createQuery.test.d.ts.map

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