# @yll10243/symlink

> 通过模板文件或文件夹生成软链接

Latest version **1.0.5** (published 2023-04-08) · MIT license · 0 weekly downloads

## Install

```sh
npm install @yll10243/symlink
pnpm add @yll10243/symlink
yarn add @yll10243/symlink
bun add @yll10243/symlink
```

Provides the command `symlink`.

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.5 |
| Published | 2023-04-08 |
| First published | 2023-04-07 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 8.6 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | yll1024335892 |
| Maintainers | yll10243 |

## Links

- npm: https://www.npmjs.com/package/@yll10243/symlink
- Repository: https://gitee.com/yll10243/symlink
- Homepage: https://gitee.com/yll10243/symlink#readme
- npm.io page: https://npm.io/package/@yll10243/symlink

## Dependencies (2)

- [cmd-shim](https://npm.io/package/cmd-shim.md) ^6.0.1
- [fs-extra](https://npm.io/package/fs-extra.md) ^11.1.1

## Recent versions

- 1.0.5 (latest) — 2023-04-08
- 1.0.4 — 2023-04-07

## README

# 具体使用

```
import _cmdShim from "cmd-shim";
import _fs from "fs-extra";
import path from "path";
import { createSymlink } from "./create-symlink";

jest.mock("cmd-shim");
jest.mock("fs-extra");

const cmdShim = jest.mocked(_cmdShim);
const fs = jest.mocked(_fs);

const linkRelative = (from: string, to: string) => path.relative(path.dirname(to), from);

describe("create-symlink", () => {
  fs.lstat.mockImplementation(() => Promise.reject(new Error("MOCK")));
  fs.unlink.mockResolvedValue();
  fs.symlink.mockResolvedValue();
  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
  // @ts-ignore
  fs.pathExists.mockResolvedValue(true);
  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
  // @ts-ignore
  fs.outputFile.mockResolvedValue();
  fs.remove.mockResolvedValue();
  cmdShim.mockResolvedValue();

  if (process.platform !== "win32") {
    it("creates relative symlink to a directory", async () => {
      const src = path.resolve("./packages/package-2");
      const dst = path.resolve("./packages/package-1/node_modules/package-2");
      const type = "junction"; // even in posix environments :P

      await createSymlink(src, dst, type);

      expect(fs.unlink).not.toHaveBeenCalled();
      expect(fs.symlink).toHaveBeenLastCalledWith(linkRelative(src, dst), dst, type);
    });

    it("creates relative symlink to an executable file", async () => {
      const src = path.resolve("./packages/package-2/cli.js");
      const dst = path.resolve("./packages/package-1/node_modules/.bin/package-2");
      const type = "exec";

      await createSymlink(src, dst, type);

      expect(fs.unlink).not.toHaveBeenCalled();
      expect(fs.symlink).toHaveBeenLastCalledWith(linkRelative(src, dst), dst, "file");
    });

    it("overwrites an existing symlink", async () => {
      const src = path.resolve("./packages/package-2");
      const dst = path.resolve("./packages/package-1/node_modules/package-2");
      const type = "junction"; // even in posix environments :P

      fs.lstat.mockImplementationOnce(() => Promise.resolve() as any); // something _does_ exist at destination

      await createSymlink(src, dst, type);

      expect(fs.unlink).toHaveBeenLastCalledWith(dst);
      expect(fs.symlink).toHaveBeenLastCalledWith(linkRelative(src, dst), dst, type);
    });
  } else {
    it("creates command shim to an executable file", async () => {
      const src = path.resolve("./packages/package-2/cli.js");
      const dst = path.resolve("./packages/package-1/node_modules/.bin/package-2");
      const type = "exec";

      await createSymlink(src, dst, type);

      expect(fs.lstat).not.toHaveBeenCalled();
      expect(cmdShim).toHaveBeenLastCalledWith(src, dst);
    });

    it("rejects when cmd-shim errors", async () => {
      cmdShim.mockImplementationOnce(() => Promise.reject(new Error("yikes")));

      await expect(createSymlink("src", "dst", "exec")).rejects.toThrow("yikes");
    });

    it("always uses absolute paths when creating symlinks", async () => {
      const src = path.resolve("./packages/package-2");
      const dst = path.resolve("./packages/package-1/node_modules/package-2");
      const type = "junction"; // only _actually_ matters in windows

      fs.lstat.mockImplementationOnce(() => Promise.resolve() as any); // something _does_ exist at destination

      await createSymlink(src, dst, type);

      expect(fs.unlink).toHaveBeenLastCalledWith(dst);
      expect(fs.symlink).toHaveBeenLastCalledWith(src, dst, type);
    });

    it("creates stub symlink to executable that doesn't exist yet", async () => {
      const src = path.resolve("./packages/package-3/cli.js");
      const dst = path.resolve("./packages/package-1/node_modules/.bin/package-3");
      const type = "exec";

      fs.pathExists.mockReturnValueOnce(Promise.resolve(false) as any);

      await createSymlink(src, dst, type);

      expect(fs.outputFile).toHaveBeenLastCalledWith(src, "");
      expect(cmdShim).toHaveBeenLastCalledWith(src, dst);
      expect(fs.remove).toHaveBeenLastCalledWith(src);
    });

    it("does not swallow cmd-shim errors when executable doesn't exist yet", async () => {
      cmdShim.mockImplementationOnce(() => Promise.reject(new Error("oh no")));
      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
      // @ts-ignore
      fs.pathExists.mockResolvedValueOnce(false);

      await expect(createSymlink("src", "dst", "exec")).rejects.toThrow("oh no");
      expect(fs.remove).toHaveBeenLastCalledWith("src");
    });
  }
});

```

## 参考来源

- lerna-main\libs\core\src\lib\create-symlink.ts

## 通过脚本运行

- package.json文件中

```
"scripts": {
  "link": "symlink link ./package.json ./xx.josn file",
  "unlink": "symlink unlink ./xx.josn"
}
```

---
_Source: https://npm.io/package/@yll10243/symlink · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._