@rolldown/pluginutils 1.0.0-beta.35 → 1.0.0-beta.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolldown/pluginutils",
-  "version": "1.0.0-beta.35",
+  "version": "1.0.0-beta.37",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -11,14 +11,12 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist"
@@ -26,9 +24,13 @@
   "devDependencies": {
     "@types/picomatch": "^4.0.0",
     "picomatch": "^4.0.2",
-    "tsdown": "0.14.2",
+    "tsdown": "0.15.0",
     "vitest": "^3.0.1"
   },
+  "tsdown": {
+    "exports": true,
+    "fixedExtension": true
+  },
   "scripts": {
     "build": "tsdown",
     "test": "vitest --typecheck"

package/dist/index.cjs

@@ -1,266 +0,0 @@
-
-//#region src/utils.ts
-const postfixRE = /[?#].*$/;
-function cleanUrl(url) {
-	return url.replace(postfixRE, "");
-}
-function extractQueryWithoutFragment(url) {
-	const questionMarkIndex = url.indexOf("?");
-	if (questionMarkIndex === -1) return "";
-	const fragmentIndex = url.indexOf("#", questionMarkIndex);
-	if (fragmentIndex === -1) return url.substring(questionMarkIndex);
-	else return url.substring(questionMarkIndex, fragmentIndex);
-}
-
-//#endregion
-//#region src/composable-filters.ts
-var And = class {
-	kind;
-	args;
-	constructor(...args) {
-		if (args.length === 0) throw new Error("`And` expects at least one operand");
-		this.args = args;
-		this.kind = "and";
-	}
-};
-var Or = class {
-	kind;
-	args;
-	constructor(...args) {
-		if (args.length === 0) throw new Error("`Or` expects at least one operand");
-		this.args = args;
-		this.kind = "or";
-	}
-};
-var Not = class {
-	kind;
-	expr;
-	constructor(expr) {
-		this.expr = expr;
-		this.kind = "not";
-	}
-};
-var Id = class {
-	kind;
-	pattern;
-	params;
-	constructor(pattern, params) {
-		this.pattern = pattern;
-		this.kind = "id";
-		this.params = params ?? { cleanUrl: false };
-	}
-};
-var ModuleType = class {
-	kind;
-	pattern;
-	constructor(pattern) {
-		this.pattern = pattern;
-		this.kind = "moduleType";
-	}
-};
-var Code = class {
-	kind;
-	pattern;
-	constructor(expr) {
-		this.pattern = expr;
-		this.kind = "code";
-	}
-};
-var Query = class {
-	kind;
-	key;
-	pattern;
-	constructor(key, pattern) {
-		this.pattern = pattern;
-		this.key = key;
-		this.kind = "query";
-	}
-};
-var Include = class {
-	kind;
-	expr;
-	constructor(expr) {
-		this.expr = expr;
-		this.kind = "include";
-	}
-};
-var Exclude = class {
-	kind;
-	expr;
-	constructor(expr) {
-		this.expr = expr;
-		this.kind = "exclude";
-	}
-};
-function and(...args) {
-	return new And(...args);
-}
-function or(...args) {
-	return new Or(...args);
-}
-function not(expr) {
-	return new Not(expr);
-}
-function id(pattern, params) {
-	return new Id(pattern, params);
-}
-function moduleType(pattern) {
-	return new ModuleType(pattern);
-}
-function code(pattern) {
-	return new Code(pattern);
-}
-function query(key, pattern) {
-	return new Query(key, pattern);
-}
-function include(expr) {
-	return new Include(expr);
-}
-function exclude(expr) {
-	return new Exclude(expr);
-}
-/**
-* convert a queryObject to FilterExpression like
-* ```js
-*   and(query(k1, v1), query(k2, v2))
-* ```
-* @param queryFilterObject The query filter object needs to be matched.
-* @returns a `And` FilterExpression
-*/
-function queries(queryFilter) {
-	let arr = Object.entries(queryFilter).map(([key, value]) => {
-		return new Query(key, value);
-	});
-	return and(...arr);
-}
-function interpreter(exprs, code$1, id$1, moduleType$1) {
-	let arr = [];
-	if (Array.isArray(exprs)) arr = exprs;
-	else arr = [exprs];
-	return interpreterImpl(arr, code$1, id$1, moduleType$1);
-}
-function interpreterImpl(expr, code$1, id$1, moduleType$1, ctx = {}) {
-	let hasInclude = false;
-	for (const e of expr) switch (e.kind) {
-		case "include":
-			hasInclude = true;
-			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1, ctx)) return true;
-			break;
-		case "exclude":
-			if (exprInterpreter(e.expr, code$1, id$1, moduleType$1)) return false;
-			break;
-	}
-	return !hasInclude;
-}
-function exprInterpreter(expr, code$1, id$1, moduleType$1, ctx = {}) {
-	switch (expr.kind) {
-		case "and": return expr.args.every((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
-		case "or": return expr.args.some((e) => exprInterpreter(e, code$1, id$1, moduleType$1, ctx));
-		case "not": return !exprInterpreter(expr.expr, code$1, id$1, moduleType$1, ctx);
-		case "id":
-			if (id$1 === void 0) throw new Error("`id` is required for `id` expression");
-			if (expr.params.cleanUrl) id$1 = cleanUrl(id$1);
-			return typeof expr.pattern === "string" ? id$1 === expr.pattern : expr.pattern.test(id$1);
-		case "moduleType":
-			if (moduleType$1 === void 0) throw new Error("`moduleType` is required for `moduleType` expression");
-			return moduleType$1 === expr.pattern;
-		case "code":
-			if (code$1 === void 0) throw new Error("`code` is required for `code` expression");
-			return typeof expr.pattern === "string" ? code$1.includes(expr.pattern) : expr.pattern.test(code$1);
-		case "query": {
-			if (id$1 === void 0) throw new Error("`id` is required for `Query` expression");
-			if (!ctx.urlSearchParamsCache) {
-				let queryString = extractQueryWithoutFragment(id$1);
-				ctx.urlSearchParamsCache = new URLSearchParams(queryString);
-			}
-			let urlParams = ctx.urlSearchParamsCache;
-			if (typeof expr.pattern === "boolean") if (expr.pattern) return urlParams.has(expr.key);
-			else return !urlParams.has(expr.key);
-			else if (typeof expr.pattern === "string") return urlParams.get(expr.key) === expr.pattern;
-			else return expr.pattern.test(urlParams.get(expr.key) ?? "");
-		}
-		default: throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
-	}
-}
-
-//#endregion
-//#region src/simple-filters.ts
-/**
-* Constructs a RegExp that matches the exact string specified.
-*
-* This is useful for plugin hook filters.
-*
-* @param str the string to match.
-* @param flags flags for the RegExp.
-*
-* @example
-* ```ts
-* import { exactRegex } from '@rolldown/pluginutils';
-* const plugin = {
-*   name: 'plugin',
-*   resolveId: {
-*     filter: { id: exactRegex('foo') },
-*     handler(id) {} // will only be called for `foo`
-*   }
-* }
-* ```
-*/
-function exactRegex(str, flags) {
-	return new RegExp(`^${escapeRegex(str)}$`, flags);
-}
-/**
-* Constructs a RegExp that matches a value that has the specified prefix.
-*
-* This is useful for plugin hook filters.
-*
-* @param str the string to match.
-* @param flags flags for the RegExp.
-*
-* @example
-* ```ts
-* import { prefixRegex } from '@rolldown/pluginutils';
-* const plugin = {
-*   name: 'plugin',
-*   resolveId: {
-*     filter: { id: prefixRegex('foo') },
-*     handler(id) {} // will only be called for IDs starting with `foo`
-*   }
-* }
-* ```
-*/
-function prefixRegex(str, flags) {
-	return new RegExp(`^${escapeRegex(str)}`, flags);
-}
-const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
-function escapeRegex(str) {
-	return str.replace(escapeRegexRE, "\\$&");
-}
-function makeIdFiltersToMatchWithQuery(input) {
-	if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
-	return input.map((i) => makeIdFilterToMatchWithQuery(i));
-}
-function makeIdFilterToMatchWithQuery(input) {
-	if (typeof input === "string") return `${input}{?*,}`;
-	return makeRegexIdFilterToMatchWithQuery(input);
-}
-function makeRegexIdFilterToMatchWithQuery(input) {
-	return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
-}
-
-//#endregion
-exports.and = and;
-exports.code = code;
-exports.exactRegex = exactRegex;
-exports.exclude = exclude;
-exports.exprInterpreter = exprInterpreter;
-exports.id = id;
-exports.include = include;
-exports.interpreter = interpreter;
-exports.interpreterImpl = interpreterImpl;
-exports.makeIdFiltersToMatchWithQuery = makeIdFiltersToMatchWithQuery;
-exports.moduleType = moduleType;
-exports.not = not;
-exports.or = or;
-exports.prefixRegex = prefixRegex;
-exports.queries = queries;
-exports.query = query;

package/dist/index.d.ts

@@ -1,157 +0,0 @@
-//#region src/composable-filters.d.ts
-type StringOrRegExp = string | RegExp;
-type PluginModuleType = "js" | "jsx" | "ts" | "tsx" | "json" | "text" | "base64" | "dataurl" | "binary" | "empty" | (string & {});
-type FilterExpressionKind = FilterExpression["kind"];
-type FilterExpression = And | Or | Not | Id | ModuleType | Code | Query;
-type TopLevelFilterExpression = Include | Exclude;
-declare class And {
-  kind: "and";
-  args: FilterExpression[];
-  constructor(...args: FilterExpression[]);
-}
-declare class Or {
-  kind: "or";
-  args: FilterExpression[];
-  constructor(...args: FilterExpression[]);
-}
-declare class Not {
-  kind: "not";
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-interface QueryFilterObject {
-  [key: string]: StringOrRegExp | boolean;
-}
-interface IdParams {
-  cleanUrl?: boolean;
-}
-declare class Id {
-  kind: "id";
-  pattern: StringOrRegExp;
-  params: IdParams;
-  constructor(pattern: StringOrRegExp, params?: IdParams);
-}
-declare class ModuleType {
-  kind: "moduleType";
-  pattern: PluginModuleType;
-  constructor(pattern: PluginModuleType);
-}
-declare class Code {
-  kind: "code";
-  pattern: StringOrRegExp;
-  constructor(expr: StringOrRegExp);
-}
-declare class Query {
-  kind: "query";
-  key: string;
-  pattern: StringOrRegExp | boolean;
-  constructor(key: string, pattern: StringOrRegExp | boolean);
-}
-declare class Include {
-  kind: "include";
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-declare class Exclude {
-  kind: "exclude";
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-declare function and(...args: FilterExpression[]): And;
-declare function or(...args: FilterExpression[]): Or;
-declare function not(expr: FilterExpression): Not;
-declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
-declare function moduleType(pattern: PluginModuleType): ModuleType;
-declare function code(pattern: StringOrRegExp): Code;
-declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
-declare function include(expr: FilterExpression): Include;
-declare function exclude(expr: FilterExpression): Exclude;
-/**
-* convert a queryObject to FilterExpression like
-* ```js
-*   and(query(k1, v1), query(k2, v2))
-* ```
-* @param queryFilterObject The query filter object needs to be matched.
-* @returns a `And` FilterExpression
-*/
-declare function queries(queryFilter: QueryFilterObject): And;
-declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType): boolean;
-interface InterpreterCtx {
-  urlSearchParamsCache?: URLSearchParams;
-}
-declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
-declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
-//#endregion
-//#region src/simple-filters.d.ts
-/**
-* Constructs a RegExp that matches the exact string specified.
-*
-* This is useful for plugin hook filters.
-*
-* @param str the string to match.
-* @param flags flags for the RegExp.
-*
-* @example
-* ```ts
-* import { exactRegex } from '@rolldown/pluginutils';
-* const plugin = {
-*   name: 'plugin',
-*   resolveId: {
-*     filter: { id: exactRegex('foo') },
-*     handler(id) {} // will only be called for `foo`
-*   }
-* }
-* ```
-*/
-declare function exactRegex(str: string, flags?: string): RegExp;
-/**
-* Constructs a RegExp that matches a value that has the specified prefix.
-*
-* This is useful for plugin hook filters.
-*
-* @param str the string to match.
-* @param flags flags for the RegExp.
-*
-* @example
-* ```ts
-* import { prefixRegex } from '@rolldown/pluginutils';
-* const plugin = {
-*   name: 'plugin',
-*   resolveId: {
-*     filter: { id: prefixRegex('foo') },
-*     handler(id) {} // will only be called for IDs starting with `foo`
-*   }
-* }
-* ```
-*/
-declare function prefixRegex(str: string, flags?: string): RegExp;
-type WidenString<T> = T extends string ? string : T;
-/**
-* Converts a id filter to match with an id with a query.
-*
-* @param input the id filters to convert.
-*
-* @example
-* ```ts
-* import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
-* const plugin = {
-*   name: 'plugin',
-*   transform: {
-*     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
-*     // The handler will be called for IDs like:
-*     // - foo.js
-*     // - foo.js?foo
-*     // - foo.txt?foo.js
-*     // - foo.ts
-*     // - foo.ts?foo
-*     // - foo.txt?foo.ts
-*     handler(code, id) {}
-*   }
-* }
-* ```
-*/
-declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
-declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
-declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
-//#endregion
-export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, id, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query };