@gytx/unplugin 3.1.0-patch.1

package/dist/parse-C8UGVJ_5.mjs

@@ -0,0 +1,140 @@
+import { resolve } from "node:path";
+import picomatch from "picomatch";
+import pify from "pify";
+//#region src/utils/general.ts
+function toArray(array) {
+	array = array || [];
+	if (Array.isArray(array)) return array;
+	return [array];
+}
+//#endregion
+//#region src/utils/filter.ts
+const BACKSLASH_REGEX = /\\/g;
+function normalize$1(path) {
+	return path.replace(BACKSLASH_REGEX, "/");
+}
+const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
+function isAbsolute$1(path) {
+	return ABSOLUTE_PATH_REGEX.test(path);
+}
+function getMatcherString(glob, cwd) {
+	if (glob.startsWith("**") || isAbsolute$1(glob)) return normalize$1(glob);
+	return normalize$1(resolve(cwd, glob));
+}
+function patternToIdFilter(pattern) {
+	if (pattern instanceof RegExp) return (id) => {
+		const normalizedId = normalize$1(id);
+		const result = pattern.test(normalizedId);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	const matcher = picomatch(getMatcherString(pattern, process.cwd()), { dot: true });
+	return (id) => {
+		return matcher(normalize$1(id));
+	};
+}
+function patternToCodeFilter(pattern) {
+	if (pattern instanceof RegExp) return (code) => {
+		const result = pattern.test(code);
+		pattern.lastIndex = 0;
+		return result;
+	};
+	return (code) => code.includes(pattern);
+}
+function createFilter(exclude, include) {
+	if (!exclude && !include) return;
+	return (input) => {
+		if (exclude?.some((filter) => filter(input))) return false;
+		if (include?.some((filter) => filter(input))) return true;
+		return !(include && include.length > 0);
+	};
+}
+function normalizeFilter(filter) {
+	if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
+	if (Array.isArray(filter)) return { include: filter };
+	return {
+		exclude: filter.exclude ? toArray(filter.exclude) : void 0,
+		include: filter.include ? toArray(filter.include) : void 0
+	};
+}
+function createIdFilter(filter) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map(patternToIdFilter);
+	const includeFilter = include?.map(patternToIdFilter);
+	return createFilter(excludeFilter, includeFilter);
+}
+function createCodeFilter(filter) {
+	if (!filter) return;
+	const { exclude, include } = normalizeFilter(filter);
+	const excludeFilter = exclude?.map(patternToCodeFilter);
+	const includeFilter = include?.map(patternToCodeFilter);
+	return createFilter(excludeFilter, includeFilter);
+}
+function createFilterForId(filter) {
+	const filterFunction = createIdFilter(filter);
+	return filterFunction ? (id) => !!filterFunction(id) : void 0;
+}
+function createFilterForTransform(idFilter, codeFilter) {
+	if (!idFilter && !codeFilter) return;
+	const idFilterFunction = createIdFilter(idFilter);
+	const codeFilterFunction = createCodeFilter(codeFilter);
+	return (id, code) => {
+		let fallback = true;
+		if (idFilterFunction) fallback &&= idFilterFunction(id);
+		if (!fallback) return false;
+		if (codeFilterFunction) fallback &&= codeFilterFunction(code);
+		return fallback;
+	};
+}
+function normalizeObjectHook(name, hook) {
+	let handler;
+	let filter;
+	if (typeof hook === "function") handler = hook;
+	else {
+		handler = hook.handler;
+		const hookFilter = hook.filter;
+		if (name === "resolveId" || name === "load") filter = createFilterForId(hookFilter?.id);
+		else filter = createFilterForTransform(hookFilter?.id, hookFilter?.code);
+	}
+	return {
+		handler,
+		filter: filter || (() => true)
+	};
+}
+//#endregion
+//#region src/utils/fs.ts
+function createNodeFs() {
+	const fsPromiseModule = import("node:fs/promises");
+	return {
+		readFile: async (path, options) => {
+			return (await fsPromiseModule).readFile(path, options);
+		},
+		stat: async (path, options) => {
+			return (await fsPromiseModule).stat(path, options);
+		},
+		lstat: async (path, options) => {
+			return (await fsPromiseModule).lstat(path, options);
+		}
+	};
+}
+function createBuildContextFs(inputFs) {
+	const fs = inputFs ? pify(inputFs) : createNodeFs();
+	return {
+		readFile: fs.readFile,
+		stat: fs.stat,
+		lstat: fs.lstat
+	};
+}
+//#endregion
+//#region src/utils/parse.ts
+let parseImpl;
+function parse(code, opts = {}) {
+	if (!parseImpl) throw new Error("Parse implementation is not set. Please call setParseImpl first.");
+	return parseImpl(code, opts);
+}
+function setParseImpl(customParse) {
+	parseImpl = customParse;
+}
+//#endregion
+export { toArray as a, normalizeObjectHook as i, setParseImpl as n, createBuildContextFs as r, parse as t };

package/dist/rspack/loaders/load.d.mts

@@ -0,0 +1,6 @@
+import { LoaderContext } from "@rspack/core";
+
+//#region src/rspack/loaders/load.d.ts
+declare function load(this: LoaderContext, source: string, map: any): Promise<void>;
+//#endregion
+export { load as default };

package/dist/rspack/loaders/load.mjs

@@ -0,0 +1,25 @@
+import { i as normalizeObjectHook } from "../../parse-C8UGVJ_5.mjs";
+import { t as normalizeAbsolutePath } from "../../webpack-like-m4jN95Ew.mjs";
+import { n as createContext, t as createBuildContext } from "../../context-cZ84xoAB.mjs";
+import { i as isVirtualModuleId, n as decodeVirtualModuleId } from "../../utils-DjVnpaM4.mjs";
+//#region src/rspack/loaders/load.ts
+async function load(source, map) {
+	const callback = this.async();
+	const { plugin } = this.query;
+	let id = this.resource;
+	if (!plugin?.load || !id) return callback(null, source, map);
+	if (isVirtualModuleId(id, plugin)) id = decodeVirtualModuleId(id, plugin);
+	const context = createContext(this);
+	const { handler } = normalizeObjectHook("load", plugin.load);
+	try {
+		const res = await handler.call(Object.assign({}, this._compilation && createBuildContext(this._compiler, this._compilation, this), context), normalizeAbsolutePath(id));
+		if (res == null) callback(null, source, map);
+		else if (typeof res !== "string") callback(null, res.code, res.map ?? map);
+		else callback(null, res, map);
+	} catch (error) {
+		if (error instanceof Error) callback(error);
+		else callback(new Error(String(error)));
+	}
+}
+//#endregion
+export { load as default };

package/dist/rspack/loaders/transform.d.mts

@@ -0,0 +1,6 @@
+import { LoaderContext } from "@rspack/core";
+
+//#region src/rspack/loaders/transform.d.ts
+declare function transform(this: LoaderContext, source: string, map: any): Promise<void>;
+//#endregion
+export { transform as default };

package/dist/rspack/loaders/transform.mjs

@@ -0,0 +1,23 @@
+import { i as normalizeObjectHook } from "../../parse-C8UGVJ_5.mjs";
+import { n as createContext, t as createBuildContext } from "../../context-cZ84xoAB.mjs";
+//#region src/rspack/loaders/transform.ts
+async function transform(source, map) {
+	const callback = this.async();
+	const { plugin } = this.query;
+	if (!plugin?.transform) return callback(null, source, map);
+	const id = this.resource;
+	const context = createContext(this);
+	const { handler, filter } = normalizeObjectHook("transform", plugin.transform);
+	if (!filter(this.resource, source)) return callback(null, source, map);
+	try {
+		const res = await handler.call(Object.assign({}, this._compilation && createBuildContext(this._compiler, this._compilation, this, map), context), source, id);
+		if (res == null) callback(null, source, map);
+		else if (typeof res !== "string") callback(null, res.code, map == null ? map : res.map || map);
+		else callback(null, res, map);
+	} catch (error) {
+		if (error instanceof Error) callback(error);
+		else callback(new Error(String(error)));
+	}
+}
+//#endregion
+export { transform as default };

package/dist/utils-DjVnpaM4.mjs

@@ -0,0 +1,53 @@
+import { basename, dirname, resolve } from "node:path";
+import fs from "node:fs";
+//#region src/rspack/utils.ts
+function encodeVirtualModuleId(id, plugin) {
+	return resolve(plugin.__virtualModulePrefix, encodeURIComponent(id));
+}
+function decodeVirtualModuleId(encoded, _plugin) {
+	return decodeURIComponent(basename(encoded));
+}
+function isVirtualModuleId(encoded, plugin) {
+	return dirname(encoded) === plugin.__virtualModulePrefix;
+}
+var FakeVirtualModulesPlugin = class FakeVirtualModulesPlugin {
+	plugin;
+	name = "FakeVirtualModulesPlugin";
+	static counters = /* @__PURE__ */ new Map();
+	static initCleanup = false;
+	constructor(plugin) {
+		this.plugin = plugin;
+		if (!FakeVirtualModulesPlugin.initCleanup) {
+			FakeVirtualModulesPlugin.initCleanup = true;
+			process.once("exit", () => {
+				FakeVirtualModulesPlugin.counters.forEach((_, dir) => {
+					fs.rmSync(dir, {
+						recursive: true,
+						force: true
+					});
+				});
+			});
+		}
+	}
+	apply(compiler) {
+		const dir = this.plugin.__virtualModulePrefix;
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		const counter = FakeVirtualModulesPlugin.counters.get(dir) ?? 0;
+		FakeVirtualModulesPlugin.counters.set(dir, counter + 1);
+		compiler.hooks.shutdown.tap(this.name, () => {
+			const counter = (FakeVirtualModulesPlugin.counters.get(dir) ?? 1) - 1;
+			if (counter === 0) {
+				FakeVirtualModulesPlugin.counters.delete(dir);
+				fs.rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+			} else FakeVirtualModulesPlugin.counters.set(dir, counter);
+		});
+	}
+	async writeModule(file) {
+		return fs.promises.writeFile(file, "");
+	}
+};
+//#endregion
+export { isVirtualModuleId as i, decodeVirtualModuleId as n, encodeVirtualModuleId as r, FakeVirtualModulesPlugin as t };

package/dist/webpack/loaders/load.d.mts

@@ -0,0 +1,6 @@
+import { LoaderContext } from "webpack";
+
+//#region src/webpack/loaders/load.d.ts
+declare function load(this: LoaderContext<any>, source: string, map: any): Promise<void>;
+//#endregion
+export { load as default };

package/dist/webpack/loaders/load.mjs

@@ -0,0 +1,26 @@
+import { i as normalizeObjectHook } from "../../parse-C8UGVJ_5.mjs";
+import { t as normalizeAbsolutePath } from "../../webpack-like-m4jN95Ew.mjs";
+import { n as createBuildContext, r as createContext } from "../../context-Dv7UHMCI.mjs";
+//#region src/webpack/loaders/load.ts
+async function load(source, map) {
+	const callback = this.async();
+	const { plugin } = this.query;
+	let id = this.resource;
+	if (!plugin?.load || !id) return callback(null, source, map);
+	if (id.startsWith(plugin.__virtualModulePrefix)) id = decodeURIComponent(id.slice(plugin.__virtualModulePrefix.length));
+	const context = createContext(this);
+	const { handler } = normalizeObjectHook("load", plugin.load);
+	const res = await handler.call(Object.assign({}, createBuildContext({
+		addWatchFile: (file) => {
+			this.addDependency(file);
+		},
+		getWatchFiles: () => {
+			return this.getDependencies();
+		}
+	}, this._compiler, this._compilation, this), context), normalizeAbsolutePath(id));
+	if (res == null) callback(null, source, map);
+	else if (typeof res !== "string") callback(null, res.code, res.map ?? map);
+	else callback(null, res, map);
+}
+//#endregion
+export { load as default };

package/dist/webpack/loaders/transform.d.mts

@@ -0,0 +1,6 @@
+import { LoaderContext } from "webpack";
+
+//#region src/webpack/loaders/transform.d.ts
+declare function transform(this: LoaderContext<any>, source: string, map: any): Promise<void>;
+//#endregion
+export { transform as default };

package/dist/webpack/loaders/transform.mjs

@@ -0,0 +1,29 @@
+import { i as normalizeObjectHook } from "../../parse-C8UGVJ_5.mjs";
+import { n as createBuildContext, r as createContext } from "../../context-Dv7UHMCI.mjs";
+//#region src/webpack/loaders/transform.ts
+async function transform(source, map) {
+	const callback = this.async();
+	const { plugin } = this.query;
+	if (!plugin?.transform) return callback(null, source, map);
+	const context = createContext(this);
+	const { handler, filter } = normalizeObjectHook("transform", plugin.transform);
+	if (!filter(this.resource, source)) return callback(null, source, map);
+	try {
+		const res = await handler.call(Object.assign({}, createBuildContext({
+			addWatchFile: (file) => {
+				this.addDependency(file);
+			},
+			getWatchFiles: () => {
+				return this.getDependencies();
+			}
+		}, this._compiler, this._compilation, this, map), context), source, this.resource);
+		if (res == null) callback(null, source, map);
+		else if (typeof res !== "string") callback(null, res.code, map == null ? map : res.map || map);
+		else callback(null, res, map);
+	} catch (error) {
+		if (error instanceof Error) callback(error);
+		else callback(new Error(String(error)));
+	}
+}
+//#endregion
+export { transform as default };

package/dist/webpack-like-m4jN95Ew.mjs

@@ -0,0 +1,31 @@
+import { i as normalizeObjectHook } from "./parse-C8UGVJ_5.mjs";
+import { isAbsolute, normalize } from "node:path";
+//#region src/utils/webpack-like.ts
+function transformUse(data, plugin, transformLoader) {
+	if (data.resource == null) return [];
+	const id = normalizeAbsolutePath(data.resource + (data.resourceQuery || ""));
+	if (plugin.transformInclude && !plugin.transformInclude(id)) return [];
+	const { filter } = normalizeObjectHook("load", plugin.transform);
+	if (!filter(id)) return [];
+	return [{
+		loader: transformLoader,
+		options: { plugin },
+		ident: plugin.name
+	}];
+}
+/**
+* Normalizes a given path when it's absolute. Normalizing means returning a new path by converting
+* the input path to the native os format. This is useful in cases where we want to normalize
+* the `id` argument of a hook. Any absolute ids should be in the default format
+* of the operating system. Any relative imports or node_module imports should remain
+* untouched.
+*
+* @param path - Path to normalize.
+* @returns a new normalized path.
+*/
+function normalizeAbsolutePath(path) {
+	if (isAbsolute(path)) return normalize(path);
+	else return path;
+}
+//#endregion
+export { transformUse as n, normalizeAbsolutePath as t };

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@gytx/unplugin",
+  "type": "module",
+  "version": "3.1.0-patch.1",
+  "packageManager": "pnpm@11.0.8",
+  "description": "Unified plugin system for build tools",
+  "license": "MIT",
+  "homepage": "https://unplugin.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unplugin.git"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./rspack/loaders/load": "./dist/rspack/loaders/load.mjs",
+    "./rspack/loaders/transform": "./dist/rspack/loaders/transform.mjs",
+    "./webpack/loaders/load": "./dist/webpack/loaders/load.mjs",
+    "./webpack/loaders/transform": "./dist/webpack/loaders/transform.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "publishConfig": {
+    "tag": "beta"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch src",
+    "lint": "eslint --cache .",
+    "lint:fix": "nr lint --fix",
+    "typecheck": "tsgo --noEmit",
+    "docs:dev": "pnpm -C docs run dev",
+    "docs:build": "pnpm -C docs run build",
+    "docs:gen-files": "pnpm -C docs run gen-files",
+    "prepublishOnly": "nr build",
+    "release": "bumpp",
+    "test": "nr test:build && vitest run",
+    "test:build": "jiti scripts/buildFixtures.ts"
+  },
+  "dependencies": {
+    "@jridgewell/remapping": "catalog:prod",
+    "picomatch": "catalog:prod",
+    "pify": "catalog:prod",
+    "webpack-virtual-modules": "catalog:prod"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "catalog:dev",
+    "@antfu/ni": "catalog:dev",
+    "@arethetypeswrong/core": "catalog:dev",
+    "@farmfe/cli": "catalog:test",
+    "@farmfe/core": "catalog:peer",
+    "@rspack/cli": "catalog:test",
+    "@rspack/core": "catalog:peer",
+    "@types/node": "catalog:dev",
+    "@types/picomatch": "catalog:dev",
+    "@typescript/native-preview": "catalog:dev",
+    "ansis": "catalog:dev",
+    "bumpp": "catalog:dev",
+    "bun-types-no-globals": "catalog:dev",
+    "esbuild": "catalog:dev",
+    "eslint": "catalog:dev",
+    "eslint-plugin-format": "catalog:dev",
+    "jiti": "catalog:dev",
+    "lint-staged": "catalog:dev",
+    "magic-string": "catalog:test",
+    "publint": "catalog:dev",
+    "rolldown": "catalog:peer",
+    "rollup": "catalog:peer",
+    "simple-git-hooks": "catalog:dev",
+    "tsdown": "catalog:dev",
+    "typescript": "catalog:dev",
+    "unloader": "catalog:peer",
+    "unplugin": "workspace:*",
+    "unplugin-unused": "catalog:dev",
+    "vite": "catalog:peer",
+    "vitest": "catalog:test",
+    "webpack": "catalog:peer",
+    "webpack-cli": "catalog:test"
+  },
+  "resolutions": {
+    "esbuild": "catalog:dev"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm i --frozen-lockfile --ignore-scripts --offline && pnpm exec lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint --fix"
+  }
+}