track-cli 3.0.0-rc

package/esm/deps/deno.land/std@0.195.0/fs/copy.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+export interface CopyOptions {
+    /**
+     * overwrite existing file or directory.
+     * @default {false}
+     */
+    overwrite?: boolean;
+    /**
+     * When `true`, will set last modification and access times to the ones of the
+     * original source files.
+     * When `false`, timestamp behavior is OS-dependent.
+     *
+     * @default {false}
+     */
+    preserveTimestamps?: boolean;
+}
+/**
+ * Copy a file or directory. The directory can have contents. Like `cp -r`.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { copy } from "https://deno.land/std@$STD_VERSION/fs/copy.ts";
+ * copy("./foo", "./bar"); // returns a promise
+ * ```
+ *
+ * @param src the file/directory path.
+ *            Note that if `src` is a directory it will copy everything inside
+ *            of this directory, not the entire directory itself
+ * @param dest the destination path. Note that if `src` is a file, `dest` cannot
+ *             be a directory
+ * @param options
+ */
+export declare function copy(src: string | URL, dest: string | URL, options?: CopyOptions): Promise<void>;
+/**
+ * Copy a file or directory. The directory can have contents. Like `cp -r`.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { copySync } from "https://deno.land/std@$STD_VERSION/fs/copy.ts";
+ * copySync("./foo", "./bar"); // void
+ * ```
+ * @param src the file/directory path.
+ *            Note that if `src` is a directory it will copy everything inside
+ *            of this directory, not the entire directory itself
+ * @param dest the destination path. Note that if `src` is a file, `dest` cannot
+ *             be a directory
+ * @param options
+ */
+export declare function copySync(src: string | URL, dest: string | URL, options?: CopyOptions): void;

package/esm/deps/deno.land/std@0.195.0/fs/copy.js

@@ -0,0 +1,244 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+// @ts-nocheck Bypass static errors for missing --unstable.
+import * as path from "../path/mod.js";
+import { ensureDir, ensureDirSync } from "./ensure_dir.js";
+import { getFileInfoType, isSubdir, toPathString } from "./_util.js";
+import { assert } from "../assert/assert.js";
+import { isWindows } from "../_util/os.js";
+async function ensureValidCopy(src, dest, options) {
+    let destStat;
+    try {
+        destStat = await dntShim.Deno.lstat(dest);
+    }
+    catch (err) {
+        if (err instanceof dntShim.Deno.errors.NotFound) {
+            return;
+        }
+        throw err;
+    }
+    if (options.isFolder && !destStat.isDirectory) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+    }
+    if (!options.overwrite) {
+        throw new dntShim.Deno.errors.AlreadyExists(`'${dest}' already exists.`);
+    }
+    return destStat;
+}
+function ensureValidCopySync(src, dest, options) {
+    let destStat;
+    try {
+        destStat = dntShim.Deno.lstatSync(dest);
+    }
+    catch (err) {
+        if (err instanceof dntShim.Deno.errors.NotFound) {
+            return;
+        }
+        throw err;
+    }
+    if (options.isFolder && !destStat.isDirectory) {
+        throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+    }
+    if (!options.overwrite) {
+        throw new dntShim.Deno.errors.AlreadyExists(`'${dest}' already exists.`);
+    }
+    return destStat;
+}
+/* copy file to dest */
+async function copyFile(src, dest, options) {
+    await ensureValidCopy(src, dest, options);
+    await dntShim.Deno.copyFile(src, dest);
+    if (options.preserveTimestamps) {
+        const statInfo = await dntShim.Deno.stat(src);
+        assert(statInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(statInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        await dntShim.Deno.utime(dest, statInfo.atime, statInfo.mtime);
+    }
+}
+/* copy file to dest synchronously */
+function copyFileSync(src, dest, options) {
+    ensureValidCopySync(src, dest, options);
+    dntShim.Deno.copyFileSync(src, dest);
+    if (options.preserveTimestamps) {
+        const statInfo = dntShim.Deno.statSync(src);
+        assert(statInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(statInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        dntShim.Deno.utimeSync(dest, statInfo.atime, statInfo.mtime);
+    }
+}
+/* copy symlink to dest */
+async function copySymLink(src, dest, options) {
+    await ensureValidCopy(src, dest, options);
+    const originSrcFilePath = await dntShim.Deno.readLink(src);
+    const type = getFileInfoType(await dntShim.Deno.lstat(src));
+    if (isWindows) {
+        await dntShim.Deno.symlink(originSrcFilePath, dest, {
+            type: type === "dir" ? "dir" : "file",
+        });
+    }
+    else {
+        await dntShim.Deno.symlink(originSrcFilePath, dest);
+    }
+    if (options.preserveTimestamps) {
+        const statInfo = await dntShim.Deno.lstat(src);
+        assert(statInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(statInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        await dntShim.Deno.utime(dest, statInfo.atime, statInfo.mtime);
+    }
+}
+/* copy symlink to dest synchronously */
+function copySymlinkSync(src, dest, options) {
+    ensureValidCopySync(src, dest, options);
+    const originSrcFilePath = dntShim.Deno.readLinkSync(src);
+    const type = getFileInfoType(dntShim.Deno.lstatSync(src));
+    if (isWindows) {
+        dntShim.Deno.symlinkSync(originSrcFilePath, dest, {
+            type: type === "dir" ? "dir" : "file",
+        });
+    }
+    else {
+        dntShim.Deno.symlinkSync(originSrcFilePath, dest);
+    }
+    if (options.preserveTimestamps) {
+        const statInfo = dntShim.Deno.lstatSync(src);
+        assert(statInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(statInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        dntShim.Deno.utimeSync(dest, statInfo.atime, statInfo.mtime);
+    }
+}
+/* copy folder from src to dest. */
+async function copyDir(src, dest, options) {
+    const destStat = await ensureValidCopy(src, dest, {
+        ...options,
+        isFolder: true,
+    });
+    if (!destStat) {
+        await ensureDir(dest);
+    }
+    if (options.preserveTimestamps) {
+        const srcStatInfo = await dntShim.Deno.stat(src);
+        assert(srcStatInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(srcStatInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        await dntShim.Deno.utime(dest, srcStatInfo.atime, srcStatInfo.mtime);
+    }
+    src = toPathString(src);
+    dest = toPathString(dest);
+    for await (const entry of dntShim.Deno.readDir(src)) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, path.basename(srcPath));
+        if (entry.isSymlink) {
+            await copySymLink(srcPath, destPath, options);
+        }
+        else if (entry.isDirectory) {
+            await copyDir(srcPath, destPath, options);
+        }
+        else if (entry.isFile) {
+            await copyFile(srcPath, destPath, options);
+        }
+    }
+}
+/* copy folder from src to dest synchronously */
+function copyDirSync(src, dest, options) {
+    const destStat = ensureValidCopySync(src, dest, {
+        ...options,
+        isFolder: true,
+    });
+    if (!destStat) {
+        ensureDirSync(dest);
+    }
+    if (options.preserveTimestamps) {
+        const srcStatInfo = dntShim.Deno.statSync(src);
+        assert(srcStatInfo.atime instanceof Date, `statInfo.atime is unavailable`);
+        assert(srcStatInfo.mtime instanceof Date, `statInfo.mtime is unavailable`);
+        dntShim.Deno.utimeSync(dest, srcStatInfo.atime, srcStatInfo.mtime);
+    }
+    src = toPathString(src);
+    dest = toPathString(dest);
+    for (const entry of dntShim.Deno.readDirSync(src)) {
+        assert(entry.name != null, "file.name must be set");
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, path.basename(srcPath));
+        if (entry.isSymlink) {
+            copySymlinkSync(srcPath, destPath, options);
+        }
+        else if (entry.isDirectory) {
+            copyDirSync(srcPath, destPath, options);
+        }
+        else if (entry.isFile) {
+            copyFileSync(srcPath, destPath, options);
+        }
+    }
+}
+/**
+ * Copy a file or directory. The directory can have contents. Like `cp -r`.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { copy } from "https://deno.land/std@$STD_VERSION/fs/copy.ts";
+ * copy("./foo", "./bar"); // returns a promise
+ * ```
+ *
+ * @param src the file/directory path.
+ *            Note that if `src` is a directory it will copy everything inside
+ *            of this directory, not the entire directory itself
+ * @param dest the destination path. Note that if `src` is a file, `dest` cannot
+ *             be a directory
+ * @param options
+ */
+export async function copy(src, dest, options = {}) {
+    src = path.resolve(toPathString(src));
+    dest = path.resolve(toPathString(dest));
+    if (src === dest) {
+        throw new Error("Source and destination cannot be the same.");
+    }
+    const srcStat = await dntShim.Deno.lstat(src);
+    if (srcStat.isDirectory && isSubdir(src, dest)) {
+        throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`);
+    }
+    if (srcStat.isSymlink) {
+        await copySymLink(src, dest, options);
+    }
+    else if (srcStat.isDirectory) {
+        await copyDir(src, dest, options);
+    }
+    else if (srcStat.isFile) {
+        await copyFile(src, dest, options);
+    }
+}
+/**
+ * Copy a file or directory. The directory can have contents. Like `cp -r`.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { copySync } from "https://deno.land/std@$STD_VERSION/fs/copy.ts";
+ * copySync("./foo", "./bar"); // void
+ * ```
+ * @param src the file/directory path.
+ *            Note that if `src` is a directory it will copy everything inside
+ *            of this directory, not the entire directory itself
+ * @param dest the destination path. Note that if `src` is a file, `dest` cannot
+ *             be a directory
+ * @param options
+ */
+export function copySync(src, dest, options = {}) {
+    src = path.resolve(toPathString(src));
+    dest = path.resolve(toPathString(dest));
+    if (src === dest) {
+        throw new Error("Source and destination cannot be the same.");
+    }
+    const srcStat = dntShim.Deno.lstatSync(src);
+    if (srcStat.isDirectory && isSubdir(src, dest)) {
+        throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`);
+    }
+    if (srcStat.isSymlink) {
+        copySymlinkSync(src, dest, options);
+    }
+    else if (srcStat.isDirectory) {
+        copyDirSync(src, dest, options);
+    }
+    else if (srcStat.isFile) {
+        copyFileSync(src, dest, options);
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/empty_dir.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/**
+ * Ensures that a directory is empty.
+ * Deletes directory contents if the directory is not empty.
+ * If the directory does not exist, it is created.
+ * The directory itself is not deleted.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { emptyDir } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * emptyDir("./foo"); // returns a promise
+ * ```
+ */
+export declare function emptyDir(dir: string | URL): Promise<void>;
+/**
+ * Ensures that a directory is empty.
+ * Deletes directory contents if the directory is not empty.
+ * If the directory does not exist, it is created.
+ * The directory itself is not deleted.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { emptyDirSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * emptyDirSync("./foo"); // void
+ * ```
+ */
+export declare function emptyDirSync(dir: string | URL): void;

package/esm/deps/deno.land/std@0.195.0/fs/empty_dir.js

@@ -0,0 +1,74 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import { join } from "../path/mod.js";
+import { toPathString } from "./_util.js";
+/**
+ * Ensures that a directory is empty.
+ * Deletes directory contents if the directory is not empty.
+ * If the directory does not exist, it is created.
+ * The directory itself is not deleted.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { emptyDir } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * emptyDir("./foo"); // returns a promise
+ * ```
+ */
+export async function emptyDir(dir) {
+    try {
+        const items = [];
+        for await (const dirEntry of dntShim.Deno.readDir(dir)) {
+            items.push(dirEntry);
+        }
+        while (items.length) {
+            const item = items.shift();
+            if (item && item.name) {
+                const filepath = join(toPathString(dir), item.name);
+                await dntShim.Deno.remove(filepath, { recursive: true });
+            }
+        }
+    }
+    catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.NotFound)) {
+            throw err;
+        }
+        // if not exist. then create it
+        await dntShim.Deno.mkdir(dir, { recursive: true });
+    }
+}
+/**
+ * Ensures that a directory is empty.
+ * Deletes directory contents if the directory is not empty.
+ * If the directory does not exist, it is created.
+ * The directory itself is not deleted.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { emptyDirSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * emptyDirSync("./foo"); // void
+ * ```
+ */
+export function emptyDirSync(dir) {
+    try {
+        const items = [...dntShim.Deno.readDirSync(dir)];
+        // If the directory exists, remove all entries inside it.
+        while (items.length) {
+            const item = items.shift();
+            if (item && item.name) {
+                const filepath = join(toPathString(dir), item.name);
+                dntShim.Deno.removeSync(filepath, { recursive: true });
+            }
+        }
+    }
+    catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.NotFound)) {
+            throw err;
+        }
+        // if not exist. then create it
+        dntShim.Deno.mkdirSync(dir, { recursive: true });
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/ensure_dir.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/**
+ * Ensures that the directory exists.
+ * If the directory structure does not exist, it is created. Like mkdir -p.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureDir } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureDir("./bar"); // returns a promise
+ * ```
+ */
+export declare function ensureDir(dir: string | URL): Promise<void>;
+/**
+ * Ensures that the directory exists.
+ * If the directory structure does not exist, it is created. Like mkdir -p.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureDirSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureDirSync("./ensureDirSync"); // void
+ * ```
+ */
+export declare function ensureDirSync(dir: string | URL): void;

package/esm/deps/deno.land/std@0.195.0/fs/ensure_dir.js

@@ -0,0 +1,55 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import { getFileInfoType } from "./_util.js";
+/**
+ * Ensures that the directory exists.
+ * If the directory structure does not exist, it is created. Like mkdir -p.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureDir } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureDir("./bar"); // returns a promise
+ * ```
+ */
+export async function ensureDir(dir) {
+    try {
+        await dntShim.Deno.mkdir(dir, { recursive: true });
+    }
+    catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.AlreadyExists)) {
+            throw err;
+        }
+        const fileInfo = await dntShim.Deno.lstat(dir);
+        if (!fileInfo.isDirectory) {
+            throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+        }
+    }
+}
+/**
+ * Ensures that the directory exists.
+ * If the directory structure does not exist, it is created. Like mkdir -p.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureDirSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureDirSync("./ensureDirSync"); // void
+ * ```
+ */
+export function ensureDirSync(dir) {
+    try {
+        dntShim.Deno.mkdirSync(dir, { recursive: true });
+    }
+    catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.AlreadyExists)) {
+            throw err;
+        }
+        const fileInfo = dntShim.Deno.lstatSync(dir);
+        if (!fileInfo.isDirectory) {
+            throw new Error(`Ensure path exists, expected 'dir', got '${getFileInfoType(fileInfo)}'`);
+        }
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/ensure_file.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/**
+ * Ensures that the file exists.
+ * If the file that is requested to be created is in directories that do not
+ * exist.
+ * these directories are created. If the file already exists,
+ * it is NOTMODIFIED.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureFile } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureFile("./folder/targetFile.dat"); // returns promise
+ * ```
+ */
+export declare function ensureFile(filePath: string | URL): Promise<void>;
+/**
+ * Ensures that the file exists.
+ * If the file that is requested to be created is in directories that do not
+ * exist,
+ * these directories are created. If the file already exists,
+ * it is NOT MODIFIED.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureFileSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureFileSync("./folder/targetFile.dat"); // void
+ * ```
+ */
+export declare function ensureFileSync(filePath: string | URL): void;

package/esm/deps/deno.land/std@0.195.0/fs/ensure_file.js

@@ -0,0 +1,75 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import * as path from "../path/mod.js";
+import { ensureDir, ensureDirSync } from "./ensure_dir.js";
+import { getFileInfoType, toPathString } from "./_util.js";
+/**
+ * Ensures that the file exists.
+ * If the file that is requested to be created is in directories that do not
+ * exist.
+ * these directories are created. If the file already exists,
+ * it is NOTMODIFIED.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureFile } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureFile("./folder/targetFile.dat"); // returns promise
+ * ```
+ */
+export async function ensureFile(filePath) {
+    try {
+        // if file exists
+        const stat = await dntShim.Deno.lstat(filePath);
+        if (!stat.isFile) {
+            throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType(stat)}'`);
+        }
+    }
+    catch (err) {
+        // if file not exists
+        if (err instanceof dntShim.Deno.errors.NotFound) {
+            // ensure dir exists
+            await ensureDir(path.dirname(toPathString(filePath)));
+            // create file
+            await dntShim.Deno.writeFile(filePath, new Uint8Array());
+            return;
+        }
+        throw err;
+    }
+}
+/**
+ * Ensures that the file exists.
+ * If the file that is requested to be created is in directories that do not
+ * exist,
+ * these directories are created. If the file already exists,
+ * it is NOT MODIFIED.
+ * Requires the `--allow-read` and `--allow-write` flag.
+ *
+ * @example
+ * ```ts
+ * import { ensureFileSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureFileSync("./folder/targetFile.dat"); // void
+ * ```
+ */
+export function ensureFileSync(filePath) {
+    try {
+        // if file exists
+        const stat = dntShim.Deno.lstatSync(filePath);
+        if (!stat.isFile) {
+            throw new Error(`Ensure path exists, expected 'file', got '${getFileInfoType(stat)}'`);
+        }
+    }
+    catch (err) {
+        // if file not exists
+        if (err instanceof dntShim.Deno.errors.NotFound) {
+            // ensure dir exists
+            ensureDirSync(path.dirname(toPathString(filePath)));
+            // create file
+            dntShim.Deno.writeFileSync(filePath, new Uint8Array());
+            return;
+        }
+        throw err;
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/ensure_link.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/**
+ * Ensures that the hard link exists.
+ * If the directory structure does not exist, it is created.
+ *
+ * @example
+ * ```ts
+ * import { ensureSymlink } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureSymlink("./folder/targetFile.dat", "./folder/targetFile.link.dat"); // returns promise
+ * ```
+ *
+ * @param src the source file path. Directory hard links are not allowed.
+ * @param dest the destination link path
+ */
+export declare function ensureLink(src: string | URL, dest: string | URL): Promise<void>;
+/**
+ * Ensures that the hard link exists.
+ * If the directory structure does not exist, it is created.
+ *
+ * @example
+ * ```ts
+ * import { ensureSymlinkSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureSymlinkSync("./folder/targetFile.dat", "./folder/targetFile.link.dat"); // void
+ * ```
+ *
+ * @param src the source file path. Directory hard links are not allowed.
+ * @param dest the destination link path
+ */
+export declare function ensureLinkSync(src: string | URL, dest: string | URL): void;

package/esm/deps/deno.land/std@0.195.0/fs/ensure_link.js

@@ -0,0 +1,43 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import * as path from "../path/mod.js";
+import { ensureDir, ensureDirSync } from "./ensure_dir.js";
+import { toPathString } from "./_util.js";
+/**
+ * Ensures that the hard link exists.
+ * If the directory structure does not exist, it is created.
+ *
+ * @example
+ * ```ts
+ * import { ensureSymlink } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureSymlink("./folder/targetFile.dat", "./folder/targetFile.link.dat"); // returns promise
+ * ```
+ *
+ * @param src the source file path. Directory hard links are not allowed.
+ * @param dest the destination link path
+ */
+export async function ensureLink(src, dest) {
+    dest = toPathString(dest);
+    await ensureDir(path.dirname(dest));
+    await dntShim.Deno.link(toPathString(src), dest);
+}
+/**
+ * Ensures that the hard link exists.
+ * If the directory structure does not exist, it is created.
+ *
+ * @example
+ * ```ts
+ * import { ensureSymlinkSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * ensureSymlinkSync("./folder/targetFile.dat", "./folder/targetFile.link.dat"); // void
+ * ```
+ *
+ * @param src the source file path. Directory hard links are not allowed.
+ * @param dest the destination link path
+ */
+export function ensureLinkSync(src, dest) {
+    dest = toPathString(dest);
+    ensureDirSync(path.dirname(dest));
+    dntShim.Deno.linkSync(toPathString(src), dest);
+}

package/esm/deps/deno.land/std@0.195.0/fs/ensure_symlink.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/**
+ * Ensures that the link exists, and points to a valid file.
+ * If the directory structure does not exist, it is created.
+ *
+ * @param target the source file path
+ * @param linkName the destination link path
+ */
+export declare function ensureSymlink(target: string | URL, linkName: string | URL): Promise<void>;
+/**
+ * Ensures that the link exists, and points to a valid file.
+ * If the directory structure does not exist, it is created.
+ *
+ * @param target the source file path
+ * @param linkName the destination link path
+ */
+export declare function ensureSymlinkSync(target: string | URL, linkName: string | URL): void;