@yaegassy/coc-ty 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 yaegassy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# coc-ty
+
+[ty](https://github.com/astral-sh/ty) language server extension for [coc.nvim](https://github.com/neoclide/coc.nvim).
+
+## Install
+
+**CocInstall**:
+
+> ...TODO
+
+**e.g. vim-plug**:
+
+```vim
+Plug 'yaegassy/coc-ty', {'do': 'yarn install --frozen-lockfile'}
+```
+
+## Configuration options
+
+- `ty.enable`: Enable coc-ty extension, default: `true`
+- `ty.disableHover`: Disable hover only, default: `false`
+- `ty.disableInlayHint`: Disable inlayHint only, default: `false`
+- `ty.disableTypeDefinition`: Disable typeDefinition only, default: `false`
+- `ty.useDetectTyCommand`: Automatically detects the ty command in the execution environment and sets `tf.path`, default: `true`
+- `ty.binaryPath`: Custom path for the `ty` binary. If no value is set, the `ty` command will be detected from the runtime environment, , default: `""`
+- `ty.trace.server`: Traces the communication between coc.nvim and the ty language server, default: `"off"`
+
+Other settings have the same configuration as [ty-vscode](https://github.com/astral-sh/ty-vscode).
+
+## Commands
+
+- `ty.showLogs`: Show logs
+- `ty.restart`: Restart Server
+
+## Thanks
+
+- [astral-sh/ty](https://github.com/astral-sh/ty)
+- [astral-sh/ty-vscode](https://github.com/astral-sh/ty-vscode)
+
+## License
+
+MIT
+
+---
+
+> This extension is built with [create-coc-extension](https://github.com/fannheyward/create-coc-extension)

package/lib/index.js

@@ -0,0 +1,383 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/isexe/windows.js"(exports, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs = require("fs");
+    function checkPathExt(path, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat, path, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path, options);
+    }
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), path, options);
+    }
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/isexe/mode.js"(exports, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs = require("fs");
+    function isexe(path, options, cb) {
+      fs.stat(path, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path, options) {
+      return checkStat(fs.statSync(path), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/isexe/index.js"(exports, module2) {
+    var fs = require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module2.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path, options) {
+      try {
+        return core.sync(path, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/which/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/which/lib/index.js"(exports, module2) {
+    var isexe = require_isexe();
+    var { join, delimiter, sep, posix } = require("path");
+    var isWindows = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join(pathPart, cmd);
+    };
+    var which3 = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which3;
+    which3.sync = whichSync;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  activate: () => activate
+});
+module.exports = __toCommonJS(src_exports);
+var import_coc5 = require("coc.nvim");
+
+// src/client.ts
+var import_coc = require("coc.nvim");
+
+// src/constant.ts
+var SERVER_SUBCOMMAND = "server";
+
+// src/client.ts
+var import_which = __toESM(require_lib());
+function createServerClient(command) {
+  const newEnv = { ...process.env };
+  const args = [SERVER_SUBCOMMAND];
+  const serverOptions = {
+    command,
+    args,
+    options: { env: newEnv }
+  };
+  const clientOptions = {
+    documentSelector: ["python"],
+    initializationOptions: getInitializationOptions(),
+    disabledFeatures: getLanguageClientDisabledFeatures()
+  };
+  const client2 = new import_coc.LanguageClient("ty", "ty server", serverOptions, clientOptions);
+  return client2;
+}
+function convertFromWorkspaceConfigToInitializationOptions() {
+  const settings = import_coc.workspace.getConfiguration("ty");
+  const initializationOptions = {
+    settings: {
+      path: settings.get("path"),
+      interpreter: settings.get("interpreter"),
+      importStrategy: settings.get(`importStrategy`) ?? "fromEnvironment",
+      logLevel: settings.get("logLevel"),
+      logFile: settings.get("logFile"),
+      experimental: settings.get("experimental")
+    }
+  };
+  return initializationOptions;
+}
+function getInitializationOptions() {
+  const initializationOptions = convertFromWorkspaceConfigToInitializationOptions();
+  if (import_coc.workspace.getConfiguration("ty").get("useDetectTyCommand", true)) {
+    const envTyCommandPath = import_which.default.sync("ty", { nothrow: true });
+    if (envTyCommandPath) {
+      initializationOptions.settings.path = [envTyCommandPath];
+    }
+  }
+  return initializationOptions;
+}
+function getLanguageClientDisabledFeatures() {
+  const r = [];
+  if (getConfigDisableHover())
+    r.push("hover");
+  if (getConfigDisableInlayHintHover())
+    r.push("inlayHint");
+  if (getConfigDisableTypeDefinitionHover())
+    r.push("typeDefinition");
+  return r;
+}
+function getConfigDisableHover() {
+  return import_coc.workspace.getConfiguration("ty").get("disableHover", false);
+}
+function getConfigDisableInlayHintHover() {
+  return import_coc.workspace.getConfiguration("ty").get("disableInlayHint", false);
+}
+function getConfigDisableTypeDefinitionHover() {
+  return import_coc.workspace.getConfiguration("ty").get("disableTypeDefinition", false);
+}
+
+// src/commands/restart.ts
+var import_coc2 = require("coc.nvim");
+function register(context, client2) {
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("ty.restart", async () => {
+      if (client2) {
+        if (client2.serviceState !== import_coc2.ServiceStat.Stopped) {
+          await client2.stop();
+        }
+      }
+      client2.start();
+    })
+  );
+}
+
+// src/commands/showLogs.ts
+var import_coc3 = require("coc.nvim");
+async function register2(context, client2) {
+  await client2.onReady();
+  context.subscriptions.push(
+    import_coc3.commands.registerCommand("ty.showLogs", () => {
+      if (client2.outputChannel) {
+        client2.outputChannel.show();
+      }
+    })
+  );
+}
+
+// src/tool.ts
+var import_coc4 = require("coc.nvim");
+var import_which2 = __toESM(require_lib());
+async function getTyBinaryPath() {
+  let tyBinaryPath = import_coc4.workspace.getConfiguration("ty").get("binaryPath", "");
+  if (!tyBinaryPath) {
+    tyBinaryPath = import_which2.default.sync("ty", { nothrow: true }) || "";
+  }
+  return tyBinaryPath;
+}
+
+// src/index.ts
+var client;
+async function activate(context) {
+  if (!import_coc5.workspace.getConfiguration("ty").get("enable"))
+    return;
+  const command = await getTyBinaryPath();
+  if (command) {
+    client = createServerClient(command);
+  } else {
+    import_coc5.window.showWarningMessage('coc-ty | "ty" binary does not exist.`');
+    return;
+  }
+  context.subscriptions.push(import_coc5.services.registLanguageClient(client));
+  register2(context, client);
+  register(context, client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate
+});

package/package.json

@@ -0,0 +1,192 @@
+{
+  "name": "@yaegassy/coc-ty",
+  "version": "0.1.0",
+  "description": "coc.nvim extension with support for the ty type checker and language server.",
+  "author": "yaegassy <yosstools@gmail.com>",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "keywords": [
+    "coc.nvim",
+    "python",
+    "python3",
+    "ty",
+    "type checker",
+    "coc-ty",
+    "vim",
+    "neovim"
+  ],
+  "engines": {
+    "coc": "^0.0.80"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yaegassy/coc-ty"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint src --ext ts",
+    "clean": "rimraf lib",
+    "watch": "node esbuild.js --watch",
+    "build": "node esbuild.js",
+    "prepare": "node esbuild.js"
+  },
+  "prettier": {
+    "singleQuote": true,
+    "printWidth": 120,
+    "semi": true
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "@types/semver": "^7.5.8",
+    "@types/which": "^2.0.1",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "coc.nvim": "^0.0.82",
+    "esbuild": "^0.16.17",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.1",
+    "typescript": "^5.3.3",
+    "which": "^3.0.0"
+  },
+  "activationEvents": [
+    "onLanguage:python"
+  ],
+  "contributes": {
+    "rootPatterns": [
+      {
+        "filetype": "python",
+        "patterns": [
+          "pyproject.toml",
+          "ty.toml",
+          "setup.py",
+          "setup.cfg",
+          "tox.ini",
+          "Pipfile",
+          "requirements.txt"
+        ]
+      }
+    ],
+    "configuration": {
+      "type": "object",
+      "title": "coc-ty configuration",
+      "properties": {
+        "ty.enable": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable coc-ty extension"
+        },
+        "ty.disableHover": {
+          "type": "boolean",
+          "default": false,
+          "description": "Disable hover only."
+        },
+        "ty.disableInlayHint": {
+          "type": "boolean",
+          "default": false,
+          "description": "Disable inlayHint only."
+        },
+        "ty.disableTypeDefinition": {
+          "type": "boolean",
+          "default": false,
+          "description": "Disable typeDefinition only."
+        },
+        "ty.useDetectTyCommand": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically detects the ty command in the execution environment and sets `ty.path`."
+        },
+        "ty.binaryPath": {
+          "type": "string",
+          "default": "",
+          "description": "Custom path for the `ty` binary when using the native server. If no value is set, the `ty` command will be detected from the runtime environment."
+        },
+        "ty.path": {
+          "default": [],
+          "markdownDescription": "Path to a custom `ty` executable, e.g., `[\"/path/to/ty\"]`.",
+          "scope": "resource",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "ty.experimental.completions.enable": {
+          "default": false,
+          "markdownDescription": "Whether to enable completions.",
+          "scope": "window",
+          "type": "boolean"
+        },
+        "ty.importStrategy": {
+          "default": "fromEnvironment",
+          "markdownDescription": "Strategy for loading the `ty` executable. `fromEnvironment` picks up ty from the environment, falling back to the bundled version if needed. `useBundled` uses the version bundled with the extension.",
+          "enum": [
+            "fromEnvironment",
+            "useBundled"
+          ],
+          "enumDescriptions": [
+            "Use `ty` from environment, fallback to bundled version only if `ty` not available in the environment.",
+            "Always use the bundled version of `ty`."
+          ],
+          "scope": "window",
+          "type": "string"
+        },
+        "ty.interpreter": {
+          "default": [],
+          "markdownDescription": "Path to a Python interpreter to use to find the `ty` executable.",
+          "scope": "resource",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
+        "ty.logLevel": {
+          "default": null,
+          "markdownDescription": "Controls the log level of the language server.",
+          "enum": [
+            "error",
+            "warning",
+            "info",
+            "debug",
+            "trace"
+          ],
+          "scope": "application",
+          "type": "string"
+        },
+        "ty.logFile": {
+          "default": null,
+          "markdownDescription": "Path to the log file for the language server.",
+          "type": "string"
+        },
+        "ty.trace.server": {
+          "type": "string",
+          "enum": [
+            "off",
+            "messages",
+            "verbose"
+          ],
+          "default": "off",
+          "description": "Traces the communication between coc.nvim and the ty server."
+        }
+      }
+    },
+    "commands": [
+      {
+        "command": "ty.showLogs",
+        "title": "Show logs"
+      },
+      {
+        "command": "ty.restart",
+        "title": "Restart Server"
+      }
+    ]
+  },
+  "dependencies": {
+    "semver": "^7.6.2",
+    "toml": "^3.0.0"
+  },
+  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+}