vite-plugin-performance 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ice breaker
+
+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,120 @@
+# `wrapPlugin` – Vite Plugin Performance Wrapper
+
+`wrapPlugin` is a utility function designed to wrap Vite plugins and monitor the execution time of their lifecycle hooks. It helps developers gain insights into plugin performance and identify potential bottlenecks.
+
+---
+
+## ✨ Features
+
+- Automatically wraps and times specified Vite plugin hooks
+- Supports threshold-based logging (only logs slow hooks)
+- Allows custom hook selection
+- Provides a callback for custom performance tracking
+- Array merge support with override using `defu`
+
+---
+
+## 📦 Installation
+
+```sh
+npm i -D vite-plugin-performance
+```
+
+---
+
+## 🚀 Usage
+
+```ts
+import someVitePlugin from 'some-vite-plugin'
+import { defineConfig } from 'vite'
+import { wrapPlugin } from 'vite-plugin-performance'
+
+export default defineConfig({
+  plugins: [
+    wrapPlugin(
+      someVitePlugin(),
+      {
+        threshold: 50, // Log only hooks taking longer than 50ms
+        onHookExecution: ({ pluginName, hookName, duration }) => {
+          // Custom logic, e.g., send to monitoring service
+          reportToMonitoringSystem({ pluginName, hookName, duration })
+        },
+      }
+    ),
+  ],
+})
+```
+
+---
+
+## 🧩 API
+
+### `wrapPlugin(plugin: Plugin, options?: Partial<WrapPluginOptions>): Plugin`
+
+#### Parameters
+
+- `plugin`: A Vite plugin object
+- `options`: Optional configuration object
+
+#### `WrapPluginOptions` Interface
+
+| Option            | Type                                      | Default                      | Description                            |
+| ----------------- | ----------------------------------------- | ---------------------------- | -------------------------------------- |
+| `threshold`       | `number`                                  | `0`                          | Minimum duration (ms) to log a hook    |
+| `onHookExecution` | `(params: OnHookExecutionParams) => void` | `undefined`                  | Callback invoked when a hook completes |
+| `hooks`           | `PluginHooks[]`                           | Common hook list (see below) | List of Vite plugin hooks to wrap      |
+| `slient`          | `boolean`                                 | `false`                      | Suppress default console output        |
+
+#### Default Hook List:
+
+```ts
+[
+  'options',
+  'buildStart',
+  'resolveId',
+  'load',
+  'transform',
+  'buildEnd',
+  'generateBundle',
+  'renderChunk',
+  'writeBundle',
+]
+```
+
+---
+
+## 🧪 Example Output
+
+When a hook's execution time exceeds the threshold, output will be shown in the console:
+
+```
+[my-plugin] transform            ⏱  132.57 ms
+```
+
+---
+
+## 📘 Types
+
+### `OnHookExecutionParams`
+
+```ts
+interface OnHookExecutionParams {
+  pluginName: string
+  hookName: string
+  args: any[]
+  duration: number
+}
+```
+
+---
+
+## ⚠️ Notes
+
+- This utility only works with object-based plugin definitions. It does not support plugins returned as arrays.
+- Async hooks are automatically awaited to ensure accurate timing.
+
+---
+
+## 📄 License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+function getDefaultOptions() {
+  return {
+    threshold: 0,
+    hooks: [
+      "options",
+      "buildStart",
+      "resolveId",
+      "load",
+      "transform",
+      "buildEnd",
+      "generateBundle",
+      "renderChunk",
+      "writeBundle"
+    ],
+    slient: false
+  };
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+
+const defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+
+function wrapPlugin(maybePlugin, options) {
+  const isArr = Array.isArray(maybePlugin);
+  const plugins = isArr ? maybePlugin : [maybePlugin];
+  const wrappedPlugins = plugins.map((plugin) => {
+    const wrapped = { ...plugin };
+    const { threshold = 0, onHookExecution, hooks, slient } = defuOverrideArray(
+      options,
+      getDefaultOptions()
+    );
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        if (typeof plugin[hook] === "function") {
+          wrapped[hook] = async function(...args) {
+            const start = performance.now();
+            const result = await plugin[hook]?.apply(this, args);
+            const end = performance.now();
+            const duration = Math.round(end - start);
+            if (duration >= threshold) {
+              const pluginName = plugin.name;
+              if (!slient) {
+                console.log(`[${pluginName}] ${hook.padEnd(20)} \u23F1 ${duration.toFixed(2).padStart(6)} ms`);
+              }
+              onHookExecution?.({
+                pluginName,
+                hookName: hook,
+                args,
+                duration
+              });
+            }
+            return result;
+          };
+        }
+      }
+    }
+    return wrapped;
+  });
+  return isArr ? wrappedPlugins : wrappedPlugins[0];
+}
+
+exports.wrapPlugin = wrapPlugin;

package/dist/index.d.cts

@@ -0,0 +1,20 @@
+import { Plugin } from 'vite';
+
+type PluginHooks = keyof Plugin;
+interface OnHookExecutionParams {
+    pluginName: string;
+    hookName: string;
+    args: any[];
+    duration: number;
+}
+interface WrapPluginOptions {
+    threshold?: number;
+    onHookExecution?: (params: OnHookExecutionParams) => void;
+    hooks?: PluginHooks[];
+    slient?: boolean;
+}
+
+declare function wrapPlugin(maybePlugin: Plugin, options?: Partial<WrapPluginOptions>): Plugin;
+declare function wrapPlugin(maybePlugin: Plugin[], options?: Partial<WrapPluginOptions>): Plugin[];
+
+export { type OnHookExecutionParams, type PluginHooks, type WrapPluginOptions, wrapPlugin };

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+import { Plugin } from 'vite';
+
+type PluginHooks = keyof Plugin;
+interface OnHookExecutionParams {
+    pluginName: string;
+    hookName: string;
+    args: any[];
+    duration: number;
+}
+interface WrapPluginOptions {
+    threshold?: number;
+    onHookExecution?: (params: OnHookExecutionParams) => void;
+    hooks?: PluginHooks[];
+    slient?: boolean;
+}
+
+declare function wrapPlugin(maybePlugin: Plugin, options?: Partial<WrapPluginOptions>): Plugin;
+declare function wrapPlugin(maybePlugin: Plugin[], options?: Partial<WrapPluginOptions>): Plugin[];
+
+export { type OnHookExecutionParams, type PluginHooks, type WrapPluginOptions, wrapPlugin };

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from 'vite';
+
+type PluginHooks = keyof Plugin;
+interface OnHookExecutionParams {
+    pluginName: string;
+    hookName: string;
+    args: any[];
+    duration: number;
+}
+interface WrapPluginOptions {
+    threshold?: number;
+    onHookExecution?: (params: OnHookExecutionParams) => void;
+    hooks?: PluginHooks[];
+    slient?: boolean;
+}
+
+declare function wrapPlugin(maybePlugin: Plugin, options?: Partial<WrapPluginOptions>): Plugin;
+declare function wrapPlugin(maybePlugin: Plugin[], options?: Partial<WrapPluginOptions>): Plugin[];
+
+export { type OnHookExecutionParams, type PluginHooks, type WrapPluginOptions, wrapPlugin };

package/dist/index.mjs

@@ -0,0 +1,120 @@
+function getDefaultOptions() {
+  return {
+    threshold: 0,
+    hooks: [
+      "options",
+      "buildStart",
+      "resolveId",
+      "load",
+      "transform",
+      "buildEnd",
+      "generateBundle",
+      "renderChunk",
+      "writeBundle"
+    ],
+    slient: false
+  };
+}
+
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+
+const defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+
+function wrapPlugin(maybePlugin, options) {
+  const isArr = Array.isArray(maybePlugin);
+  const plugins = isArr ? maybePlugin : [maybePlugin];
+  const wrappedPlugins = plugins.map((plugin) => {
+    const wrapped = { ...plugin };
+    const { threshold = 0, onHookExecution, hooks, slient } = defuOverrideArray(
+      options,
+      getDefaultOptions()
+    );
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        if (typeof plugin[hook] === "function") {
+          wrapped[hook] = async function(...args) {
+            const start = performance.now();
+            const result = await plugin[hook]?.apply(this, args);
+            const end = performance.now();
+            const duration = Math.round(end - start);
+            if (duration >= threshold) {
+              const pluginName = plugin.name;
+              if (!slient) {
+                console.log(`[${pluginName}] ${hook.padEnd(20)} \u23F1 ${duration.toFixed(2).padStart(6)} ms`);
+              }
+              onHookExecution?.({
+                pluginName,
+                hookName: hook,
+                args,
+                duration
+              });
+            }
+            return result;
+          };
+        }
+      }
+    }
+    return wrapped;
+  });
+  return isArr ? wrappedPlugins : wrappedPlugins[0];
+}
+
+export { wrapPlugin };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "vite-plugin-performance",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "vite-plugin-performance",
+  "author": "ice breaker <1324318532@qq.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weapp-vite/weapp-vite.git",
+    "directory": "packages/vite-plugin-performance"
+  },
+  "bugs": {
+    "url": "https://github.com/weapp-vite/weapp-vite/issues"
+  },
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "unbuild --stub",
+    "build:watch": "unbuild --watch --sourcemap",
+    "build": "unbuild",
+    "test": "vitest run",
+    "test:dev": "vitest",
+    "release": "pnpm publish",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  }
+}