📝 Use JSR instead to support Denops v7

Author: lambdalisue

src/api-reference.md

@@ -1,10 +1,10 @@
 # API Reference
 
-There is a standard module [denops_std] to develop denops plugins. It provides
+There is a standard module [@denops/std] to develop denops plugins. It provides
 various functions to interact with Vim and Neovim and some shorthands to make it
 easier to write plugins.
 
 You can find API references about the module by checking the Deno doc page:
-`https://deno.land/x/denops_std/mod.ts`.
+`https://jsr.io/@denops/std`.
 
-[denops_std]: https://deno.land/x/denops_std/mod.ts
+[@denops/std]: https://jsr.io/@denops/std

src/getting-started/README.md

@@ -21,8 +21,8 @@ $HOME
 
 Next, write the following TypeScript code in `main.ts`:
 
-```typescript
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
+```typescript:denops/denops-getting-started/main.ts
+import type { Entrypoint } from "jsr:@denops/[email protected]";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {

src/getting-started/explanation.md

@@ -91,7 +91,7 @@ easily call.
 In the Getting Started, we wrote the following code in the `main.ts` file:
 
 ```typescript
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
@@ -107,14 +107,14 @@ Let's break down this code step by step.
 ### About Imports
 
 ```typescript
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
 ```
 
-The first line imports the `Entrypoint` type from the [denops_std] standard
+The first line imports the `Entrypoint` type from the [@denops/std] standard
 library. You can find detailed information about the library by checking the
-URL: `https://deno.land/x/[email protected].0` (remove `/mod.ts`). We fixed the
-version in the import URL, so it's recommended to check for details and update
-to the latest version URL.
+URL: `https://jsr.io/@denops/[email protected].0` (replace `jsr:` to `https://jsr.io/`).
+We fixed the version in the import URL, so it's recommended to check for details
+and update to the latest version URL.
 
 Note that we use `import type` syntax, which is part of TypeScript's
 [Type-Only Imports and Export](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html).
@@ -130,28 +130,11 @@ meaning. Using `import { Entrypoint }` for a type-only import is also valid.
 > [`denops/@denops-private/denops.ts`](https://github.com/vim-denops/denops.vim/blob/main/denops/%40denops-private/denops.ts),
 > but it is not publicly exposed for the reasons mentioned above.
 >
-> This type information is provided by [denops_core], and [denops_std] simply
-> re-exports the type information from [denops_core]. However, [denops_core] is
-> intended to be referenced only by [denops.vim] and [denops_std], so Denops
+> This type information is provided by [@denops/core], and [@denops/std] simply
+> re-exports the type information from [@denops/core]. However, [@denops/core]
+> is intended to be referenced only by [denops.vim] and [@denops/std], so Denops
 > plugin developers don't need to use it directly.
 
-> [!NOTE]
->
-> Prior to denops-std v6.5.0, the `Entrypoint` type was not defined thus
-> developers must define the `main` function as like
->
-> ```typescript
-> import type { Denops } from "https://deno.land/x/[email protected]/mod.ts";
->
-> export function main(denops: Denops): void {
->   denops.dispatcher = {
->     async hello() {
->       await denops.cmd(`echo "Hello, Denops!"`);
->     },
->   };
-> }
-> ```
-
 ### About Entry Point
 
 ```typescript
@@ -162,8 +145,8 @@ export const main: Entrypoint = (denops) => {
 
 The above code exports the `main` function. The `main` function is called by
 Denops, and it takes the
-[Denops instance](https://deno.land/x/denops_std/mod.ts?s=Denops) (`denops`) as
-an argument. Denops plugins use this `denops` to add user-defined APIs or call
+[Denops instance](https://jsr.io/@denops/core/doc/~/Denops) (`denops`) as an
+argument. Denops plugins use this `denops` to add user-defined APIs or call
 Vim's features.
 
 ### About User-Defined APIs
@@ -222,17 +205,17 @@ several methods:
 | `eval`     | Evaluate a Vim expression and returns the result. If `ctx` is provided, it is expanded as local variables. |
 | `dispatch` | Calls a user-defined API of another Denops plugin and returns the result.                                  |
 
-Although `denops` provides low-level interfaces, [denops_std] combines these
+Although `denops` provides low-level interfaces, [@denops/std] combines these
 low-level interfaces to offer higher-level interfaces. Therefore, it's
-recommended to use [denops_std] to call Vim's features in actual plugin
+recommended to use [@denops/std] to call Vim's features in actual plugin
 development.
 
 For example, use
-[`function` module](https://deno.land/x/[email protected].0/function/mod.ts) to
-call Vim's function instead of `denops.call` like:
+[`function` module](https://jsr.io/@denops/[email protected].0/doc/function/~) to call
+Vim's function instead of `denops.call` like:
 
 ```typescript
-import * as fn from "https://deno.land/x/[email protected].0/function/mod.ts";
+import * as fn from "jsr:@denops/[email protected].0/function";
 
 // Bad (result1 is `unknown`)
 const result1 = await denops.call("expand", "%");
@@ -251,8 +234,8 @@ plugin.
 
 - [Tutorial (Hello World)](../tutorial/helloworld/README.md)
 - [Tutorial (Maze)](../tutorial/maze/README.md)
-- [API reference](https://deno.land/x/denops_std/mod.ts)
+- [API reference](https://jsr.io/@denops/std)
 
 [denops.vim]: https://github.com/vim-denops/denops.vim
-[denops_std]: https://deno.land/x/denops_std
-[denops_core]: https://deno.land/x/denops_core
+[@denops/std]: https://jsr.io/@denops/std
+[@denops/core]: https://jsr.io/@denops/core

src/install.md

@@ -76,11 +76,11 @@ You can check the health of Denops by running the `:checkhealth` command
 ==============================================================================
 denops: health#denops#check
 
-- Supported Deno version: `1.38.5`
-- Detected Deno version: `1.39.4`
+- Supported Deno version: `1.45.0`
+- Detected Deno version: `1.45.4`
 - OK Deno version check: passed
-- Supported Neovim version: `0.9.4`
-- Detected Neovim version: `0.9.5`
+- Supported Neovim version: `0.10.0`
+- Detected Neovim version: `0.10.0`
 - OK Neovim version check: passed
 - Denops status: `running`
 - OK Denops status check: passed

src/tutorial.md

@@ -6,10 +6,10 @@ This article is a tutorial on developing Denops plugins.
 
 In this tutorial, we use the following software and version as of writing.
 
-- [denops.vim v6.0.7](https://github.com/vim-denops/denops.vim/releases/tag/v6.0.7)
-  (2024-05-15)
-- [denops_std v6.5.0](https://github.com/vim-denops/deno-denops-std/releases/tag/v6.5.0)
-  (2024-05-15)
+- [denops.vim v7.0.0](https://github.com/vim-denops/denops.vim/releases/tag/v7.0.0)
+  (2024-07-27)
+- [denops_std v7.0.0](https://github.com/vim-denops/deno-denops-std/releases/tag/v7.0.0)
+  (2024-07-27)
 
 [vim-jp]: https://vim-jp.org/
 [denops.vim]: https://github.com/vim-denops/denops.vim

src/tutorial/helloworld/adding-an-api.md

@@ -7,8 +7,8 @@ Open `denops/denops-helloworld/main.ts` and rewrite the content with the
 following code:
 
 ```typescript:denops/denops-helloworld/main.ts
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
-import { assert, is } from "https://deno.land/x/unknownutil@v3.18.1/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
+import { assert, is } from "jsr:@core/unknownutil@3.18.1";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
@@ -29,8 +29,8 @@ for details about User-Defined APIs.
 >
 > While Vim script does not facilitate types, Denops uses `unknown` types on the
 > interface between Vim and Denops. That's why we use
-> [unknownutil](https://deno.land/x/unknownutil) to ensure that the `name` is of
-> type `string` in the above code.
+> [unknownutil](https://jsr.io/@core/unknownutil) to ensure that the `name` is
+> of type `string` in the above code.
 
 Once you've updated the file, restart Vim, and execute the following command,
 you will see the message "Hello, Your name!".

src/tutorial/helloworld/calling-vim-features.md

@@ -5,8 +5,8 @@ the `denops` instance passed to the plugin's `main` function. You can rewrite
 `main.ts` as follows to register the `DenopsHello` as a Vim command:
 
 ```ts:denops/denops-helloworld/main.ts
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
-import { assert, is } from "https://deno.land/x/unknownutil@v3.18.1/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
+import { assert, is } from "jsr:@core/unknownutil@3.18.1";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
@@ -61,4 +61,4 @@ In the next step, follow the tutorial to learn how to develop a real Denops
 plugin.
 
 - [Tutorial (Maze)](../tutorial/maze/README.md)
-- [API reference](https://deno.land/x/denops_std/mod.ts)
+- [API reference](https://jsr.io/@denops/std)

src/tutorial/helloworld/creating-a-minimal-denops-plugin.md

@@ -32,7 +32,7 @@ denops-helloworld
 Here is the content of the `denops/denops-helloworld/main.ts` file:
 
 ```typescript:denops/denops-helloworld/main.ts
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
 
 export const main: Entrypoint = (denops) => {
   console.log("Hello, Denops from TypeScript!");
@@ -45,7 +45,7 @@ export const main: Entrypoint = (denops) => {
 > `console.error`, etc.) for debug output. The content will be echoed to Vim.
 > However, it is not recommended to use `console.log` in production code.
 > Instead, use `denops.cmd("echo '...'")` or the `echo` function in the `helper`
-> module of the `denops_std` library.
+> module of the `@denops/std` library.
 
 Once you've created the file, restart Vim, and "Hello, Denops from TypeScript!"
 will be displayed on Vim startup.

src/tutorial/maze/adjusting-maze-size-to-fit-the-window.md

@@ -8,9 +8,9 @@ Let's modify the plugin to ensure the generated maze fits the current window
 size.
 
 ```typescript:denops/denops-helloworld/main.ts
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
-import * as fn from "https://deno.land/x/[email protected].0/function/mod.ts";
-import { Maze } from "https://deno.land/x/maze_generator@v0.4.0/mod.js";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
+import * as fn from "jsr:@denops/[email protected].0/function";
+import { Maze } from "npm:@thewizardbear/maze_generator@0.4.0";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
@@ -31,10 +31,10 @@ export const main: Entrypoint = (denops) => {
 };
 ```
 
-In this code, we utilize the `function` module (aliased to `fn`) of `denops_std`
-(Denops Standard Library) to call `winwidth()`, `winheight()`, and `setline()`
-functions. Then, we create a maze that fits the current window size and write it
-to the buffer.
+In this code, we utilize the `function` module (aliased to `fn`) of
+`@denops/std` (Denops Standard Library) to call `winwidth()`, `winheight()`, and
+`setline()` functions. Then, we create a maze that fits the current window size
+and write it to the buffer.
 
 So why do we use the `function` module instead of `denops.call`? With
 `denops.call`, developers must know the function name, arguments, return type,
@@ -44,13 +44,13 @@ checking, etc. It is more convenient and safe to use the `function` module.
 
 > [!TIP]
 >
-> The `function` module of the `denops_std` library provides a set of functions
+> The `function` module of the `@denops/std` library provides a set of functions
 > that are available on both Vim and Neovim. If you'd like to use Vim or Neovim
 > only functions, use the `vim` or `nvim` module under the `function` module
 > instead.
 >
 > See the
-> [function module of denops_std API document](https://doc.deno.land/https/deno.land/x/denops_std/function/mod.ts)
+> [function module of @denops/std API document](https://jsr.io/@denops/[email protected]/doc/function/~)
 > for more details.
 
 Restart Vim, rerun the `:Maze` command, and then you can see:

src/tutorial/maze/creating-applicative-plugin.md

@@ -33,12 +33,12 @@ opener, generate a maze that fits the current window size, configure the buffer
 options to make it non-file readonly buffer, etc.
 
 ```ts:denops/denops-maze/main.ts
-import type { Entrypoint } from "https://deno.land/x/[email protected]/mod.ts";
-import { batch, collect } from "https://deno.land/x/[email protected].0/batch/mod.ts";
-import * as fn from "https://deno.land/x/[email protected].0/function/mod.ts";
-import * as op from "https://deno.land/x/[email protected].0/option/mod.ts";
-import { Maze } from "https://deno.land/x/maze_generator@v0.4.0/mod.js";
-import { assert, is } from "https://deno.land/x/unknownutil@v3.18.1/mod.ts";
+import type { Entrypoint } from "jsr:@denops/[email protected]";
+import { batch, collect } from "jsr:@denops/[email protected].0/batch";
+import * as fn from "jsr:@denops/[email protected].0/function";
+import * as op from "jsr:@denops/[email protected].0/option";
+import { Maze } from "npm:@thewizardbear/maze_generator@0.4.0";
+import { assert, is } from "jsr:@core/unknownutil@3.18.1";
 
 export const main: Entrypoint = (denops) => {
   denops.dispatcher = {
@@ -68,16 +68,15 @@ export const main: Entrypoint = (denops) => {
 };
 ```
 
-In above code, we utilize the following denops_std modules:
+In above code, we utilize the following `@denops/std` modules:
 
 - `batch` and `collect` functions in a `batch` module to execute multiple
   commands in a single RPC
 - `function` module to call Vim's functions
 - `option` module to get and set Vim's options
 
-See the
-[denops_std API document](https://doc.deno.land/https/deno.land/x/denops_std/mod.ts)
-for more details about each modules.
+See the [denops_std API document](https://jsr.io/@denops/std) for more details
+about each modules.
 
 That's it. Now you can see a smaller maze shown on the window with `:Maze`
 command.