js-dev-tool 1.2.1 → 1.2.2

package/basic-types.d.ts

@@ -85,10 +85,10 @@ type Constructor<T> = new (...args: any[]) => T;
  *   - If it is **1**, the types are displayed concatenated.
  *   - If it is **0**, the types are displayed separated by "&".
  */
-type RequireThese<T, K extends keyof T, Merge extends 1 | 0 = 0> =
-  Merge extends 1 ? Prettify<
-  T & Required<Pick<T, K>>
-> : T & Required<Pick<T, K>>;
+type RequireThese<
+  T, K extends keyof T, Merge extends 1 | 0 = 0,
+  Intersected = T & Required<Pick<T, K>>
+> = Merge extends 1 ? Prettify<Intersected> : Intersected;
 /**
  * pick any `property` as excludes
  */

package/extras/list-deps-of.js

@@ -0,0 +1,212 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2026 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file list-deps-of.js
+ * @command node list-deps-of.mjs typescript-jsdoctag-completions-plugin
+ *
+ * CAVEAT: yarn v1.x lock file 専用
+ */
+const fs = require("fs");
+const path = require("path");
+/** @param {string} raw */
+function parseSelectors(raw) {
+  if (raw.includes("\"")) {
+    const selectors = [];
+    const regex = /"([^"]+)"/g;
+    let match = regex.exec(raw);
+    while (match) {
+      selectors.push(match[1]);
+      match = regex.exec(raw);
+    }
+    if (selectors.length > 0) {
+      return selectors;
+    }
+  }
+  return raw.split(/\s?,\s?/)
+}
+/** @param {string} selector */
+function selectorToName(selector) {
+  const npmIndex = selector.indexOf("@npm:");
+  if (npmIndex !== -1) {
+    return selector.slice(0, npmIndex);
+  }
+  const lastAt = selector.lastIndexOf("@");
+  if (lastAt > 0) {
+    return selector.slice(0, lastAt);
+  }
+  return selector;
+}
+/**
+ * ```
+ * /^[^\s].+:/;
+ * ```
+ */
+const re_ModuleStart = /^[^\s].+:/;
+/**
+ * ```
+ * /^\x20{2}(?:(?:optionalD|d)ependencies):$/;
+ * ```
+ */
+const re_DepsStart = /^\x20{2}(?:(?:optionalD|d)ependencies):$/;
+/**
+ * ```
+ * /\x20{4}/;
+ * ```
+ */
+const re_DepsEntryIndent = /^\x20{4}[^\s]/;
+/**
+ * @typedef {{
+ *  name?: string;
+ *  selectors: string[];
+ *  deps: { name: string; range: string; }[]
+ * }} TDependenciesEntry
+ */
+/** @param {string} yarnLockSource */
+function parseLockfile(yarnLockSource) {
+  /** @type {TDependenciesEntry[]} */
+  const entries = [];
+  const lines = yarnLockSource.split(/\r?\n/);
+  /** @type {TDependenciesEntry | null} */
+  let current = null;
+  let inDepsSection = false;
+  const modEntryChecker = re_ModuleStart;
+  const depsStartChecker = re_DepsStart;
+  const depsEntryChecker = re_DepsEntryIndent;
+  const reDepsExtractor = /(?:"([^"]+)"|([^"\s]+))\s+"([^"]+)"\s*$/;
+  const commitCurrent = () => {
+    if (current) {
+      entries.push(current);
+    }
+  };
+  for (const line of lines) {
+    if (line.length === 0) {
+      inDepsSection = false;
+      continue;
+    }
+    if (line.startsWith("#")) {
+      continue;
+    }
+    if (modEntryChecker.test(line)) {
+      commitCurrent();
+      const rawKeys = line.slice(0, -1);
+      const selectors = parseSelectors(rawKeys);
+      current = { selectors, deps: [] };
+      inDepsSection = false;
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (depsStartChecker.test(line)) {
+      inDepsSection = true;
+      continue;
+    }
+    if (inDepsSection && depsEntryChecker.test(line)) {
+      const trimmed = line.trim();
+      const match = reDepsExtractor.exec(trimmed);
+      if (match) {
+        const name = match[1] || match[2];
+        const range = match[3];
+        current.deps.push({ name, range });
+      }
+    }
+  }
+  commitCurrent();
+  /** @type {Map<string, TDependenciesEntry>} */
+  const selectorToEntry = new Map();
+  /** @type {Map<string, TDependenciesEntry[]>} */
+  const nameToEntries = new Map();
+  for (const entry of entries) {
+    if (entry.selectors.length === 0) {
+      continue;
+    }
+    const name = selectorToName(entry.selectors[0]);
+    entry.name = name;
+    for (const selector of entry.selectors) {
+      selectorToEntry.set(selector, entry);
+    }
+    if (!nameToEntries.has(name)) {
+      nameToEntries.set(name, []);
+    }
+    // @ts-expect-error
+    nameToEntries.get(name).push(entry);
+  }
+  return { entries, selectorToEntry, nameToEntries };
+}
+/**
+ * @param {string} depName 
+ * @param {string} depRange 
+ * @param {Map<string, TDependenciesEntry>} selectorToEntry 
+ * @param {Map<string, TDependenciesEntry[]>} nameToEntries 
+ */
+function resolveEntries(depName, depRange, selectorToEntry, nameToEntries) {
+  const exactSelector = depName + "@" + depRange;
+  const exactEntry = selectorToEntry.get(exactSelector);
+  if (exactEntry) {
+    return [exactEntry];
+  }
+  const entries = nameToEntries.get(depName);
+  if (entries) {
+    return entries;
+  }
+  return [];
+}
+/**
+ * @param {TDependenciesEntry[]} startEntries 
+ * @param {Map<string, TDependenciesEntry>} selectorToEntry 
+ * @param {Map<string, TDependenciesEntry[]>} nameToEntries 
+ */
+function collectDependencies(startEntries, selectorToEntry, nameToEntries) {
+  /** @type {Set<string>} */
+  const result = new Set();
+  /** @type {Set<TDependenciesEntry>} */
+  const visitedEntries = new Set();
+  const stack = [...startEntries];
+  while (stack.length > 0) {
+    const entry = stack.pop();
+    if (!entry || visitedEntries.has(entry)) {
+      continue;
+    }
+    visitedEntries.add(entry);
+    for (const dep of entry.deps) {
+      result.add(dep.name);
+      const resolvedEntries = resolveEntries(
+        dep.name,
+        dep.range,
+        selectorToEntry,
+        nameToEntries
+      );
+      for (const resolvedEntry of resolvedEntries) {
+        if (!visitedEntries.has(resolvedEntry)) {
+          stack.push(resolvedEntry);
+        }
+      }
+    }
+  }
+  return result;
+}
+const lockfilePath = "yarn.lock";
+/**
+ * @param {string} targetName
+ * @returns {string[]}
+ */
+function listDependenciesOf(targetName) {
+  const resolvedLockfilePath = path.resolve(process.cwd(), lockfilePath);
+  if (!fs.existsSync(resolvedLockfilePath)) {
+    console.error("Lockfile not found: " + resolvedLockfilePath);
+  }
+  const lockText = fs.readFileSync(resolvedLockfilePath, "utf8");
+  const { selectorToEntry, nameToEntries } = parseLockfile(lockText);
+  const startEntries = nameToEntries.get(targetName) || [];
+  if (startEntries.length === 0) {
+    console.error("Module not found in yarn.lock: " + targetName);
+  }
+  const deps = collectDependencies(startEntries, selectorToEntry, nameToEntries);
+  return Array.from(deps).sort();
+}
+module.exports = { listDependenciesOf };

package/extras/list-deps-of.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+list-deps-of() {
+  local module_name="${1:-}"
+  if [ -z "${module_name}" ]; then
+    echo "Usage: list-deps-of <module-name> [--lockfile <path>]" >&2
+    return 1
+  fi
+
+  local script_dir
+  script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  node "${script_dir}/list-deps-of.js" "$@"
+}
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+  list-deps-of "$@"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-dev-tool",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "bin": {
     "jstool": "tools.js"
   },

package/utils.d.ts

@@ -159,4 +159,5 @@ export const CI: boolean;
 /**
  * Nothing is logged in a CI environment.
  */
-export const log: typeof console.log;
+export const log: typeof console.log;
+export const listDependenciesOf: typeof import("./extras/list-deps-of").listDependenciesOf;

package/utils.js

@@ -24,6 +24,7 @@ const fs = require("fs");
 const path = require("path");
 const lib = require("./common");
 const tinArgs = require("tin-args");
+const { listDependenciesOf } = require("./extras/list-deps-of");
 const CI = !!process.env.CI;
 /**
  * Nothing is logged in a CI environment.
@@ -406,4 +407,5 @@ module.exports = {
   fireReplace,
   CI,
   log,
+  listDependenciesOf
 };