rask-ui 0.25.0 → 0.25.4

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.d.ts

@@ -1,42 +0,0 @@
-type QueryState<T> = {
-    isPending: true;
-    data: T | null;
-    error: null;
-} | {
-    isPending: false;
-    data: T;
-    error: null;
-} | {
-    isPending: false;
-    data: null;
-    error: string;
-};
-export type Query<T> = QueryState<T> & {
-    fetch(force?: boolean): void;
-};
-/**
- * Creates a reactive query that manages data fetching with loading and error states.
- *
- * @warning **Do not destructure the returned reactive object!** Destructuring breaks reactivity.
- * Access properties directly in your render function instead.
- *
- * @example
- * // ❌ Bad - destructuring loses reactivity
- * function Component() {
- *   const query = createQuery(() => fetchUsers());
- *   const { isPending, data, error } = query; // Don't do this!
- *   return () => <div>{isPending ? "Loading..." : data.length}</div>; // Won't update!
- * }
- *
- * // ✅ Good - access properties directly
- * function Component() {
- *   const query = createQuery(() => fetchUsers());
- *   return () => <div>{query.isPending ? "Loading..." : query.data.length}</div>;
- * }
- *
- * @param fetcher - Function that returns a promise with the data to fetch
- * @returns Reactive query object with isPending, data, error properties and fetch method
- */
-export declare function createQuery<T>(fetcher: () => Promise<T>): Query<T>;
-export {};
-//# sourceMappingURL=createQuery.d.ts.map

package/dist/createQuery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createQuery.d.ts","sourceRoot":"","sources":["../src/createQuery.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,CAAC,CAAC,IACb;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACf,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACrC,KAAK,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CA+DlE"}

package/dist/createQuery.js

@@ -1,80 +0,0 @@
-import { createState } from "./createState";
-/**
- * Creates a reactive query that manages data fetching with loading and error states.
- *
- * @warning **Do not destructure the returned reactive object!** Destructuring breaks reactivity.
- * Access properties directly in your render function instead.
- *
- * @example
- * // ❌ Bad - destructuring loses reactivity
- * function Component() {
- *   const query = createQuery(() => fetchUsers());
- *   const { isPending, data, error } = query; // Don't do this!
- *   return () => <div>{isPending ? "Loading..." : data.length}</div>; // Won't update!
- * }
- *
- * // ✅ Good - access properties directly
- * function Component() {
- *   const query = createQuery(() => fetchUsers());
- *   return () => <div>{query.isPending ? "Loading..." : query.data.length}</div>;
- * }
- *
- * @param fetcher - Function that returns a promise with the data to fetch
- * @returns Reactive query object with isPending, data, error properties and fetch method
- */
-export function createQuery(fetcher) {
-    const state = createState({
-        isPending: true,
-        data: null,
-        error: null,
-    });
-    const assign = (newState) => {
-        Object.assign(state, newState);
-    };
-    let currentAbortController;
-    const fetch = () => {
-        currentAbortController?.abort();
-        const abortController = (currentAbortController = new AbortController());
-        fetcher()
-            .then((data) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assign({
-                isPending: false,
-                data,
-                error: null,
-            });
-        })
-            .catch((error) => {
-            if (abortController.signal.aborted) {
-                return;
-            }
-            assign({
-                isPending: false,
-                data: null,
-                error: String(error),
-            });
-        });
-    };
-    fetch();
-    return {
-        get isPending() {
-            return state.isPending;
-        },
-        get data() {
-            return state.data;
-        },
-        get error() {
-            return state.error;
-        },
-        fetch(force) {
-            assign({
-                isPending: true,
-                data: force ? null : state.data,
-                error: null,
-            });
-            fetch();
-        },
-    };
-}

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":""}

package/dist/createQuery.test.js

@@ -1,156 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createQuery } from './createQuery';
-describe('createQuery', () => {
-    it('should start in pending state and fetch immediately', async () => {
-        const fetcher = vi.fn(() => Promise.resolve('data'));
-        const query = createQuery(fetcher);
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBeNull();
-        expect(query.error).toBeNull();
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBe('data');
-    });
-    it('should resolve to data state on success', async () => {
-        const fetcher = () => Promise.resolve({ id: 1, name: 'Test' });
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toEqual({ id: 1, name: 'Test' });
-        expect(query.error).toBeNull();
-    });
-    it('should resolve to error state on failure', async () => {
-        const fetcher = () => Promise.reject(new Error('Network error'));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBeNull();
-        expect(query.error).toContain('Network error');
-    });
-    it('should allow manual refetch', async () => {
-        const fetcher = vi.fn(() => Promise.resolve('data'));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(fetcher).toHaveBeenCalledTimes(1);
-        query.fetch();
-        expect(query.isPending).toBe(true);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(fetcher).toHaveBeenCalledTimes(2);
-        expect(query.isPending).toBe(false);
-    });
-    it('should retain old data during refetch by default', async () => {
-        const fetcher = vi
-            .fn()
-            .mockResolvedValueOnce('data1')
-            .mockResolvedValueOnce('data2');
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe('data1');
-        query.fetch();
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBe('data1'); // Old data retained
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe('data2');
-    });
-    it('should clear old data when force refetch is used', async () => {
-        const fetcher = vi
-            .fn()
-            .mockResolvedValueOnce('data1')
-            .mockResolvedValueOnce('data2');
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe('data1');
-        query.fetch(true); // Force refresh
-        expect(query.isPending).toBe(true);
-        expect(query.data).toBeNull(); // Old data cleared
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe('data2');
-    });
-    it('should cancel previous request on new fetch', async () => {
-        let resolveFirst;
-        let resolveSecond;
-        const firstPromise = new Promise((resolve) => {
-            resolveFirst = resolve;
-        });
-        const secondPromise = new Promise((resolve) => {
-            resolveSecond = resolve;
-        });
-        const fetcher = vi
-            .fn()
-            .mockReturnValueOnce(firstPromise)
-            .mockReturnValueOnce(secondPromise);
-        const query = createQuery(fetcher);
-        expect(query.isPending).toBe(true);
-        // Trigger second fetch before first completes
-        query.fetch();
-        // Resolve first (should be ignored due to cancellation)
-        resolveFirst('first');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBeNull(); // First result ignored
-        // Resolve second
-        resolveSecond('second');
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.data).toBe('second');
-    });
-    it('should handle rapid successive fetches', async () => {
-        let counter = 0;
-        const fetcher = vi.fn(() => Promise.resolve(`data-${++counter}`));
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        // Rapid fetches
-        query.fetch();
-        query.fetch();
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        // Only the last fetch should matter
-        expect(fetcher).toHaveBeenCalledTimes(4); // Initial + 3 fetches
-        expect(query.data).toBe('data-4');
-    });
-    it('should cancel on error and allow refetch', async () => {
-        const fetcher = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('First error'))
-            .mockResolvedValueOnce('success');
-        const query = createQuery(fetcher);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.error).toContain('First error');
-        expect(query.data).toBeNull();
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.error).toBeNull();
-        expect(query.data).toBe('success');
-    });
-    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 fetcher = vi
-            .fn()
-            .mockReturnValueOnce(abortedPromise)
-            .mockReturnValueOnce(successPromise);
-        const query = createQuery(fetcher);
-        // Immediately trigger second fetch to abort first
-        query.fetch();
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(query.data).toBe('success');
-        expect(query.error).toBeNull();
-    });
-    it('should expose reactive getters', async () => {
-        const fetcher = () => Promise.resolve('data');
-        const query = createQuery(fetcher);
-        // Access getters
-        const pending1 = query.isPending;
-        const data1 = query.data;
-        const error1 = query.error;
-        expect(pending1).toBe(true);
-        expect(data1).toBeNull();
-        expect(error1).toBeNull();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(query.isPending).toBe(false);
-        expect(query.data).toBe('data');
-    });
-});

package/dist/createRef.d.ts

@@ -1,6 +0,0 @@
-export declare function createRef<T>(cb?: (element: T) => (() => void) | void): {
-    (node: T | null): void;
-    current: T | null;
-    cb: ((element: T) => (() => void) | void) | undefined;
-};
-//# sourceMappingURL=createRef.d.ts.map

package/dist/createRef.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRef.d.ts","sourceRoot":"","sources":["../src/createRef.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;WAChD,CAAC,GAAG,IAAI;;mBADe,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI;EASpE"}

package/dist/createRef.js

@@ -1,8 +0,0 @@
-export function createRef(cb) {
-    function ref(node) {
-        ref.current = node;
-    }
-    ref.current = null;
-    ref.cb = cb;
-    return ref;
-}

package/dist/createState.d.ts

@@ -1,26 +0,0 @@
-/**
- * Creates a reactive state object that tracks property access and notifies observers on changes.
- *
- * @warning **Do not destructure the returned reactive object!** Destructuring breaks reactivity
- * because it extracts plain values instead of maintaining proxy access. This is the same rule
- * as Solid.js signals.
- *
- * @example
- * // ❌ Bad - destructuring loses reactivity
- * function Component(props) {
- *   const state = createState({ count: 0, name: "foo" });
- *   const { count, name } = state; // Don't do this!
- *   return () => <div>{count} {name}</div>; // Won't update!
- * }
- *
- * // ✅ Good - access properties directly in render
- * function Component(props) {
- *   const state = createState({ count: 0, name: "foo" });
- *   return () => <div>{state.count} {state.name}</div>; // Reactive!
- * }
- *
- * @param state - The initial state object to make reactive
- * @returns A reactive proxy of the state object
- */
-export declare function createState<T extends object>(state: T): T;
-//# sourceMappingURL=createState.d.ts.map

package/dist/createState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createState.d.ts","sourceRoot":"","sources":["../src/createState.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEzD"}

package/dist/createState.js

@@ -1,94 +0,0 @@
-import { getCurrentObserver, Signal } from "./observation";
-/**
- * Creates a reactive state object that tracks property access and notifies observers on changes.
- *
- * @warning **Do not destructure the returned reactive object!** Destructuring breaks reactivity
- * because it extracts plain values instead of maintaining proxy access. This is the same rule
- * as Solid.js signals.
- *
- * @example
- * // ❌ Bad - destructuring loses reactivity
- * function Component(props) {
- *   const state = createState({ count: 0, name: "foo" });
- *   const { count, name } = state; // Don't do this!
- *   return () => <div>{count} {name}</div>; // Won't update!
- * }
- *
- * // ✅ Good - access properties directly in render
- * function Component(props) {
- *   const state = createState({ count: 0, name: "foo" });
- *   return () => <div>{state.count} {state.name}</div>; // Reactive!
- * }
- *
- * @param state - The initial state object to make reactive
- * @returns A reactive proxy of the state object
- */
-export function createState(state) {
-    return getProxy(state);
-}
-const proxyCache = new WeakMap();
-const PROXY_MARKER = Symbol("isProxy");
-function getProxy(value) {
-    // Check if already a proxy to avoid double-wrapping
-    if (PROXY_MARKER in value) {
-        return value;
-    }
-    if (proxyCache.has(value)) {
-        return proxyCache.get(value);
-    }
-    const signals = {};
-    const proxy = new Proxy(value, {
-        has(target, key) {
-            // Support the "in" operator check for PROXY_MARKER
-            if (key === PROXY_MARKER) {
-                return true;
-            }
-            return Reflect.has(target, key);
-        },
-        get(target, key) {
-            // Mark this as a proxy to prevent double-wrapping
-            if (key === PROXY_MARKER) {
-                return true;
-            }
-            const value = Reflect.get(target, key);
-            if (typeof key === "symbol" || typeof value === "function") {
-                return value;
-            }
-            const observer = getCurrentObserver();
-            if (observer) {
-                const signal = (signals[key] = signals[key] || new Signal());
-                observer.subscribeSignal(signal);
-            }
-            if (Array.isArray(value) ||
-                (typeof value === "object" && value !== null)) {
-                return getProxy(value);
-            }
-            return value;
-        },
-        set(target, key, newValue) {
-            if (typeof key === "symbol") {
-                return Reflect.set(target, key, newValue);
-            }
-            const oldValue = Reflect.get(target, key);
-            const setResult = Reflect.set(target, key, newValue);
-            // We only notify if actual change, though array length actually updates under the hood
-            if (newValue !== oldValue || (Array.isArray(value) && key === "length")) {
-                console.log("WTF", key, newValue);
-                const signal = signals[key];
-                signal?.notify();
-            }
-            return setResult;
-        },
-        deleteProperty(target, key) {
-            if (typeof key === "symbol") {
-                return Reflect.deleteProperty(target, key);
-            }
-            const signal = signals[key];
-            signal?.notify();
-            delete signals[key];
-            return Reflect.deleteProperty(target, key);
-        },
-    });
-    proxyCache.set(value, proxy);
-    return proxy;
-}

package/dist/createState.test.d.ts

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

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

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