@effectionx/jsonl-store 0.3.1 → 0.4.0

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

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

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

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

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

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

@@ -1,105 +0,0 @@
-"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.map

@@ -1 +0,0 @@
-{"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,244 +0,0 @@
-"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 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 fsp = __importStar(require("node:fs/promises"));
-const node_stream_1 = require("node:stream");
-function* mkdir(path, options) {
-    return yield* (0, effection_1.call)(() => fsp.mkdir(path, options));
-}
-class JSONLStore {
-    constructor(location) {
-        Object.defineProperty(this, "location", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: location
-        });
-    }
-    /**
-     * Creates a store with a location that has a trailing slash.
-     * The trailing slash is important to ensure that the store content
-     * is written to the store directory and not the directory above which
-     * can be very annoying. The location has to be absolute.
-     * ```ts
-     * const store = JSONLStore.from({ location: 'file:///Users/foo/.store/' })
-     * ```
-     *
-     * @param options StoreConstructorOptions
-     * @returns
-     */
-    static from(options) {
-        const pathname = options.location instanceof URL
-            ? options.location.pathname
-            : options.location;
-        if (pathname.charAt(-1) === "/") {
-            return new JSONLStore((0, mod_js_4.toFileUrl)(pathname));
-        }
-        else {
-            return new JSONLStore((0, mod_js_4.toFileUrl)(`${pathname}/`));
-        }
-    }
-    /**
-     * Returns true when key is present
-     * ```ts
-     * import { useStore } from "jsr:@effectionx/jsonl-store";
-     *
-     * const store = yield* useStore();
-     *
-     * if (yield* store.has("test")) {
-     *  console.log("store exists");
-     * }
-     * ```
-     *
-     * @param key string
-     * @returns boolean
-     */
-    *has(key) {
-        const location = new URL(`./${key}.jsonl`, this.location);
-        return yield* (0, effection_1.call)(async () => {
-            try {
-                return await (0, mod_js_3.exists)(location);
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    /**
-     * Returns content of a file as a stream
-     *
-     * ```ts
-     * import { each } from "npm:effection@^3";
-     * import { useStore } from "jsr:@effectionx/jsonl-store";
-     *
-     * const store = yield* useStore();
-     *
-     * for (const item of yield* each(store.read<number>("test"))) {
-     *   console.log(item)
-     *   yield* each.next();
-     * }
-     * ```
-     *
-     * @param key string
-     * @returns Stream<T>
-     */
-    read(key) {
-        const location = new URL(`./${key}.jsonl`, this.location);
-        return (0, effection_1.resource)(function* (provide) {
-            const channel = (0, effection_1.createChannel)();
-            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 mod_js_2.TextLineStream())
-                .pipeThrough(new mod_js_1.JsonParseStream());
-            yield* (0, effection_1.spawn)(function* () {
-                const reader = lines.getReader();
-                try {
-                    while (true) {
-                        const { done, value } = yield* (0, effection_1.call)(() => reader.read());
-                        yield* channel.send(value);
-                        if (done)
-                            break;
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                    yield* channel.close();
-                }
-            });
-            yield* provide(yield* channel);
-        });
-    }
-    /**
-     * Write data to a file, creates the file and necessary directory structure as it goes along.
-     *
-     * ```ts
-     * import { useStore } from "jsr:@effectionx/jsonl-store";
-     *
-     * const store = yield* useStore();
-     * yield* store.write("hello", "world");
-     * ```
-     * @param key string
-     * @param data unknown
-     */
-    *write(key, data) {
-        const location = new URL(`./${key}.jsonl`, this.location);
-        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.
-     *
-     * ```ts
-     * import { useStore } from "jsr:@effectionx/jsonl-store";
-     *
-     * const store = yield* useStore();
-     * yield* store.write("hello", "world");
-     * yield* store.append("hello", "from bob");
-     * ```
-     * @param key string
-     * @param data
-     */
-    *append(key, data) {
-        const location = new URL(`./${key}.jsonl`, this.location);
-        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@^3";
-     * import { useStore } from "jsr:@effectionx/jsonl-store";
-     *
-     * const store = yield* useStore();
-     *
-     * for (const item of yield* each(store.find<number>("subdir/*"))) {
-     *   console.log(item);
-     *    yield* each.next();
-     * }
-     * ```
-     *
-     * @param glob string
-     * @returns Stream<T, void>
-     */
-    find(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, mod_js_3.walk)(root, {
-            includeDirs: false,
-            includeFiles: true,
-            match: [
-                reg,
-            ],
-        });
-        const read = this.read.bind(this);
-        return (0, effection_1.resource)(function* (provide) {
-            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 = 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();
-                    }
-                    yield* effection_1.each.next();
-                }
-                queue.close();
-            });
-            yield* provide(queue);
-        });
-    }
-    *clear() {
-        yield* (0, effection_1.call)(() => (0, mod_js_3.emptyDir)(this.location));
-    }
-}
-exports.JSONLStore = JSONLStore;

package/script/mod.d.ts

@@ -1,5 +0,0 @@
-import "./_dnt.polyfills.js";
-export { StoreContext, useStore } from "./context.js";
-export { JSONLStore } from "./jsonl.js";
-export * from "./types.js";
-//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

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

@@ -1,24 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-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; } });
-var jsonl_js_1 = require("./jsonl.js");
-Object.defineProperty(exports, "JSONLStore", { enumerable: true, get: function () { return jsonl_js_1.JSONLStore; } });
-__exportStar(require("./types.js"), exports);

package/script/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "commonjs"
-}

package/script/types.d.ts

@@ -1,14 +0,0 @@
-import type { Operation, Stream } from "effection";
-export interface Store {
-    location: URL;
-    write(key: string, data: unknown): Operation<void>;
-    append(key: string, data: unknown): Operation<void>;
-    read<T>(key: string): Stream<T, void>;
-    has(key: string): Operation<boolean>;
-    find<T>(glob: string): Stream<T, void>;
-    clear(): Operation<void>;
-}
-export interface StoreConstructorOptions {
-    location: URL | string;
-}
-//# sourceMappingURL=types.d.ts.map

package/script/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnD,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,GAAG,CAAC;IACd,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IACtC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;IACrC,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IACvC,KAAK,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,GAAG,GAAG,MAAM,CAAC;CACxB"}

package/script/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });