@effectionx/jsonl-store 0.3.0 → 0.4.0

package/esm/deps/jsr.io/@std/fs/1.0.20/exists.js

@@ -1,269 +0,0 @@
-// Copyright 2018-2025 the Deno authors. MIT license.
-/**
- * Asynchronously test whether or not the given path exists by checking with
- * the file system.
- *
- * Note: Do not use this function if performing a check before another operation
- * on that file. Doing so creates a race condition. Instead, perform the actual
- * file operation directly. This function is not recommended for this use case.
- * See the recommended method below.
- *
- * @see {@link https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use} for
- * more information on the time-of-check to time-of-use bug.
- *
- * Requires `--allow-read` permissions, and in some cases, `--allow-sys`
- * permissions if `options.isReadable` is `true`.
- *
- * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
- * for more information on Deno's permissions system.
- *
- * @param path The path to the file or directory, as a string or URL.
- * @param options Additional options for the check.
- *
- * @returns A promise that resolves with `true` if the path exists, `false`
- * otherwise.
- *
- * @example Recommended method
- * ```ts ignore
- * // Notice no use of exists
- * try {
- *   await Deno.remove("./foo", { recursive: true });
- * } catch (error) {
- *   if (!(error instanceof Deno.errors.NotFound)) {
- *     throw error;
- *   }
- *   // Do nothing...
- * }
- * ```
- *
- * Notice that `exists()` is not used in the above example. Doing so avoids a
- * possible race condition. See the above note for details.
- *
- * @example Basic usage
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./exists"); // true
- * await exists("./does_not_exist"); // false
- * ```
- *
- * @example Check if a path is readable
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./readable", { isReadable: true }); // true
- * await exists("./not_readable", { isReadable: true }); // false
- * ```
- *
- * @example Check if a path is a directory
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./directory", { isDirectory: true }); // true
- * await exists("./file", { isDirectory: true }); // false
- * ```
- *
- * @example Check if a path is a file
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./file", { isFile: true }); // true
- * await exists("./directory", { isFile: true }); // false
- * ```
- *
- * @example Check if a path is a readable directory
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./readable_directory", { isReadable: true, isDirectory: true }); // true
- * await exists("./not_readable_directory", { isReadable: true, isDirectory: true }); // false
- * ```
- *
- * @example Check if a path is a readable file
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { exists } from "@std/fs/exists";
- *
- * await exists("./readable_file", { isReadable: true, isFile: true }); // true
- * await exists("./not_readable_file", { isReadable: true, isFile: true }); // false
- * ```
- */
-export async function exists(path, options) {
-    try {
-        const stat = await Deno.stat(path);
-        if (options &&
-            (options.isReadable || options.isDirectory || options.isFile)) {
-            if (options.isDirectory && options.isFile) {
-                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together");
-            }
-            if ((options.isDirectory && !stat.isDirectory) ||
-                (options.isFile && !stat.isFile)) {
-                return false;
-            }
-            if (options.isReadable) {
-                return fileIsReadable(stat);
-            }
-        }
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Deno.errors.NotFound) {
-            return false;
-        }
-        if (error instanceof Deno.errors.PermissionDenied) {
-            if ((await Deno.permissions.query({ name: "read", path })).state ===
-                "granted") {
-                // --allow-read not missing
-                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
-            }
-        }
-        throw error;
-    }
-}
-/**
- * Synchronously test whether or not the given path exists by checking with
- * the file system.
- *
- * Note: Do not use this function if performing a check before another operation
- * on that file. Doing so creates a race condition. Instead, perform the actual
- * file operation directly. This function is not recommended for this use case.
- * See the recommended method below.
- *
- * @see {@link https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use} for
- * more information on the time-of-check to time-of-use bug.
- *
- * Requires `--allow-read` permissions, and in some cases, `--allow-sys`
- * permissions if `options.isReadable` is `true`.
- *
- * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
- * for more information on Deno's permissions system.
- *
- * @param path The path to the file or directory, as a string or URL.
- * @param options Additional options for the check.
- *
- * @returns `true` if the path exists, `false` otherwise.
- *
- * @example Recommended method
- * ```ts ignore
- * // Notice no use of exists
- * try {
- *   Deno.removeSync("./foo", { recursive: true });
- * } catch (error) {
- *   if (!(error instanceof Deno.errors.NotFound)) {
- *     throw error;
- *   }
- *   // Do nothing...
- * }
- * ```
- *
- * Notice that `existsSync()` is not used in the above example. Doing so avoids
- * a possible race condition. See the above note for details.
- *
- * @example Basic usage
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./exists"); // true
- * existsSync("./does_not_exist"); // false
- * ```
- *
- * @example Check if a path is readable
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./readable", { isReadable: true }); // true
- * existsSync("./not_readable", { isReadable: true }); // false
- * ```
- *
- * @example Check if a path is a directory
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./directory", { isDirectory: true }); // true
- * existsSync("./file", { isDirectory: true }); // false
- * ```
- *
- * @example Check if a path is a file
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./file", { isFile: true }); // true
- * existsSync("./directory", { isFile: true }); // false
- * ```
- *
- * @example Check if a path is a readable directory
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./readable_directory", { isReadable: true, isDirectory: true }); // true
- * existsSync("./not_readable_directory", { isReadable: true, isDirectory: true }); // false
- * ```
- *
- * @example Check if a path is a readable file
- *
- * Requires `--allow-sys` permissions in some cases.
- *
- * ```ts ignore
- * import { existsSync } from "@std/fs/exists";
- *
- * existsSync("./readable_file", { isReadable: true, isFile: true }); // true
- * existsSync("./not_readable_file", { isReadable: true, isFile: true }); // false
- * ```
- */
-export function existsSync(path, options) {
-    try {
-        const stat = Deno.statSync(path);
-        if (options &&
-            (options.isReadable || options.isDirectory || options.isFile)) {
-            if (options.isDirectory && options.isFile) {
-                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together");
-            }
-            if ((options.isDirectory && !stat.isDirectory) ||
-                (options.isFile && !stat.isFile)) {
-                return false;
-            }
-            if (options.isReadable) {
-                return fileIsReadable(stat);
-            }
-        }
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Deno.errors.NotFound) {
-            return false;
-        }
-        if (error instanceof Deno.errors.PermissionDenied) {
-            if (Deno.permissions.querySync({ name: "read", path }).state === "granted") {
-                // --allow-read not missing
-                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
-            }
-        }
-        throw error;
-    }
-}
-function fileIsReadable(stat) {
-    if (stat.mode === null) {
-        return true; // Exclusive on Non-POSIX systems
-    }
-    else if (Deno.uid() === stat.uid) {
-        return (stat.mode & 0o400) === 0o400; // User is owner and can read?
-    }
-    else if (Deno.gid() === stat.gid) {
-        return (stat.mode & 0o040) === 0o040; // User group is owner and can read?
-    }
-    return (stat.mode & 0o004) === 0o004; // Others can read?
-}

package/esm/deps/jsr.io/@std/fs/1.0.20/expand_glob.d.ts

@@ -1,267 +0,0 @@
-import { type GlobOptions } from "../../path/1.1.3/glob_to_regexp.js";
-import { type WalkEntry } from "./_create_walk_entry.js";
-export type { GlobOptions, WalkEntry };
-/** Options for {@linkcode expandGlob} and {@linkcode expandGlobSync}. */
-export interface ExpandGlobOptions extends Omit<GlobOptions, "os"> {
-    /**
-     * File path where to expand from.
-     *
-     * @default {Deno.cwd()}
-     */
-    root?: string;
-    /**
-     * List of glob patterns to be excluded from the expansion.
-     *
-     * @default {[]}
-     */
-    exclude?: string[];
-    /**
-     * Whether to include directories in entries.
-     *
-     * @default {true}
-     */
-    includeDirs?: boolean;
-    /**
-     * Whether to follow symbolic links.
-     *
-     * @default {false}
-     */
-    followSymlinks?: boolean;
-    /**
-     * Indicates whether the followed symlink's path should be canonicalized.
-     * This option works only if `followSymlinks` is not `false`.
-     *
-     * @default {true}
-     */
-    canonicalize?: boolean;
-}
-/**
- * Returns an async iterator that yields each file path matching the given glob
- * pattern.
- *
- * The file paths are absolute paths. If `root` is not provided, the current
- * working directory is used. The `root` directory is not included in the
- * yielded file paths.
- *
- * Requires `--allow-read` permission.
- *
- * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
- * for more information on Deno's permissions system.
- *
- * @param glob The glob pattern to expand.
- * @param options Additional options for the expansion.
- *
- * @returns An async iterator that yields each walk entry matching the glob
- * pattern.
- *
- * @example Basic usage
- *
- * File structure:
- * ```
- * folder
- * ├── script.ts
- * └── foo.ts
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlob } from "@std/fs/expand-glob";
- *
- * await Array.fromAsync(expandGlob("*.ts"));
- * // [
- * //   {
- * //     path: "/Users/user/folder/script.ts",
- * //     name: "script.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * //   {
- * //     path: "/Users/user/folder/foo.ts",
- * //     name: "foo.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * // ]
- * ```
- *
- * @example Define root directory
- *
- * Setting the `root` option to `/folder` will expand the glob pattern from the
- * `/folder` directory.
- *
- * File structure:
- * ```
- * folder
- * ├── subdir
- * │   └── bar.ts
- * ├── script.ts
- * └── foo.ts
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlob } from "@std/fs/expand-glob";
- *
- * await Array.fromAsync(expandGlob("*.ts", { root: "./subdir" }));
- * // [
- * //   {
- * //     path: "/Users/user/folder/subdir/bar.ts",
- * //     name: "bar.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * // ]
- * ```
- *
- * @example Exclude files
- *
- * Setting the `exclude` option to `["foo.ts"]` will exclude the `foo.ts` file
- * from the expansion.
- *
- * File structure:
- * ```
- * folder
- * ├── script.ts
- * └── foo.ts
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlob } from "@std/fs/expand-glob";
- *
- * await Array.fromAsync(expandGlob("*.ts", { exclude: ["foo.ts"] }));
- * // [
- * //   {
- * //     path: "/Users/user/folder/script.ts",
- * //     name: "true.ts",
- * //     isFile: false,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * // ]
- * ```
- *
- * @example Exclude directories
- *
- * Setting the `includeDirs` option to `false` will exclude directories from the
- * expansion.
- *
- * File structure:
- * ```
- * folder
- * ├── subdir
- * │   └── bar.ts
- * ├── script.ts
- * └── foo.ts
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlob } from "@std/fs/expand-glob";
- *
- * await Array.fromAsync(expandGlob("*", { includeDirs: false }));
- * // [
- * //   {
- * //     path: "/Users/user/folder/script.ts",
- * //     name: "script.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * //   {
- * //     path: "/Users/user/folder/foo.ts",
- * //     name: "foo.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * // ]
- * ```
- *
- * @example Follow symbolic links
- *
- * Setting the `followSymlinks` option to `true` will follow symbolic links.
- *
- * File structure:
- * ```
- * folder
- * ├── script.ts
- * └── link.ts -> script.ts (symbolic link)
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlob } from "@std/fs/expand-glob";
- *
- * await Array.fromAsync(expandGlob("*.ts", { followSymlinks: true }));
- * // [
- * //   {
- * //     path: "/Users/user/folder/script.ts",
- * //     name: "script.ts",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: false,
- * //   },
- * //   {
- * //     path: "/Users/user/folder/symlink",
- * //     name: "symlink",
- * //     isFile: true,
- * //     isDirectory: false,
- * //     isSymlink: true,
- * //   },
- * // ]
- * ```
- */
-export declare function expandGlob(glob: string | URL, options?: ExpandGlobOptions): AsyncIterableIterator<WalkEntry>;
-/**
- * Returns an iterator that yields each file path matching the given glob
- * pattern. The file paths are relative to the provided `root` directory.
- * If `root` is not provided, the current working directory is used.
- * The `root` directory is not included in the yielded file paths.
- *
- * Requires the `--allow-read` flag.
- *
- * @see {@link https://docs.deno.com/runtime/manual/basics/permissions#file-system-access}
- * for more information on Deno's permissions system.
- *
- * @param glob The glob pattern to expand.
- * @param options Additional options for the expansion.
- *
- * @returns An iterator that yields each walk entry matching the glob pattern.
- *
- * @example Usage
- *
- * File structure:
- * ```
- * folder
- * ├── script.ts
- * └── foo.ts
- * ```
- *
- * ```ts ignore
- * // script.ts
- * import { expandGlobSync } from "@std/fs/expand-glob";
- *
- * const entries = [];
- * for (const entry of expandGlobSync("*.ts")) {
- *   entries.push(entry);
- * }
- *
- * entries[0]!.path; // "/Users/user/folder/script.ts"
- * entries[0]!.name; // "script.ts"
- * entries[0]!.isFile; // false
- * entries[0]!.isDirectory; // true
- * entries[0]!.isSymlink; // false
- *
- * entries[1]!.path; // "/Users/user/folder/foo.ts"
- * entries[1]!.name; // "foo.ts"
- * entries[1]!.isFile; // true
- * entries[1]!.isDirectory; // false
- * entries[1]!.isSymlink; // false
- * ```
- */
-export declare function expandGlobSync(glob: string | URL, options?: ExpandGlobOptions): IterableIterator<WalkEntry>;
-//# sourceMappingURL=expand_glob.d.ts.map

package/esm/deps/jsr.io/@std/fs/1.0.20/expand_glob.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expand_glob.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.20/expand_glob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAgB,MAAM,oCAAoC,CAAC;AAQpF,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,yBAAyB,CAAC;AAGjC,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AAEvC,yEAAyE;AACzE,MAAM,WAAW,iBAAkB,SAAQ,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC;IAChE;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAuCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmLG;AACH,wBAAuB,UAAU,CAC/B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,qBAAqB,CAAC,SAAS,CAAC,CAyGlC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAiB,cAAc,CAC7B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,gBAAgB,CAAC,SAAS,CAAC,CAuG7B"}