@elonehoo/vitepress-plugin-npm-commands/dist/index.js

A plugin that adds syntax for showing `npm`, `yarn`, `pnpm` commands in tabs.

// src/node/autoConverter.ts
var npmInstall = /* @__PURE__ */ new Set([
  "install",
  "add",
  "i",
  "in",
  "ins",
  "inst",
  "insta",
  "instal",
  "isnt",
  "isnta",
  "isntal",
  "isntall"
]);
var npmUpdate = /* @__PURE__ */ new Set(["update", "up", "upgrade", "udpate"]);
var npmUninstall = /* @__PURE__ */ new Set(["uninstall", "unlink", "remove", "rm", "r", "un"]);
var npmRebuild = /* @__PURE__ */ new Set(["rebuild", "rb"]);
var npmRun = /* @__PURE__ */ new Set(["run-script", "run", "rum", "urn"]);
var npmInit = /* @__PURE__ */ new Set(["init", "create", "innit"]);
var converterList = [
  {
    match: /npm (?:([-\w]+)(?: ([^# ][^#]*))?)/,
    replacer: (pkgm, original, subCommand, _arg) => {
      const arg = _arg;
      const argStr = arg !== void 0 ? ` ${arg}` : "";
      if (npmInstall.has(subCommand)) {
        if (arg === void 0)
          return `${pkgm} install`;
        return `${pkgm} add ${arg}`;
      }
      if (npmUpdate.has(subCommand))
        return pkgm === "yarn" ? `yarn up${argStr}` : `pnpm update${argStr}`;
      if (npmUninstall.has(subCommand) && arg !== void 0)
        return `${pkgm} remove ${arg}`;
      if (npmRebuild.has(subCommand))
        return `${pkgm} rebuild${argStr}`;
      if (npmRun.has(subCommand) && arg !== void 0)
        return `${pkgm} run ${arg}`;
      if (npmInit.has(subCommand) && arg !== void 0) {
        if (arg === void 0)
          return original;
        return `${pkgm} create ${arg}`;
      }
      return `${pkgm} ${subCommand}${argStr}`;
    }
  }
];
var autoConverter = (command, pkgManager) => {
  if (pkgManager === "npm")
    return command;
  let newCommand = command;
  for (const converter of converterList) {
    newCommand = newCommand.replace(
      converter.match,
      (...args) => converter.replacer(pkgManager, ...args)
    );
  }
  return newCommand;
};

// src/node/packageManager.ts
var packageManagers = ["npm", "yarn", "pnpm"];

// src/node/markdownPlugin.ts
var tabsShareStateKey = "~npm-commands";
var npmCommandsCommandRE = new RegExp(
  `(?://\\s*\\[!=npm\\s+(${packageManagers.join("|")}|auto)\\])+$`,
  "m"
);
var npmCommandsPlugin = (md) => {
  const tabLabelsProp = `:tabLabels="${md.utils.escapeHtml(
    JSON.stringify(packageManagers)
  )}"`;
  const shareStateKeyProp = `sharedStateKey="${md.utils.escapeHtml(
    tabsShareStateKey
  )}"`;
  const originalFence = md.renderer.rules.fence;
  md.renderer.rules.fence = (...args) => {
    var _a;
    const [tokens, idx, , env] = args;
    const token = tokens[idx];
    if (token.attrGet("----npm-disable") !== null) {
      const pos = token.attrIndex("----npm-disable");
      (_a = token.attrs) == null ? void 0 : _a.splice(pos, 1);
      return originalFence(...args);
    }
    if (!npmCommandsCommandRE.test(token.content))
      return originalFence(...args);
    const codes = generateEachPackageManagerCode(token.content);
    const slots = codes.map(([pkgManger, code]) => {
      const attrStr = token.attrs ? `{${token.attrs.map(([key, val]) => val ? `${key}=${val}` : key).join(" ")}}` : "";
      const codeWithFence = `${token.markup}${token.info}${attrStr}
${code}${token.markup}`;
      return `<template #${pkgManger}>${md.render(
        codeWithFence,
        env
      )}</template>`;
    });
    return `<PluginTabs ${tabLabelsProp} ${shareStateKeyProp}>${slots.join(
      ""
    )}</PluginTabs>`;
  };
};
var parseNpmCommandsCommandFromLine = (line) => {
  const m = line.match(npmCommandsCommandRE);
  if (!m)
    return null;
  return m[1];
};
var generateEachPackageManagerCode = (input) => {
  const codes = Object.fromEntries(
    packageManagers.map((m) => [m, []])
  );
  for (const line of input.split("\n")) {
    const pkgManager = parseNpmCommandsCommandFromLine(line);
    if (!pkgManager) {
      for (const key of packageManagers)
        codes[key].push(line);
    } else if (pkgManager === "auto") {
      for (const key of packageManagers) {
        const convertedCommand = autoConverter(
          line.replace(npmCommandsCommandRE, "").trimEnd(),
          key
        );
        codes[key].push(convertedCommand);
      }
    } else {
      codes[pkgManager].push(line.replace(npmCommandsCommandRE, ""));
    }
  }
  return Object.entries(codes).map(
    ([key, val]) => [key, val.join("\n")]
  );
};
export {
  npmCommandsPlugin as npmCommandsMarkdownPlugin
};