@rolldown/pluginutils 1.0.0-beta.55 → 1.0.0-beta.56

package/dist/composable-filters.d.ts

@@ -1,7 +1,7 @@
 type StringOrRegExp = string | RegExp;
 type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
 export type FilterExpressionKind = FilterExpression['kind'];
-export type FilterExpression = And | Or | Not | Id | ModuleType | Code | Query;
+export type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
 export type TopLevelFilterExpression = Include | Exclude;
 declare class And {
     kind: 'and';
@@ -30,6 +30,12 @@ declare class Id {
     params: IdParams;
     constructor(pattern: StringOrRegExp, params?: IdParams);
 }
+declare class ImporterId {
+    kind: 'importerId';
+    pattern: StringOrRegExp;
+    params: IdParams;
+    constructor(pattern: StringOrRegExp, params?: IdParams);
+}
 declare class ModuleType {
     kind: 'moduleType';
     pattern: PluginModuleType;
@@ -60,6 +66,7 @@ export declare function and(...args: FilterExpression[]): And;
 export declare function or(...args: FilterExpression[]): Or;
 export declare function not(expr: FilterExpression): Not;
 export declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
+export declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
 export declare function moduleType(pattern: PluginModuleType): ModuleType;
 export declare function code(pattern: StringOrRegExp): Code;
 export declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
@@ -74,10 +81,10 @@ export declare function exclude(expr: FilterExpression): Exclude;
  * @returns a `And` FilterExpression
  */
 export declare function queries(queryFilter: QueryFilterObject): And;
-export declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType): boolean;
+export declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
 interface InterpreterCtx {
     urlSearchParamsCache?: URLSearchParams;
 }
-export declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
-export declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, ctx?: InterpreterCtx): boolean;
+export declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
+export declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
 export {};

package/dist/composable-filters.js

@@ -41,6 +41,18 @@ class Id {
         };
     }
 }
+class ImporterId {
+    kind;
+    pattern;
+    params;
+    constructor(pattern, params) {
+        this.pattern = pattern;
+        this.kind = 'importerId';
+        this.params = params ?? {
+            cleanUrl: false,
+        };
+    }
+}
 class ModuleType {
     kind;
     pattern;
@@ -95,6 +107,9 @@ export function not(expr) {
 export function id(pattern, params) {
     return new Id(pattern, params);
 }
+export function importerId(pattern, params) {
+    return new ImporterId(pattern, params);
+}
 export function moduleType(pattern) {
     return new ModuleType(pattern);
 }
@@ -130,7 +145,7 @@ export function queries(queryFilter) {
     });
     return and(...arr);
 }
-export function interpreter(exprs, code, id, moduleType) {
+export function interpreter(exprs, code, id, moduleType, importerId) {
     let arr = [];
     if (Array.isArray(exprs)) {
         arr = exprs;
@@ -138,21 +153,21 @@ export function interpreter(exprs, code, id, moduleType) {
     else {
         arr = [exprs];
     }
-    return interpreterImpl(arr, code, id, moduleType);
+    return interpreterImpl(arr, code, id, moduleType, importerId);
 }
-export function interpreterImpl(expr, code, id, moduleType, ctx = {}) {
+export function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
     let hasInclude = false;
     for (const e of expr) {
         switch (e.kind) {
             case 'include': {
                 hasInclude = true;
-                if (exprInterpreter(e.expr, code, id, moduleType, ctx)) {
+                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
                     return true;
                 }
                 break;
             }
             case 'exclude': {
-                if (exprInterpreter(e.expr, code, id, moduleType)) {
+                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
                     return false;
                 }
                 break;
@@ -161,27 +176,40 @@ export function interpreterImpl(expr, code, id, moduleType, ctx = {}) {
     }
     return !hasInclude;
 }
-export function exprInterpreter(expr, code, id, moduleType, ctx = {}) {
+export function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
     switch (expr.kind) {
         case 'and': {
-            return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, ctx));
+            return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
         }
         case 'or': {
-            return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, ctx));
+            return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
         }
         case 'not': {
-            return !exprInterpreter(expr.expr, code, id, moduleType, ctx);
+            return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
         }
         case 'id': {
             if (id === undefined) {
                 throw new Error('`id` is required for `id` expression');
             }
+            let idToMatch = id;
+            if (expr.params.cleanUrl) {
+                idToMatch = cleanUrl(idToMatch);
+            }
+            return typeof expr.pattern === 'string'
+                ? idToMatch === expr.pattern
+                : expr.pattern.test(idToMatch);
+        }
+        case 'importerId': {
+            if (importerId === undefined) {
+                return false; // Entry files have no importer, so no match
+            }
+            let importerIdToMatch = importerId;
             if (expr.params.cleanUrl) {
-                id = cleanUrl(id);
+                importerIdToMatch = cleanUrl(importerIdToMatch);
             }
             return typeof expr.pattern === 'string'
-                ? id === expr.pattern
-                : expr.pattern.test(id);
+                ? importerIdToMatch === expr.pattern
+                : expr.pattern.test(importerIdToMatch);
         }
         case 'moduleType': {
             if (moduleType === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolldown/pluginutils",
-  "version": "1.0.0-beta.55",
+  "version": "1.0.0-beta.56",
   "license": "MIT",
   "type": "module",
   "repository": {