rask-ui 0.27.0 → 0.28.0

package/dist/createState.js

@@ -0,0 +1,129 @@
+import { getCurrentComponent } from "./component";
+import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
+import { getCurrentObserver, Signal } from "./observation";
+export function assignState(state, newState) {
+    return Object.assign(state, newState);
+}
+/**
+ * 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) {
+    if (getCurrentComponent()?.isRendering) {
+        throw new Error("createState cannot be called during render. Call it in component setup or globally.");
+    }
+    return getProxy(state, {});
+}
+const proxyCache = new WeakMap();
+export const PROXY_MARKER = Symbol("isProxy");
+function getProxy(value, notifyInspectorRef) {
+    // 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;
+            }
+            if (INSPECTOR_ENABLED && key === INSPECT_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;
+            }
+            if (INSPECTOR_ENABLED && key === INSPECT_MARKER) {
+                return !notifyInspectorRef.current;
+            }
+            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, INSPECTOR_ENABLED && notifyInspectorRef.current
+                    ? {
+                        current: {
+                            notify: notifyInspectorRef.current.notify,
+                            path: notifyInspectorRef.current.path.concat(key),
+                        },
+                    }
+                    : notifyInspectorRef);
+            }
+            return value;
+        },
+        set(target, key, newValue) {
+            if (INSPECTOR_ENABLED && key === INSPECT_MARKER) {
+                Object.defineProperty(notifyInspectorRef, "current", {
+                    get() {
+                        return newValue.current;
+                    },
+                });
+                return Reflect.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")) {
+                const signal = signals[key];
+                signal?.notify();
+            }
+            if (INSPECTOR_ENABLED) {
+                notifyInspectorRef.current?.notify({
+                    type: "mutation",
+                    path: notifyInspectorRef.current.path,
+                    value: newValue,
+                });
+            }
+            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/createTask.d.ts

@@ -0,0 +1,31 @@
+export type TaskState<P, T> = {
+    isRunning: false;
+    params: null;
+    result: null;
+    error: null;
+} | {
+    isRunning: true;
+    result: T | null;
+    params: P;
+    error: null;
+} | {
+    isRunning: false;
+    params: null;
+    result: T;
+    error: null;
+} | {
+    isRunning: false;
+    params: null;
+    result: null;
+    error: string;
+};
+export type Task<A, B = never> = [B] extends [never] ? TaskState<null, A> & {
+    run(): Promise<A>;
+    rerun(): Promise<A>;
+} : TaskState<A, B> & {
+    run(params: A): Promise<B>;
+    rerun(params: A): Promise<B>;
+};
+export declare function createTask<T>(task: (params: undefined, signal: AbortSignal) => Promise<T>): Task<T>;
+export declare function createTask<P, T>(task: (params: P, signal: AbortSignal) => Promise<T>): Task<P, T>;
+//# sourceMappingURL=createTask.d.ts.map

package/dist/createTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../src/createTask.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IACtB;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACjB,MAAM,EAAE,CAAC,CAAC;IACV,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,CAAC,CAAC;IACV,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,EAAE,IAAI,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAChD,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG;IACnB,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;IAClB,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CACrB,GACD,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAChB,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3B,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9B,CAAC;AAEN,wBAAgB,UAAU,CAAC,CAAC,EAC1B,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3D,IAAI,CAAC,CAAC,CAAC,CAAC;AACX,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GACnD,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/createTask.js

@@ -0,0 +1,79 @@
+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/createView.d.ts

@@ -0,0 +1,28 @@
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : never;
+type UndefinedKeys<T> = {
+    [K in keyof T]-?: [T[K]] extends [undefined] ? K : never;
+}[keyof T];
+type MergeTwo<A extends object, B extends object> = A extends any ? Simplify<Omit<A, keyof B> & Omit<B, UndefinedKeys<B>>> : never;
+type MergeMany<T extends readonly object[]> = T extends [
+    infer H extends object,
+    ...infer R extends object[]
+] ? MergeManyAcc<H, R> : {};
+type MergeManyAcc<Acc extends object, Rest extends object[]> = Rest extends [
+    infer H extends object,
+    ...infer R extends object[]
+] ? MergeManyAcc<MergeTwo<Acc, H>, R> : Acc;
+/**
+ * Creates a view that merges multiple objects (reactive or not) into a single
+ * object while maintaining reactivity through getters. Properties from later
+ * arguments override earlier ones.
+ *
+ * ⚠️ Do not destructure the returned view object; always read properties
+ * directly from the view to preserve reactivity.
+ */
+export declare function createView<A extends object>(a: A): A;
+export declare function createView<A extends object, B extends object>(a: A, b: B): MergeTwo<A, B>;
+export declare function createView<T extends readonly object[]>(...args: T): MergeMany<T>;
+export {};
+//# sourceMappingURL=createView.d.ts.map

package/dist/createView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createView.d.ts","sourceRoot":"","sources":["../src/createView.ts"],"names":[],"mappings":"AAGA,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAC;AAEpE,KAAK,aAAa,CAAC,CAAC,IAAI;KACrB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACzD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,GAC7D,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,GACtD,KAAK,CAAC;AAEV,KAAK,SAAS,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI,CAAC,SAAS;IACtD,MAAM,CAAC,SAAS,MAAM;IACtB,GAAG,MAAM,CAAC,SAAS,MAAM,EAAE;CAC5B,GACG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,GAClB,EAAE,CAAC;AAEP,KAAK,YAAY,CAAC,GAAG,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAAE,IAAI,IAAI,SAAS;IAC1E,MAAM,CAAC,SAAS,MAAM;IACtB,GAAG,MAAM,CAAC,SAAS,MAAM,EAAE;CAC5B,GACG,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,GAAG,CAAC;AAER;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;AACtD,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC3D,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,GACH,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,wBAAgB,UAAU,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,EACpD,GAAG,IAAI,EAAE,CAAC,GACT,SAAS,CAAC,CAAC,CAAC,CAAC"}

package/dist/createView.js

@@ -0,0 +1,77 @@
+import { getCurrentComponent } from "./component";
+import { INSPECT_MARKER, INSPECTOR_ENABLED } from "./inspect";
+export function createView(...args) {
+    if (!getCurrentComponent()) {
+        throw new Error("Only use createView in component setup");
+    }
+    const result = {};
+    const seen = new Set();
+    let notifyInspectorRef = {};
+    for (let i = args.length - 1; i >= 0; i--) {
+        const src = args[i];
+        if (!src)
+            continue;
+        if (INSPECTOR_ENABLED && src[INSPECT_MARKER]) {
+            src[INSPECT_MARKER] = notifyInspectorRef;
+        }
+        // Mimic Object.assign: only enumerable own property keys
+        for (const key of Reflect.ownKeys(src)) {
+            if (seen.has(key))
+                continue;
+            const desc = Object.getOwnPropertyDescriptor(src, key);
+            if (!desc || !desc.enumerable)
+                continue;
+            Object.defineProperty(result, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => {
+                    const value = src[key];
+                    if (!INSPECTOR_ENABLED || !notifyInspectorRef.current) {
+                        return value;
+                    }
+                    // Propagate inspector marker into nested observables
+                    if (value?.[INSPECT_MARKER]) {
+                        value[INSPECT_MARKER] = {
+                            current: {
+                                notify: notifyInspectorRef.current.notify,
+                                path: notifyInspectorRef.current.path.concat(key),
+                            },
+                        };
+                    }
+                    else if (typeof value === "function") {
+                        // Wrap actions to notify inspector
+                        return (...params) => {
+                            notifyInspectorRef.current.notify({
+                                type: "action",
+                                path: notifyInspectorRef.current.path.concat(key),
+                                params,
+                            });
+                            return value(...params);
+                        };
+                    }
+                    return value;
+                },
+            });
+            seen.add(key);
+        }
+    }
+    if (INSPECTOR_ENABLED) {
+        Object.defineProperty(result, INSPECT_MARKER, {
+            enumerable: false,
+            configurable: false,
+            get() {
+                return !notifyInspectorRef.current;
+            },
+            set: (value) => {
+                Object.defineProperty(notifyInspectorRef, "current", {
+                    configurable: true,
+                    get() {
+                        return value.current;
+                    },
+                });
+            },
+        });
+    }
+    // The overload signatures expose a precise type; this is the shared impl.
+    return result;
+}

package/dist/error.d.ts

@@ -0,0 +1,5 @@
+export declare const CatchErrorContext: import("./createContext").Context<(error: unknown) => void>;
+export declare function useCatchError(): {
+    error: unknown;
+};
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,iBAAiB,4CAAyB,OAAO,KAAK,IAAI,CAAG,CAAC;AAE3E,wBAAgB,aAAa;WAQK,OAAO;EAOxC"}

package/dist/error.js

@@ -0,0 +1,16 @@
+import { useState } from "./useState";
+import { createContext, useInjectContext } from "./createContext";
+import { getCurrentComponent } from "./component";
+export const CatchErrorContext = createContext();
+export function useCatchError() {
+    const currentComponent = getCurrentComponent();
+    if (!currentComponent || currentComponent.isRendering) {
+        throw new Error("Only use the useCatchError hook in setup");
+    }
+    const inject = useInjectContext(CatchErrorContext);
+    const state = useState({
+        error: null,
+    });
+    inject((error) => (state.error = error));
+    return state;
+}

package/dist/jsx.d.ts

@@ -0,0 +1,11 @@
+// JSX type definitions
+// Re-export Inferno's comprehensive JSX types
+import 'inferno';
+
+// Re-export useful Inferno types for convenience
+export type {
+  InfernoNode,
+  InfernoChild,
+  Component,
+  ComponentType,
+} from 'inferno';

package/dist/patchInferno.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,107 @@
+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

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

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

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