@effectionx/jsonl-store 0.1.2 → 0.3.0

package/script/deps/jsr.io/@std/streams/1.0.14/to_transform_stream.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Convert the generator function into a {@linkcode TransformStream}.
+ *
+ * @typeparam I The type of the chunks in the source stream.
+ * @typeparam O The type of the chunks in the transformed stream.
+ * @param transformer A function to transform.
+ * @param writableStrategy An object that optionally defines a queuing strategy for the stream.
+ * @param readableStrategy An object that optionally defines a queuing strategy for the stream.
+ * @returns A {@linkcode TransformStream} that transforms the source stream as defined by the provided transformer.
+ *
+ * @example Build a transform stream that multiplies each value by 100
+ * ```ts
+ * import { toTransformStream } from "@std/streams/to-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([0, 1, 2])
+ *   .pipeThrough(toTransformStream(async function* (src) {
+ *     for await (const chunk of src) {
+ *       yield chunk * 100;
+ *     }
+ *   }));
+ *
+ * assertEquals(
+ *   await Array.fromAsync(stream),
+ *   [0, 100, 200],
+ * );
+ * ```
+ *
+ * @example JSON Lines
+ * ```ts
+ * import { TextLineStream } from "@std/streams/text-line-stream";
+ * import { toTransformStream } from "@std/streams/to-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([
+ *   '{"name": "Alice", "age": ',
+ *   '30}\n{"name": "Bob", "age"',
+ *   ": 25}\n",
+ * ]);
+ *
+ * type Person = { name: string; age: number };
+ *
+ * // Split the stream by newline and parse each line as a JSON object
+ * const jsonStream = stream.pipeThrough(new TextLineStream())
+ *   .pipeThrough(toTransformStream(async function* (src) {
+ *     for await (const chunk of src) {
+ *       if (chunk.trim().length === 0) {
+ *         continue;
+ *       }
+ *       yield JSON.parse(chunk) as Person;
+ *     }
+ *   }));
+ *
+ * assertEquals(
+ *   await Array.fromAsync(jsonStream),
+ *   [{ "name": "Alice", "age": 30 }, { "name": "Bob", "age": 25 }],
+ * );
+ * ```
+ */
+export declare function toTransformStream<I, O>(transformer: (src: ReadableStream<I>) => Iterable<O> | AsyncIterable<O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
+//# sourceMappingURL=to_transform_stream.d.ts.map

package/script/deps/jsr.io/@std/streams/1.0.14/to_transform_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_transform_stream.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/to_transform_stream.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EACpC,WAAW,EAAE,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EACvE,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EACrC,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GACpC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CA2CvB"}

package/script/deps/jsr.io/@std/streams/1.0.14/to_transform_stream.js

@@ -0,0 +1,106 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTransformStream = toTransformStream;
+/**
+ * Convert the generator function into a {@linkcode TransformStream}.
+ *
+ * @typeparam I The type of the chunks in the source stream.
+ * @typeparam O The type of the chunks in the transformed stream.
+ * @param transformer A function to transform.
+ * @param writableStrategy An object that optionally defines a queuing strategy for the stream.
+ * @param readableStrategy An object that optionally defines a queuing strategy for the stream.
+ * @returns A {@linkcode TransformStream} that transforms the source stream as defined by the provided transformer.
+ *
+ * @example Build a transform stream that multiplies each value by 100
+ * ```ts
+ * import { toTransformStream } from "@std/streams/to-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([0, 1, 2])
+ *   .pipeThrough(toTransformStream(async function* (src) {
+ *     for await (const chunk of src) {
+ *       yield chunk * 100;
+ *     }
+ *   }));
+ *
+ * assertEquals(
+ *   await Array.fromAsync(stream),
+ *   [0, 100, 200],
+ * );
+ * ```
+ *
+ * @example JSON Lines
+ * ```ts
+ * import { TextLineStream } from "@std/streams/text-line-stream";
+ * import { toTransformStream } from "@std/streams/to-transform-stream";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream = ReadableStream.from([
+ *   '{"name": "Alice", "age": ',
+ *   '30}\n{"name": "Bob", "age"',
+ *   ": 25}\n",
+ * ]);
+ *
+ * type Person = { name: string; age: number };
+ *
+ * // Split the stream by newline and parse each line as a JSON object
+ * const jsonStream = stream.pipeThrough(new TextLineStream())
+ *   .pipeThrough(toTransformStream(async function* (src) {
+ *     for await (const chunk of src) {
+ *       if (chunk.trim().length === 0) {
+ *         continue;
+ *       }
+ *       yield JSON.parse(chunk) as Person;
+ *     }
+ *   }));
+ *
+ * assertEquals(
+ *   await Array.fromAsync(jsonStream),
+ *   [{ "name": "Alice", "age": 30 }, { "name": "Bob", "age": 25 }],
+ * );
+ * ```
+ */
+// deno-lint-ignore deno-style-guide/exported-function-args-maximum
+function toTransformStream(transformer, writableStrategy, readableStrategy) {
+    const { writable, readable, } = new TransformStream(undefined, writableStrategy);
+    const iterable = transformer(readable);
+    const iterator = iterable[Symbol.asyncIterator]?.() ??
+        iterable[Symbol.iterator]?.();
+    return {
+        writable,
+        readable: new ReadableStream({
+            async pull(controller) {
+                let result;
+                try {
+                    result = await iterator.next();
+                }
+                catch (error) {
+                    // Propagate error to stream from iterator
+                    // If the stream status is "errored", it will be thrown, but ignore.
+                    await readable.cancel(error).catch(() => { });
+                    controller.error(error);
+                    return;
+                }
+                if (result.done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel(reason) {
+                // Propagate cancellation to readable and iterator
+                if (typeof iterator.throw === "function") {
+                    try {
+                        await iterator.throw(reason);
+                    }
+                    catch {
+                        /* `iterator.throw()` always throws on site. We catch it. */
+                    }
+                }
+                await readable.cancel(reason);
+            },
+        }, readableStrategy),
+    };
+}

package/script/deps/jsr.io/@std/streams/1.0.14/zip_readable_streams.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Merge multiple streams into a single one, taking order into account, and
+ * each stream will wait for a chunk to enqueue before the next stream can
+ * append another chunk.
+ *
+ * If a stream ends before other ones, the others will continue adding data in
+ * order, and the finished one will not add any more data. If you want to cancel
+ * the other streams when one of them ends, use {@linkcode earlyZipReadableStreams}.
+ *
+ * @typeparam T The type of the chunks in the input/output streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the zipped chunks.
+ *
+ * @example Zip 2 streams with the same length
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "c"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is shorter)
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c", "d"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "c", "d"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is longer)
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3", "4"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "4"],
+ * );
+ * ```
+ *
+ * @example Zip 3 streams
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const stream3 = ReadableStream.from(["A", "B", "C"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2, stream3);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "A", "b", "B", "C"],
+ * );
+ * ```
+ */
+export declare function zipReadableStreams<T>(...streams: ReadableStream<T>[]): ReadableStream<T>;
+//# sourceMappingURL=zip_readable_streams.d.ts.map

package/script/deps/jsr.io/@std/streams/1.0.14/zip_readable_streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip_readable_streams.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.0.14/zip_readable_streams.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CAuBnB"}

package/script/deps/jsr.io/@std/streams/1.0.14/zip_readable_streams.js

@@ -0,0 +1,105 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipReadableStreams = zipReadableStreams;
+/**
+ * Merge multiple streams into a single one, taking order into account, and
+ * each stream will wait for a chunk to enqueue before the next stream can
+ * append another chunk.
+ *
+ * If a stream ends before other ones, the others will continue adding data in
+ * order, and the finished one will not add any more data. If you want to cancel
+ * the other streams when one of them ends, use {@linkcode earlyZipReadableStreams}.
+ *
+ * @typeparam T The type of the chunks in the input/output streams.
+ * @param streams An iterable of `ReadableStream`s to merge.
+ * @returns A `ReadableStream` that will emit the zipped chunks.
+ *
+ * @example Zip 2 streams with the same length
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "c"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is shorter)
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2"]);
+ * const stream2 = ReadableStream.from(["a", "b", "c", "d"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "c", "d"],
+ * );
+ * ```
+ *
+ * @example Zip 2 streams with different length (first one is longer)
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1", "2", "3", "4"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "2", "b", "3", "4"],
+ * );
+ * ```
+ *
+ * @example Zip 3 streams
+ * ```ts
+ * import { zipReadableStreams } from "@std/streams/zip-readable-streams";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const stream1 = ReadableStream.from(["1"]);
+ * const stream2 = ReadableStream.from(["a", "b"]);
+ * const stream3 = ReadableStream.from(["A", "B", "C"]);
+ * const zippedStream = zipReadableStreams(stream1, stream2, stream3);
+ *
+ * assertEquals(
+ *   await Array.fromAsync(zippedStream),
+ *   ["1", "a", "A", "b", "B", "C"],
+ * );
+ * ```
+ */
+function zipReadableStreams(...streams) {
+    const readers = new Set(streams.map((s) => s.getReader()));
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                let resolved = 0;
+                while (resolved !== streams.length) {
+                    for (const reader of readers) {
+                        const { value, done } = await reader.read();
+                        if (!done) {
+                            controller.enqueue(value);
+                        }
+                        else {
+                            resolved++;
+                            readers.delete(reader);
+                        }
+                    }
+                }
+                controller.close();
+            }
+            catch (e) {
+                controller.error(e);
+            }
+        },
+    });
+}

package/script/jsonl.d.ts

@@ -36,7 +36,7 @@ export declare class JSONLStore implements Store {
      * Returns content of a file as a stream
      *
      * ```ts
-     * import { each } from "npm:effection@4.0.0-alpha.3";
+     * import { each } from "npm:effection@^3";
      * import { useStore } from "jsr:@effectionx/jsonl-store";
      *
      * const store = yield* useStore();
@@ -82,7 +82,7 @@ export declare class JSONLStore implements Store {
      * Returns a stream of content from all files matching a glob
      *
      * ```ts
-     * import { each } from "npm:effection@4.0.0-alpha.3";
+     * import { each } from "npm:effection@^3";
      * import { useStore } from "jsr:@effectionx/jsonl-store";
      *
      * const store = yield* useStore();

package/script/jsonl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../src/jsonl.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,SAAS,EAGd,KAAK,MAAM,EAEZ,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAcjE,qBAAa,UAAW,YAAW,KAAK;IACnB,QAAQ,EAAE,GAAG;gBAAb,QAAQ,EAAE,GAAG;IAEhC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU;IAgBzD;;;;;;;;;;;;;;OAcG;IACF,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC;IAYrC;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;IAgCrC;;;;;;;;;;;OAWG;IACF,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC;IAqBnD;;;;;;;;;;;;OAYG;IACF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC;IAkBpD;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;IA0CrC,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC;CAG1B"}
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../src/jsonl.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,SAAS,EAGd,KAAK,MAAM,EAEZ,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAejE,qBAAa,UAAW,YAAW,KAAK;IACnB,QAAQ,EAAE,GAAG;gBAAb,QAAQ,EAAE,GAAG;IAEhC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU;IAgBzD;;;;;;;;;;;;;;OAcG;IACF,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC;IAYrC;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;IAiCrC;;;;;;;;;;;OAWG;IACF,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC;IAcnD;;;;;;;;;;;;OAYG;IACF,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC;IAYpD;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC;IA0CrC,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC;CAG1B"}

package/script/jsonl.js

@@ -1,18 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONLStore = void 0;
-const json_1 = require("@std/json");
-const streams_1 = require("@std/streams");
-const fs_1 = require("@std/fs");
-const path_1 = require("@std/path");
+const mod_js_1 = require("./deps/jsr.io/@std/json/1.0.2/mod.js");
+const mod_js_2 = require("./deps/jsr.io/@std/streams/1.0.14/mod.js");
+const mod_js_3 = require("./deps/jsr.io/@std/fs/1.0.20/mod.js");
+const mod_js_4 = require("./deps/jsr.io/@std/path/1.1.3/mod.js");
 const effection_1 = require("effection");
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_util_1 = require("node:util");
+const fsp = __importStar(require("node:fs/promises"));
+const node_stream_1 = require("node:stream");
 function* mkdir(path, options) {
-    return yield* (0, effection_1.call)(() => (0, node_util_1.promisify)(node_fs_1.default.mkdir)(path, options));
+    return yield* (0, effection_1.call)(() => fsp.mkdir(path, options));
 }
 class JSONLStore {
     constructor(location) {
@@ -40,10 +74,10 @@ class JSONLStore {
             ? options.location.pathname
             : options.location;
         if (pathname.charAt(-1) === "/") {
-            return new JSONLStore((0, path_1.toFileUrl)(pathname));
+            return new JSONLStore((0, mod_js_4.toFileUrl)(pathname));
         }
         else {
-            return new JSONLStore((0, path_1.toFileUrl)(`${pathname}/`));
+            return new JSONLStore((0, mod_js_4.toFileUrl)(`${pathname}/`));
         }
     }
     /**
@@ -65,7 +99,7 @@ class JSONLStore {
         const location = new URL(`./${key}.jsonl`, this.location);
         return yield* (0, effection_1.call)(async () => {
             try {
-                return await (0, fs_1.exists)(location);
+                return await (0, mod_js_3.exists)(location);
             }
             catch {
                 return false;
@@ -76,7 +110,7 @@ class JSONLStore {
      * Returns content of a file as a stream
      *
      * ```ts
-     * import { each } from "npm:effection@4.0.0-alpha.3";
+     * import { each } from "npm:effection@^3";
      * import { useStore } from "jsr:@effectionx/jsonl-store";
      *
      * const store = yield* useStore();
@@ -94,12 +128,13 @@ class JSONLStore {
         const location = new URL(`./${key}.jsonl`, this.location);
         return (0, effection_1.resource)(function* (provide) {
             const channel = (0, effection_1.createChannel)();
-            const file = yield* (0, effection_1.call)(() => Deno.open(location, { read: true }));
-            const lines = file
-                .readable
+            const fileStream = node_fs_1.default.createReadStream((0, mod_js_4.fromFileUrl)(location));
+            const webStream = node_stream_1.Readable.toWeb(fileStream);
+            // deno-lint-ignore no-explicit-any
+            const lines = webStream
                 .pipeThrough(new TextDecoderStream())
-                .pipeThrough(new streams_1.TextLineStream())
-                .pipeThrough(new json_1.JsonParseStream());
+                .pipeThrough(new mod_js_2.TextLineStream())
+                .pipeThrough(new mod_js_1.JsonParseStream());
             yield* (0, effection_1.spawn)(function* () {
                 const reader = lines.getReader();
                 try {
@@ -132,17 +167,8 @@ class JSONLStore {
      */
     *write(key, data) {
         const location = new URL(`./${key}.jsonl`, this.location);
-        yield* mkdir((0, path_1.dirname)(location.pathname), { recursive: true });
-        const file = yield* (0, effection_1.call)(() => Deno.open(location, {
-            create: true,
-            write: true,
-        }));
-        try {
-            yield* (0, effection_1.call)(() => file.write(new TextEncoder().encode(`${JSON.stringify(data)}\n`)));
-        }
-        finally {
-            file.close();
-        }
+        yield* mkdir((0, mod_js_4.dirname)((0, mod_js_4.fromFileUrl)(location)), { recursive: true });
+        yield* (0, effection_1.call)(() => fsp.writeFile((0, mod_js_4.fromFileUrl)(location), `${JSON.stringify(data)}\n`, { encoding: "utf-8" }));
     }
     /**
      * Add data to an existing file.
@@ -159,21 +185,13 @@ class JSONLStore {
      */
     *append(key, data) {
         const location = new URL(`./${key}.jsonl`, this.location);
-        const file = yield* (0, effection_1.call)(() => Deno.open(location, {
-            append: true,
-        }));
-        try {
-            yield* (0, effection_1.call)(() => file.write(new TextEncoder().encode(`${JSON.stringify(data)}\n`)));
-        }
-        finally {
-            file.close();
-        }
+        yield* (0, effection_1.call)(() => fsp.appendFile((0, mod_js_4.fromFileUrl)(location), `${JSON.stringify(data)}\n`, { encoding: "utf-8" }));
     }
     /**
      * Returns a stream of content from all files matching a glob
      *
      * ```ts
-     * import { each } from "npm:effection@4.0.0-alpha.3";
+     * import { each } from "npm:effection@^3";
      * import { useStore } from "jsr:@effectionx/jsonl-store";
      *
      * const store = yield* useStore();
@@ -188,11 +206,11 @@ class JSONLStore {
      * @returns Stream<T, void>
      */
     find(glob) {
-        const { pathname } = this.location;
-        const reg = (0, path_1.globToRegExp)(`${pathname}/${glob}`, {
+        const root = (0, mod_js_4.fromFileUrl)(this.location);
+        const reg = (0, mod_js_4.globToRegExp)((0, mod_js_4.join)(root, glob), {
             globstar: true,
         });
-        const files = (0, fs_1.walk)(this.location, {
+        const files = (0, mod_js_3.walk)(root, {
             includeDirs: false,
             includeFiles: true,
             match: [
@@ -204,7 +222,10 @@ class JSONLStore {
             const queue = (0, effection_1.createQueue)();
             yield* (0, effection_1.spawn)(function* () {
                 for (const file of yield* (0, effection_1.each)((0, effection_1.stream)(files))) {
-                    const key = (0, path_1.join)((0, path_1.dirname)(file.path.replace(pathname, "")), (0, path_1.basename)(file.name, ".jsonl"));
+                    const key = file.path
+                        .replace(root, "")
+                        .replaceAll(`\\`, `/`)
+                        .replace(/\.jsonl$/, "");
                     for (const item of yield* (0, effection_1.each)(read(key))) {
                         queue.add(item);
                         yield* effection_1.each.next();
@@ -217,7 +238,7 @@ class JSONLStore {
         });
     }
     *clear() {
-        yield* (0, effection_1.call)(() => (0, fs_1.emptyDir)(this.location));
+        yield* (0, effection_1.call)(() => (0, mod_js_3.emptyDir)(this.location));
     }
 }
 exports.JSONLStore = JSONLStore;

package/script/mod.d.ts

@@ -1,3 +1,4 @@
+import "./_dnt.polyfills.js";
 export { StoreContext, useStore } from "./context.js";
 export { JSONLStore } from "./jsonl.js";
 export * from "./types.js";

package/script/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,cAAc,YAAY,CAAC"}

package/script/mod.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONLStore = exports.useStore = exports.StoreContext = void 0;
+require("./_dnt.polyfills.js");
 var context_js_1 = require("./context.js");
 Object.defineProperty(exports, "StoreContext", { enumerable: true, get: function () { return context_js_1.StoreContext; } });
 Object.defineProperty(exports, "useStore", { enumerable: true, get: function () { return context_js_1.useStore; } });