@effectionx/jsonl-store 0.1.1

package/esm/deps/jsr.io/@std/streams/1.0.8/to_transform_stream.js

@@ -0,0 +1,102 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * 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 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/esm/deps/jsr.io/@std/streams/1.0.8/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/esm/deps/jsr.io/@std/streams/1.0.8/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.8/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/esm/deps/jsr.io/@std/streams/1.0.8/zip_readable_streams.js

@@ -0,0 +1,102 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * 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 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/esm/jsonl.d.ts

@@ -0,0 +1,102 @@
+import { type Operation, type Stream } from "effection";
+import type { Store, StoreConstructorOptions } from "./types.js";
+export declare class JSONLStore implements Store {
+    location: URL;
+    constructor(location: URL);
+    /**
+     * 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: StoreConstructorOptions): JSONLStore;
+    /**
+     * 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: string): Operation<boolean>;
+    /**
+     * Returns content of a file as a stream
+     *
+     * ```ts
+     * import { each } from "npm:effection@4.0.0-alpha.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<T>(key: string): Stream<T, void>;
+    /**
+     * 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: string, data: unknown): Operation<void>;
+    /**
+     * 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: string, data: unknown): Operation<void>;
+    /**
+     * Returns a stream of content from all files matching a glob
+     *
+     * ```ts
+     * import { each } from "npm:effection@4.0.0-alpha.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<T>(glob: string): Stream<T, void>;
+    clear(): Operation<void>;
+}
+//# sourceMappingURL=jsonl.d.ts.map

package/esm/jsonl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../src/jsonl.ts"],"names":[],"mappings":"AAUA,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"}

package/esm/jsonl.js

@@ -0,0 +1,216 @@
+import { JsonParseStream } from "./deps/jsr.io/@std/json/1.0.1/mod.js";
+import { TextLineStream } from "./deps/jsr.io/@std/streams/1.0.8/mod.js";
+import { emptyDir, exists, walk } from "./deps/jsr.io/@std/fs/1.0.4/mod.js";
+import { basename, dirname, globToRegExp, join, toFileUrl, } from "./deps/jsr.io/@std/path/1.0.6/mod.js";
+import { call, createChannel, createQueue, each, resource, spawn, stream, } from "effection";
+import fs from "node:fs";
+import { promisify } from "node:util";
+function* mkdir(path, options) {
+    return yield* call(() => promisify(fs.mkdir)(path, options));
+}
+export 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(toFileUrl(pathname));
+        }
+        else {
+            return new JSONLStore(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* call(async () => {
+            try {
+                return await exists(location);
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    /**
+     * Returns content of a file as a stream
+     *
+     * ```ts
+     * import { each } from "npm:effection@4.0.0-alpha.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 resource(function* (provide) {
+            const channel = createChannel();
+            const file = yield* call(() => Deno.open(location, { read: true }));
+            const lines = file
+                .readable
+                .pipeThrough(new TextDecoderStream())
+                .pipeThrough(new TextLineStream())
+                .pipeThrough(new JsonParseStream());
+            yield* spawn(function* () {
+                const reader = lines.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = yield* 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(dirname(location.pathname), { recursive: true });
+        const file = yield* call(() => Deno.open(location, {
+            create: true,
+            write: true,
+        }));
+        try {
+            yield* call(() => file.write(new TextEncoder().encode(`${JSON.stringify(data)}\n`)));
+        }
+        finally {
+            file.close();
+        }
+    }
+    /**
+     * 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);
+        const file = yield* call(() => Deno.open(location, {
+            append: true,
+        }));
+        try {
+            yield* call(() => file.write(new TextEncoder().encode(`${JSON.stringify(data)}\n`)));
+        }
+        finally {
+            file.close();
+        }
+    }
+    /**
+     * Returns a stream of content from all files matching a glob
+     *
+     * ```ts
+     * import { each } from "npm:effection@4.0.0-alpha.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 { pathname } = this.location;
+        const reg = globToRegExp(`${pathname}/${glob}`, {
+            globstar: true,
+        });
+        const files = walk(this.location, {
+            includeDirs: false,
+            includeFiles: true,
+            match: [
+                reg,
+            ],
+        });
+        const read = this.read.bind(this);
+        return resource(function* (provide) {
+            const queue = createQueue();
+            yield* spawn(function* () {
+                for (const file of yield* each(stream(files))) {
+                    const key = join(dirname(file.path.replace(pathname, "")), basename(file.name, ".jsonl"));
+                    for (const item of yield* each(read(key))) {
+                        queue.add(item);
+                        yield* each.next();
+                    }
+                    yield* each.next();
+                }
+                queue.close();
+            });
+            yield* provide(queue);
+        });
+    }
+    *clear() {
+        yield* call(() => emptyDir(this.location));
+    }
+}

package/esm/mod.d.ts

@@ -0,0 +1,5 @@
+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/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"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/esm/mod.js

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

package/esm/package.json

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

package/esm/types.d.ts

@@ -0,0 +1,14 @@
+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/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@effectionx/jsonl-store",
+  "version": "0.1.1",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "effection": "4.0.0-alpha.3"
+  },
+  "_generatedBy": "dnt@dev"
+}