@modern-js/utils 1.1.4-rc.0 → 1.1.6-rc.0

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # @modern-js/utils
 
-## 1.1.4-rc.0
+## 1.1.6-rc.0
+
+### Patch Changes
+
+- b7fb82ec: fix: get package manager function
+
+## 1.1.5
+
+### Patch Changes
+
+- ca7dcb32: change watch logic
+
+## 1.1.4
 
 ### Patch Changes
 

package/dist/js/modern/getPackageManager.js

@@ -1,10 +1,15 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs-extra';
-export function getPackageManager(cwd = process.cwd()) {
+import { canUsePnpm, canUseYarn } from "./nodeEnv";
+const MAX_TIMES = 5;
+export async function getPackageManager(cwd = process.cwd()) {
   let appDirectory = cwd;
+  let times = 0;
+
+  while (os.homedir() !== appDirectory && times < MAX_TIMES) {
+    times++;
 
-  while (os.homedir() !== appDirectory) {
     if (fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) {
       return 'pnpm';
     }
@@ -20,5 +25,13 @@ export function getPackageManager(cwd = process.cwd()) {
     appDirectory = path.join(appDirectory, '..');
   }
 
+  if (await canUsePnpm()) {
+    return 'pnpm';
+  }
+
+  if (await canUseYarn()) {
+    return 'yarn';
+  }
+
   return 'npm';
 }

package/dist/js/modern/index.js

@@ -28,4 +28,5 @@ export * from "./generateMetaTags";
 export * from "./prettyInstructions";
 export * from "./alias";
 export * from "./import";
-export * from "./watch";
+export * from "./watch";
+export * from "./nodeEnv";

package/dist/js/modern/nodeEnv.js

@@ -0,0 +1,31 @@
+import execa from 'execa';
+export async function canUseNpm() {
+  try {
+    await execa('npm', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+export async function canUseYarn() {
+  try {
+    await execa('yarn', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+export async function canUsePnpm() {
+  try {
+    await execa('pnpm', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

package/dist/js/modern/watch.js

@@ -8,7 +8,7 @@ export const WatchChangeType = {
 };
 export const watch = (watchDir, runTask, ignored = []) => {
   let ready = false;
-  const watcher = chokidar.watch(`${watchDir}/**/*.{js,jsx,ts,tsx}`, {
+  const watcher = chokidar.watch(watchDir, {
     ignored
   });
   watcher.on('ready', () => ready = true);

package/dist/js/node/getPackageManager.js

@@ -11,12 +11,19 @@ var _path = _interopRequireDefault(require("path"));
 
 var _fsExtra = _interopRequireDefault(require("fs-extra"));
 
+var _nodeEnv = require("./nodeEnv");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function getPackageManager(cwd = process.cwd()) {
+const MAX_TIMES = 5;
+
+async function getPackageManager(cwd = process.cwd()) {
   let appDirectory = cwd;
+  let times = 0;
+
+  while (_os.default.homedir() !== appDirectory && times < MAX_TIMES) {
+    times++;
 
-  while (_os.default.homedir() !== appDirectory) {
     if (_fsExtra.default.existsSync(_path.default.resolve(appDirectory, 'pnpm-lock.yaml'))) {
       return 'pnpm';
     }
@@ -32,5 +39,13 @@ function getPackageManager(cwd = process.cwd()) {
     appDirectory = _path.default.join(appDirectory, '..');
   }
 
+  if (await (0, _nodeEnv.canUsePnpm)()) {
+    return 'pnpm';
+  }
+
+  if (await (0, _nodeEnv.canUseYarn)()) {
+    return 'yarn';
+  }
+
   return 'npm';
 }

package/dist/js/node/index.js

@@ -418,6 +418,20 @@ Object.keys(_watch).forEach(function (key) {
   });
 });
 
+var _nodeEnv = require("./nodeEnv");
+
+Object.keys(_nodeEnv).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nodeEnv[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nodeEnv[key];
+    }
+  });
+});
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/js/node/nodeEnv.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canUseNpm = canUseNpm;
+exports.canUsePnpm = canUsePnpm;
+exports.canUseYarn = canUseYarn;
+
+var _execa = _interopRequireDefault(require("execa"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function canUseNpm() {
+  try {
+    await (0, _execa.default)('npm', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function canUseYarn() {
+  try {
+    await (0, _execa.default)('yarn', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+async function canUsePnpm() {
+  try {
+    await (0, _execa.default)('pnpm', ['--version'], {
+      env: process.env
+    });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

package/dist/js/node/watch.js

@@ -24,7 +24,7 @@ exports.WatchChangeType = WatchChangeType;
 
 const watch = (watchDir, runTask, ignored = []) => {
   let ready = false;
-  const watcher = chokidar.watch(`${watchDir}/**/*.{js,jsx,ts,tsx}`, {
+  const watcher = chokidar.watch(watchDir, {
     ignored
   });
   watcher.on('ready', () => ready = true);

package/dist/js/treeshaking/getPackageManager.js

@@ -1,25 +1,101 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 import os from 'os';
 import path from 'path';
 import fs from 'fs-extra';
+import { canUsePnpm, canUseYarn } from "./nodeEnv";
+var MAX_TIMES = 5;
 export function getPackageManager() {
-  var cwd = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : process.cwd();
-  var appDirectory = cwd;
+  return _getPackageManager.apply(this, arguments);
+}
+
+function _getPackageManager() {
+  _getPackageManager = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var cwd,
+        appDirectory,
+        times,
+        _args = arguments;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            cwd = _args.length > 0 && _args[0] !== undefined ? _args[0] : process.cwd();
+            appDirectory = cwd;
+            times = 0;
+
+          case 3:
+            if (!(os.homedir() !== appDirectory && times < MAX_TIMES)) {
+              _context.next = 14;
+              break;
+            }
+
+            times++;
+
+            if (!fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) {
+              _context.next = 7;
+              break;
+            }
+
+            return _context.abrupt("return", 'pnpm');
+
+          case 7:
+            if (!fs.existsSync(path.resolve(appDirectory, 'yarn.lock'))) {
+              _context.next = 9;
+              break;
+            }
+
+            return _context.abrupt("return", 'yarn');
+
+          case 9:
+            if (!fs.existsSync(path.resolve(appDirectory, 'package-lock.json'))) {
+              _context.next = 11;
+              break;
+            }
+
+            return _context.abrupt("return", 'npm');
+
+          case 11:
+            appDirectory = path.join(appDirectory, '..');
+            _context.next = 3;
+            break;
+
+          case 14:
+            _context.next = 16;
+            return canUsePnpm();
+
+          case 16:
+            if (!_context.sent) {
+              _context.next = 18;
+              break;
+            }
+
+            return _context.abrupt("return", 'pnpm');
 
-  while (os.homedir() !== appDirectory) {
-    if (fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) {
-      return 'pnpm';
-    }
+          case 18:
+            _context.next = 20;
+            return canUseYarn();
 
-    if (fs.existsSync(path.resolve(appDirectory, 'yarn.lock'))) {
-      return 'yarn';
-    }
+          case 20:
+            if (!_context.sent) {
+              _context.next = 22;
+              break;
+            }
 
-    if (fs.existsSync(path.resolve(appDirectory, 'package-lock.json'))) {
-      return 'npm';
-    }
+            return _context.abrupt("return", 'yarn');
 
-    appDirectory = path.join(appDirectory, '..');
-  }
+          case 22:
+            return _context.abrupt("return", 'npm');
 
-  return 'npm';
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _getPackageManager.apply(this, arguments);
 }

package/dist/js/treeshaking/index.js

@@ -28,4 +28,5 @@ export * from "./generateMetaTags";
 export * from "./prettyInstructions";
 export * from "./alias";
 export * from "./import";
-export * from "./watch";
+export * from "./watch";
+export * from "./nodeEnv";

package/dist/js/treeshaking/nodeEnv.js

@@ -0,0 +1,108 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+import execa from 'execa';
+export function canUseNpm() {
+  return _canUseNpm.apply(this, arguments);
+}
+
+function _canUseNpm() {
+  _canUseNpm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return execa('npm', ['--version'], {
+              env: process.env
+            });
+
+          case 3:
+            return _context.abrupt("return", true);
+
+          case 6:
+            _context.prev = 6;
+            _context.t0 = _context["catch"](0);
+            return _context.abrupt("return", false);
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[0, 6]]);
+  }));
+  return _canUseNpm.apply(this, arguments);
+}
+
+export function canUseYarn() {
+  return _canUseYarn.apply(this, arguments);
+}
+
+function _canUseYarn() {
+  _canUseYarn = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            _context2.next = 3;
+            return execa('yarn', ['--version'], {
+              env: process.env
+            });
+
+          case 3:
+            return _context2.abrupt("return", true);
+
+          case 6:
+            _context2.prev = 6;
+            _context2.t0 = _context2["catch"](0);
+            return _context2.abrupt("return", false);
+
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[0, 6]]);
+  }));
+  return _canUseYarn.apply(this, arguments);
+}
+
+export function canUsePnpm() {
+  return _canUsePnpm.apply(this, arguments);
+}
+
+function _canUsePnpm() {
+  _canUsePnpm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            _context3.next = 3;
+            return execa('pnpm', ['--version'], {
+              env: process.env
+            });
+
+          case 3:
+            return _context3.abrupt("return", true);
+
+          case 6:
+            _context3.prev = 6;
+            _context3.t0 = _context3["catch"](0);
+            return _context3.abrupt("return", false);
+
+          case 9:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[0, 6]]);
+  }));
+  return _canUsePnpm.apply(this, arguments);
+}

package/dist/js/treeshaking/watch.js

@@ -15,7 +15,7 @@ export var WatchChangeType = {
 export var watch = function watch(watchDir, runTask) {
   var ignored = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
   var ready = false;
-  var watcher = chokidar.watch("".concat(watchDir, "/**/*.{js,jsx,ts,tsx}"), {
+  var watcher = chokidar.watch(watchDir, {
     ignored: ignored
   });
   watcher.on('ready', function () {

package/dist/types/getPackageManager.d.ts

@@ -1 +1 @@
-export declare function getPackageManager(cwd?: string): "pnpm" | "yarn" | "npm";
+export declare function getPackageManager(cwd?: string): Promise<"npm" | "yarn" | "pnpm">;

package/dist/types/index.d.ts

@@ -27,4 +27,5 @@ export * from './generateMetaTags';
 export * from './prettyInstructions';
 export * from './alias';
 export * from './import';
-export * from './watch';
+export * from './watch';
+export * from './nodeEnv';

package/dist/types/nodeEnv.d.ts

@@ -0,0 +1,3 @@
+export declare function canUseNpm(): Promise<boolean>;
+export declare function canUseYarn(): Promise<boolean>;
+export declare function canUsePnpm(): Promise<boolean>;

package/dist/types/watch.d.ts

@@ -4,5 +4,5 @@ declare type RunTaskType = (option: {
   changedFilePath: string;
   changeType: WatchChangeTypeValueT;
 }) => void | Promise<void>;
-export declare const watch: (watchDir: string, runTask: RunTaskType, ignored?: string[]) => import("chokidar").FSWatcher;
+export declare const watch: (watchDir: string | string[], runTask: RunTaskType, ignored?: string[]) => import("chokidar").FSWatcher;
 export {};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.1.4-rc.0",
+  "version": "1.1.6-rc.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -54,7 +54,8 @@
     "recursive-readdir": "^2.2.2",
     "strip-ansi": "6.0.0",
     "upath": "^2.0.1",
-    "yaml": "^1.10.2"
+    "yaml": "^1.10.2",
+    "execa": "5"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
@@ -65,8 +66,8 @@
     "@types/recursive-readdir": "^2.2.0",
     "typescript": "^4",
     "webpack": "^5.54.0",
-    "@modern-js/plugin-testing": "^1.1.1",
-    "@modern-js/module-tools": "^1.1.1"
+    "@modern-js/plugin-testing": "^1.2.2",
+    "@modern-js/module-tools": "^1.1.4"
   },
   "peerDependencies": {
     "typescript": "^4.4.3"

package/src/getPackageManager.ts

@@ -1,10 +1,14 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs-extra';
+import { canUsePnpm, canUseYarn } from './nodeEnv';
 
-export function getPackageManager(cwd: string = process.cwd()) {
+const MAX_TIMES = 5;
+export async function getPackageManager(cwd: string = process.cwd()) {
   let appDirectory = cwd;
-  while (os.homedir() !== appDirectory) {
+  let times = 0;
+  while (os.homedir() !== appDirectory && times < MAX_TIMES) {
+    times++;
     if (fs.existsSync(path.resolve(appDirectory, 'pnpm-lock.yaml'))) {
       return 'pnpm';
     }
@@ -16,5 +20,11 @@ export function getPackageManager(cwd: string = process.cwd()) {
     }
     appDirectory = path.join(appDirectory, '..');
   }
+  if (await canUsePnpm()) {
+    return 'pnpm';
+  }
+  if (await canUseYarn()) {
+    return 'yarn';
+  }
   return 'npm';
 }

package/src/index.ts

@@ -28,3 +28,4 @@ export * from './prettyInstructions';
 export * from './alias';
 export * from './import';
 export * from './watch';
+export * from './nodeEnv';

package/src/nodeEnv.ts

@@ -0,0 +1,28 @@
+import execa from 'execa';
+
+export async function canUseNpm() {
+  try {
+    await execa('npm', ['--version'], { env: process.env });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function canUseYarn() {
+  try {
+    await execa('yarn', ['--version'], { env: process.env });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export async function canUsePnpm() {
+  try {
+    await execa('pnpm', ['--version'], { env: process.env });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

package/src/watch.ts

@@ -20,12 +20,12 @@ type RunTaskType = (option: {
 }) => void | Promise<void>;
 
 export const watch = (
-  watchDir: string,
+  watchDir: string | string[],
   runTask: RunTaskType,
   ignored: string[] = [],
 ) => {
   let ready = false;
-  const watcher = chokidar.watch(`${watchDir}/**/*.{js,jsx,ts,tsx}`, {
+  const watcher = chokidar.watch(watchDir, {
     ignored,
   });
 

package/tests/index.test.ts

@@ -0,0 +1,16 @@
+import { canUseNpm, canUsePnpm, canUseYarn } from '@/index';
+
+describe('test generator utils', () => {
+  test('test canUseNpm', async () => {
+    const npmAbility = await canUseNpm();
+    expect(typeof npmAbility === 'boolean').toBe(true);
+  });
+  test('test canUsePnpm', async () => {
+    const pnpmAbility = await canUsePnpm();
+    expect(typeof pnpmAbility === 'boolean').toBe(true);
+  });
+  test('test canUseYarn', async () => {
+    const yarnAbility = await canUseYarn();
+    expect(typeof yarnAbility === 'boolean').toBe(true);
+  });
+});