@bufbuild/protoplugin 0.0.10 → 0.1.0

package/dist/cjs/create-es-plugin.js

@@ -27,8 +27,8 @@ function createEcmaScriptPlugin(init, generateFn) {
         name: init.name,
         version: init.version,
         run(req) {
-            const { targets, tsNocheck, bootstrapWkt } = parseParameter(req.parameter, init.parseOption);
-            const { schema, toResponse } = (0, schema_js_1.createSchema)(req, targets, init.name, init.version, tsNocheck, bootstrapWkt);
+            const { targets, tsNocheck, bootstrapWkt, rewriteImports } = parseParameter(req.parameter, init.parseOption);
+            const { schema, toResponse } = (0, schema_js_1.createSchema)(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports);
             generateFn(schema);
             const res = new protobuf_1.CodeGeneratorResponse();
             toResponse(res);
@@ -41,6 +41,7 @@ function parseParameter(parameter, parseOption) {
     let targets = ["js", "dts"];
     let tsNocheck = true;
     let bootstrapWkt = false;
+    const rewriteImports = [];
     for (const { key, value } of splitParameter(parameter)) {
         switch (key) {
             case "target":
@@ -88,6 +89,15 @@ function parseParameter(parameter, parseOption) {
                         throw new error_js_1.PluginOptionError(`${key}=${value}`);
                 }
                 break;
+            case "rewrite_imports": {
+                const parts = value.split(":");
+                if (parts.length !== 2) {
+                    throw new error_js_1.PluginOptionError(`${key}=${value}`, "must be in the form of <pattern>:<target>");
+                }
+                const [pattern, target] = parts;
+                rewriteImports.push({ pattern, target });
+                break;
+            }
             default:
                 if (parseOption === undefined) {
                     throw new error_js_1.PluginOptionError(`${key}=${value}`);
@@ -101,7 +111,7 @@ function parseParameter(parameter, parseOption) {
                 break;
         }
     }
-    return { targets, tsNocheck, bootstrapWkt };
+    return { targets, tsNocheck, bootstrapWkt, rewriteImports };
 }
 function splitParameter(parameter) {
     if (parameter == undefined) {

package/dist/cjs/ecmascript/generated-file.js

@@ -17,8 +17,8 @@ exports.createGeneratedFile = void 0;
 const protobuf_1 = require("@bufbuild/protobuf");
 const import_symbol_js_1 = require("./import-symbol.js");
 const gencommon_js_1 = require("./gencommon.js");
-function createGeneratedFile(name, createTypeImport, runtimeImports, preambleSettings) {
-    const importPath = deriveImportPath(name);
+const import_path_js_1 = require("./import-path.js");
+function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings) {
     let preamble;
     const el = [];
     return {
@@ -55,16 +55,6 @@ function createGeneratedFile(name, createTypeImport, runtimeImports, preambleSet
     };
 }
 exports.createGeneratedFile = createGeneratedFile;
-const importPathExtension = ".js";
-const knownExtensionsRE = /\.(js|ts|d.ts)$/;
-const relativePathRE = /^\.{1,2}\//;
-function deriveImportPath(filename) {
-    let importPath = filename.replace(knownExtensionsRE, importPathExtension);
-    if (!relativePathRE.test(importPath)) {
-        importPath = "./" + importPath;
-    }
-    return importPath;
-}
 function elToContent(el, importerPath) {
     const c = [];
     const symbolToIdentifier = processImports(el, importerPath, (typeOnly, from, names) => {
@@ -221,7 +211,7 @@ function processImports(el, importerPath, makeImportStatement) {
             // should never happen
             continue;
         }
-        const from = makeImportPathRelative(importerPath, s.from);
+        const from = (0, import_path_js_1.makeImportPathRelative)(importerPath, s.from);
         if (i.types.size > 0) {
             makeImportStatement(true, from, buildNames(i.types));
         }
@@ -231,39 +221,6 @@ function processImports(el, importerPath, makeImportStatement) {
     }
     return symbolToIdentifier;
 }
-// makeImportPathRelative makes an import path relative to the file importing
-// it. For example, consider the following files:
-// - foo/foo.js
-// - baz.js
-// If foo.js wants to import baz.js, we return ../baz.js
-function makeImportPathRelative(importer, importPath) {
-    if (!relativePathRE.test(importPath)) {
-        // We don't touch absolute imports, like @bufbuild/protobuf
-        return importPath;
-    }
-    let a = importer
-        .replace(/^\.\//, "")
-        .split("/")
-        .filter((p) => p.length > 0)
-        .slice(0, -1);
-    let b = importPath
-        .replace(/^\.\//, "")
-        .split("/")
-        .filter((p) => p.length > 0);
-    let matchingPartCount = 0;
-    for (let l = Math.min(a.length, b.length); matchingPartCount < l; matchingPartCount++) {
-        if (a[matchingPartCount] !== b[matchingPartCount]) {
-            break;
-        }
-    }
-    a = a.slice(matchingPartCount);
-    b = b.slice(matchingPartCount);
-    const c = a
-        .map(() => "..")
-        .concat(b)
-        .join("/");
-    return relativePathRE.test(c) ? c : "./" + c;
-}
 function literalNumber(value) {
     if (Number.isNaN(value)) {
         return "globalThis.Number.NaN";

package/dist/cjs/ecmascript/import-path.js

@@ -0,0 +1,144 @@
+"use strict";
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeImportPathRelative = exports.deriveImportPath = exports.relativePathRE = exports.makeImportPath = exports.rewriteImportPath = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const cache = new WeakMap();
+/**
+ * Apply import rewrites to the given path.
+ */
+function rewriteImportPath(importPath, rewriteImports) {
+    let ri = cache.get(rewriteImports);
+    if (ri === undefined) {
+        ri = rewriteImports.map(({ pattern, target }) => {
+            return {
+                pattern: starToRegExp(pattern),
+                target,
+            };
+        });
+        cache.set(rewriteImports, ri);
+    }
+    for (const { pattern, target } of ri) {
+        if (pattern.test(importPath)) {
+            return (target.replace(/\/$/, "") + importPath.replace(exports.relativePathRE, "/"));
+        }
+    }
+    return importPath;
+}
+exports.rewriteImportPath = rewriteImportPath;
+function starToRegExp(star) {
+    const r = ["^"];
+    for (let i = 0; i < star.length; i++) {
+        switch (star[i]) {
+            case "*":
+                if (star[i + 1] === "*" && star[i + 2] === "/") {
+                    i += 2;
+                    r.push("([^\\/]+\\/)*");
+                    break;
+                }
+                r.push("[^\\/]*");
+                break;
+            case ".":
+            case "+":
+            case "?":
+            case "^":
+            case "$":
+            case "{":
+            case "}":
+            case "(":
+            case ")":
+            case "|":
+            case "[":
+            case "]":
+            case "\\":
+                r.push("\\", star[i]);
+                break;
+            default:
+                r.push(star[i]);
+                break;
+        }
+    }
+    r.push("$");
+    return new RegExp(r.join(""));
+}
+/**
+ * Returns the import path for files generated by the base type generator
+ * protoc-gen-es.
+ */
+function makeImportPath(file, bootstrapWkt, filesToGenerate) {
+    // Well-known types are published with the runtime package. We usually want
+    // the generated code to import them from the runtime package, with the
+    // following exceptions:
+    // 1. We are bootstrapping the runtime package via the plugin option
+    //    "bootstrap_wkt". In that case, we cannot refer to the runtime package
+    //    itself.
+    // 2. We were explicitly asked to generate the well-known type.
+    if (!bootstrapWkt &&
+        !filesToGenerate.includes(file) &&
+        protobuf_1.codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
+        return protobuf_1.codegenInfo.packageName;
+    }
+    return "./" + file.name + "_pb.js";
+}
+exports.makeImportPath = makeImportPath;
+exports.relativePathRE = /^\.{1,2}\//;
+/**
+ * Derives an ECMAScript module import path from a file path. For example,
+ * the path `foo/bar.ts` is transformed into `./foo/bar.js`.
+ */
+function deriveImportPath(filename) {
+    let importPath = filename.replace(/\.(js|ts|d.ts)$/, ".js");
+    if (!exports.relativePathRE.test(importPath)) {
+        importPath = "./" + importPath;
+    }
+    return importPath;
+}
+exports.deriveImportPath = deriveImportPath;
+/**
+ * Makes an import path relative to the file importing it. For example,
+ * consider the following files:
+ * - foo/foo.js
+ * - baz.js
+ * If foo.js wants to import baz.js, we return ../baz.js
+ */
+function makeImportPathRelative(importer, importPath) {
+    if (!exports.relativePathRE.test(importPath)) {
+        // We don't touch absolute imports, like @bufbuild/protobuf
+        return importPath;
+    }
+    let a = importer
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0)
+        .slice(0, -1);
+    let b = importPath
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0);
+    let matchingPartCount = 0;
+    for (let l = Math.min(a.length, b.length); matchingPartCount < l; matchingPartCount++) {
+        if (a[matchingPartCount] !== b[matchingPartCount]) {
+            break;
+        }
+    }
+    a = a.slice(matchingPartCount);
+    b = b.slice(matchingPartCount);
+    const c = a
+        .map(() => "..")
+        .concat(b)
+        .join("/");
+    return exports.relativePathRE.test(c) ? c : "./" + c;
+}
+exports.makeImportPathRelative = makeImportPathRelative;

package/dist/cjs/ecmascript/schema.js

@@ -18,13 +18,14 @@ const protobuf_1 = require("@bufbuild/protobuf");
 const generated_file_js_1 = require("./generated-file.js");
 const runtime_imports_js_1 = require("./runtime-imports.js");
 const import_symbol_js_1 = require("./import-symbol.js");
-function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt) {
+const import_path_js_1 = require("./import-path.js");
+function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports) {
     const descriptorSet = (0, protobuf_1.createDescriptorSet)(request.protoFile);
     const filesToGenerate = findFilesToGenerate(descriptorSet, request);
     const runtime = (0, runtime_imports_js_1.createRuntimeImports)(bootstrapWkt);
     const createTypeImport = (desc) => {
         const name = protobuf_1.codegenInfo.localName(desc);
-        const from = makeImportPath(desc.file, bootstrapWkt, filesToGenerate);
+        const from = (0, import_path_js_1.rewriteImportPath)((0, import_path_js_1.makeImportPath)(desc.file, bootstrapWkt, filesToGenerate), rewriteImports);
         return (0, import_symbol_js_1.createImportSymbol)(name, from);
     };
     const generatedFiles = [];
@@ -35,7 +36,8 @@ function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bo
         files: filesToGenerate,
         allFiles: descriptorSet.files,
         generateFile(name) {
-            const genFile = (0, generated_file_js_1.createGeneratedFile)(name, createTypeImport, runtime, {
+            const importPath = (0, import_path_js_1.rewriteImportPath)((0, import_path_js_1.deriveImportPath)(name), rewriteImports);
+            const genFile = (0, generated_file_js_1.createGeneratedFile)(name, importPath, createTypeImport, runtime, {
                 pluginName,
                 pluginVersion,
                 parameter: request.parameter,
@@ -63,22 +65,3 @@ function findFilesToGenerate(descriptorSet, request) {
     }
     return descriptorSet.files.filter((file) => request.fileToGenerate.includes(file.name + ".proto"));
 }
-/**
- * Returns the import path for files generated by the base type generator
- * protoc-gen-es.
- */
-function makeImportPath(file, bootstrapWkt, filesToGenerate) {
-    // Well-known types are published with the runtime package. We usually want
-    // the generated code to import them from the runtime package, with the
-    // following exceptions:
-    // 1. We are bootstrapping the runtime package via the plugin option
-    //    "bootstrap_wkt". In that case, we cannot refer to the runtime package
-    //    itself.
-    // 2. We were explicitly asked to generate the well-known type.
-    if (!bootstrapWkt &&
-        !filesToGenerate.includes(file) &&
-        protobuf_1.codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
-        return protobuf_1.codegenInfo.packageName;
-    }
-    return "./" + file.name + "_pb.js";
-}

package/dist/esm/create-es-plugin.js

@@ -24,8 +24,8 @@ export function createEcmaScriptPlugin(init, generateFn) {
         name: init.name,
         version: init.version,
         run(req) {
-            const { targets, tsNocheck, bootstrapWkt } = parseParameter(req.parameter, init.parseOption);
-            const { schema, toResponse } = createSchema(req, targets, init.name, init.version, tsNocheck, bootstrapWkt);
+            const { targets, tsNocheck, bootstrapWkt, rewriteImports } = parseParameter(req.parameter, init.parseOption);
+            const { schema, toResponse } = createSchema(req, targets, init.name, init.version, tsNocheck, bootstrapWkt, rewriteImports);
             generateFn(schema);
             const res = new CodeGeneratorResponse();
             toResponse(res);
@@ -37,6 +37,7 @@ function parseParameter(parameter, parseOption) {
     let targets = ["js", "dts"];
     let tsNocheck = true;
     let bootstrapWkt = false;
+    const rewriteImports = [];
     for (const { key, value } of splitParameter(parameter)) {
         switch (key) {
             case "target":
@@ -84,6 +85,15 @@ function parseParameter(parameter, parseOption) {
                         throw new PluginOptionError(`${key}=${value}`);
                 }
                 break;
+            case "rewrite_imports": {
+                const parts = value.split(":");
+                if (parts.length !== 2) {
+                    throw new PluginOptionError(`${key}=${value}`, "must be in the form of <pattern>:<target>");
+                }
+                const [pattern, target] = parts;
+                rewriteImports.push({ pattern, target });
+                break;
+            }
             default:
                 if (parseOption === undefined) {
                     throw new PluginOptionError(`${key}=${value}`);
@@ -97,7 +107,7 @@ function parseParameter(parameter, parseOption) {
                 break;
         }
     }
-    return { targets, tsNocheck, bootstrapWkt };
+    return { targets, tsNocheck, bootstrapWkt, rewriteImports };
 }
 function splitParameter(parameter) {
     if (parameter == undefined) {

package/dist/esm/ecmascript/generated-file.js

@@ -14,8 +14,8 @@
 import { CodeGeneratorResponse_File, } from "@bufbuild/protobuf";
 import { createImportSymbol } from "./import-symbol.js";
 import { literalString, makeFilePreamble } from "./gencommon.js";
-export function createGeneratedFile(name, createTypeImport, runtimeImports, preambleSettings) {
-    const importPath = deriveImportPath(name);
+import { makeImportPathRelative } from "./import-path.js";
+export function createGeneratedFile(name, importPath, createTypeImport, runtimeImports, preambleSettings) {
     let preamble;
     const el = [];
     return {
@@ -51,16 +51,6 @@ export function createGeneratedFile(name, createTypeImport, runtimeImports, prea
         },
     };
 }
-const importPathExtension = ".js";
-const knownExtensionsRE = /\.(js|ts|d.ts)$/;
-const relativePathRE = /^\.{1,2}\//;
-function deriveImportPath(filename) {
-    let importPath = filename.replace(knownExtensionsRE, importPathExtension);
-    if (!relativePathRE.test(importPath)) {
-        importPath = "./" + importPath;
-    }
-    return importPath;
-}
 function elToContent(el, importerPath) {
     const c = [];
     const symbolToIdentifier = processImports(el, importerPath, (typeOnly, from, names) => {
@@ -227,39 +217,6 @@ function processImports(el, importerPath, makeImportStatement) {
     }
     return symbolToIdentifier;
 }
-// makeImportPathRelative makes an import path relative to the file importing
-// it. For example, consider the following files:
-// - foo/foo.js
-// - baz.js
-// If foo.js wants to import baz.js, we return ../baz.js
-function makeImportPathRelative(importer, importPath) {
-    if (!relativePathRE.test(importPath)) {
-        // We don't touch absolute imports, like @bufbuild/protobuf
-        return importPath;
-    }
-    let a = importer
-        .replace(/^\.\//, "")
-        .split("/")
-        .filter((p) => p.length > 0)
-        .slice(0, -1);
-    let b = importPath
-        .replace(/^\.\//, "")
-        .split("/")
-        .filter((p) => p.length > 0);
-    let matchingPartCount = 0;
-    for (let l = Math.min(a.length, b.length); matchingPartCount < l; matchingPartCount++) {
-        if (a[matchingPartCount] !== b[matchingPartCount]) {
-            break;
-        }
-    }
-    a = a.slice(matchingPartCount);
-    b = b.slice(matchingPartCount);
-    const c = a
-        .map(() => "..")
-        .concat(b)
-        .join("/");
-    return relativePathRE.test(c) ? c : "./" + c;
-}
 function literalNumber(value) {
     if (Number.isNaN(value)) {
         return "globalThis.Number.NaN";

package/dist/esm/ecmascript/import-path.js

@@ -0,0 +1,137 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { codegenInfo } from "@bufbuild/protobuf";
+const cache = new WeakMap();
+/**
+ * Apply import rewrites to the given path.
+ */
+export function rewriteImportPath(importPath, rewriteImports) {
+    let ri = cache.get(rewriteImports);
+    if (ri === undefined) {
+        ri = rewriteImports.map(({ pattern, target }) => {
+            return {
+                pattern: starToRegExp(pattern),
+                target,
+            };
+        });
+        cache.set(rewriteImports, ri);
+    }
+    for (const { pattern, target } of ri) {
+        if (pattern.test(importPath)) {
+            return (target.replace(/\/$/, "") + importPath.replace(relativePathRE, "/"));
+        }
+    }
+    return importPath;
+}
+function starToRegExp(star) {
+    const r = ["^"];
+    for (let i = 0; i < star.length; i++) {
+        switch (star[i]) {
+            case "*":
+                if (star[i + 1] === "*" && star[i + 2] === "/") {
+                    i += 2;
+                    r.push("([^\\/]+\\/)*");
+                    break;
+                }
+                r.push("[^\\/]*");
+                break;
+            case ".":
+            case "+":
+            case "?":
+            case "^":
+            case "$":
+            case "{":
+            case "}":
+            case "(":
+            case ")":
+            case "|":
+            case "[":
+            case "]":
+            case "\\":
+                r.push("\\", star[i]);
+                break;
+            default:
+                r.push(star[i]);
+                break;
+        }
+    }
+    r.push("$");
+    return new RegExp(r.join(""));
+}
+/**
+ * Returns the import path for files generated by the base type generator
+ * protoc-gen-es.
+ */
+export function makeImportPath(file, bootstrapWkt, filesToGenerate) {
+    // Well-known types are published with the runtime package. We usually want
+    // the generated code to import them from the runtime package, with the
+    // following exceptions:
+    // 1. We are bootstrapping the runtime package via the plugin option
+    //    "bootstrap_wkt". In that case, we cannot refer to the runtime package
+    //    itself.
+    // 2. We were explicitly asked to generate the well-known type.
+    if (!bootstrapWkt &&
+        !filesToGenerate.includes(file) &&
+        codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
+        return codegenInfo.packageName;
+    }
+    return "./" + file.name + "_pb.js";
+}
+export const relativePathRE = /^\.{1,2}\//;
+/**
+ * Derives an ECMAScript module import path from a file path. For example,
+ * the path `foo/bar.ts` is transformed into `./foo/bar.js`.
+ */
+export function deriveImportPath(filename) {
+    let importPath = filename.replace(/\.(js|ts|d.ts)$/, ".js");
+    if (!relativePathRE.test(importPath)) {
+        importPath = "./" + importPath;
+    }
+    return importPath;
+}
+/**
+ * Makes an import path relative to the file importing it. For example,
+ * consider the following files:
+ * - foo/foo.js
+ * - baz.js
+ * If foo.js wants to import baz.js, we return ../baz.js
+ */
+export function makeImportPathRelative(importer, importPath) {
+    if (!relativePathRE.test(importPath)) {
+        // We don't touch absolute imports, like @bufbuild/protobuf
+        return importPath;
+    }
+    let a = importer
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0)
+        .slice(0, -1);
+    let b = importPath
+        .replace(/^\.\//, "")
+        .split("/")
+        .filter((p) => p.length > 0);
+    let matchingPartCount = 0;
+    for (let l = Math.min(a.length, b.length); matchingPartCount < l; matchingPartCount++) {
+        if (a[matchingPartCount] !== b[matchingPartCount]) {
+            break;
+        }
+    }
+    a = a.slice(matchingPartCount);
+    b = b.slice(matchingPartCount);
+    const c = a
+        .map(() => "..")
+        .concat(b)
+        .join("/");
+    return relativePathRE.test(c) ? c : "./" + c;
+}

package/dist/esm/ecmascript/schema.js

@@ -15,13 +15,14 @@ import { codegenInfo, CodeGeneratorResponse_Feature, createDescriptorSet, protoI
 import { createGeneratedFile } from "./generated-file.js";
 import { createRuntimeImports } from "./runtime-imports.js";
 import { createImportSymbol } from "./import-symbol.js";
-export function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt) {
+import { deriveImportPath, makeImportPath, rewriteImportPath, } from "./import-path.js";
+export function createSchema(request, targets, pluginName, pluginVersion, tsNocheck, bootstrapWkt, rewriteImports) {
     const descriptorSet = createDescriptorSet(request.protoFile);
     const filesToGenerate = findFilesToGenerate(descriptorSet, request);
     const runtime = createRuntimeImports(bootstrapWkt);
     const createTypeImport = (desc) => {
         const name = codegenInfo.localName(desc);
-        const from = makeImportPath(desc.file, bootstrapWkt, filesToGenerate);
+        const from = rewriteImportPath(makeImportPath(desc.file, bootstrapWkt, filesToGenerate), rewriteImports);
         return createImportSymbol(name, from);
     };
     const generatedFiles = [];
@@ -32,7 +33,8 @@ export function createSchema(request, targets, pluginName, pluginVersion, tsNoch
         files: filesToGenerate,
         allFiles: descriptorSet.files,
         generateFile(name) {
-            const genFile = createGeneratedFile(name, createTypeImport, runtime, {
+            const importPath = rewriteImportPath(deriveImportPath(name), rewriteImports);
+            const genFile = createGeneratedFile(name, importPath, createTypeImport, runtime, {
                 pluginName,
                 pluginVersion,
                 parameter: request.parameter,
@@ -59,22 +61,3 @@ function findFilesToGenerate(descriptorSet, request) {
     }
     return descriptorSet.files.filter((file) => request.fileToGenerate.includes(file.name + ".proto"));
 }
-/**
- * Returns the import path for files generated by the base type generator
- * protoc-gen-es.
- */
-function makeImportPath(file, bootstrapWkt, filesToGenerate) {
-    // Well-known types are published with the runtime package. We usually want
-    // the generated code to import them from the runtime package, with the
-    // following exceptions:
-    // 1. We are bootstrapping the runtime package via the plugin option
-    //    "bootstrap_wkt". In that case, we cannot refer to the runtime package
-    //    itself.
-    // 2. We were explicitly asked to generate the well-known type.
-    if (!bootstrapWkt &&
-        !filesToGenerate.includes(file) &&
-        codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
-        return codegenInfo.packageName;
-    }
-    return "./" + file.name + "_pb.js";
-}

package/dist/types/ecmascript/generated-file.d.ts

@@ -1,7 +1,7 @@
 import type { DescEnum, DescFile, DescMessage } from "@bufbuild/protobuf";
 import { CodeGeneratorResponse } from "@bufbuild/protobuf";
 import type { ImportSymbol } from "./import-symbol.js";
-import type { RuntimeImports } from "./runtime-imports";
+import type { RuntimeImports } from "./runtime-imports.js";
 /**
  * All types that can be passed to GeneratedFile.print()
  */
@@ -54,7 +54,7 @@ export interface GenerateFileToResponse {
     toResponse(res: CodeGeneratorResponse): void;
 }
 declare type CreateTypeImportFn = (desc: DescMessage | DescEnum) => ImportSymbol;
-export declare function createGeneratedFile(name: string, createTypeImport: CreateTypeImportFn, runtimeImports: RuntimeImports, preambleSettings: {
+export declare function createGeneratedFile(name: string, importPath: string, createTypeImport: CreateTypeImportFn, runtimeImports: RuntimeImports, preambleSettings: {
     pluginName: string;
     pluginVersion: string;
     parameter: string | undefined;

package/dist/types/ecmascript/import-path.d.ts

@@ -0,0 +1,64 @@
+import { DescFile } from "@bufbuild/protobuf";
+/**
+ * A configuration for rewriting import paths, a feature mainly used for
+ * remote code generation in the BSR npm registry, which makes it possible
+ * to serve the output of a BSR module and a plugin in an individual package.
+ *
+ * All plugins based on @bufbuild/protoplugin support the option
+ * "rewrite_imports", which is parsed into this type. The option can be given
+ * multiple times, in the form of `rewrite_imports=<pattern>:<target>`.
+ *
+ * The pattern is a very reduced subset of glob:
+ * - `*` matches zero or more characters except `/`.
+ * - `**` matches zero or more path elements, where an element is one or more
+ *   characters with a trailing `/`.
+ *
+ * The target is typically a npm package name, for example `@scope/pkg`.
+ *
+ * If any generated file imports from a path matching one of the patterns, the
+ * import path is rewritten to the corresponding target, by prepending the
+ * target to the import path (after replacing any leading ./ or ../ from the
+ * import path with / first).
+ *
+ * Note that the pattern is matched against the import path before it is made
+ * relative to the file importing it. The first matching pattern wins.
+ *
+ * For example, the pattern `./foo/**\/*_pb.js` (escaped for block comment!)
+ * matches:
+ * - ./foo/bar_pb.js
+ * - ./foo/bar/baz_pb.js
+ *
+ * But neither of:
+ * - ./bar_pb.js
+ * - ./foo/bar_xx.js
+ *
+ * With the target `@scope/pkg`, the import path `./foo/bar_pb.js` is
+ * transformed to `@scope/pkg/foo/bar_pb.js`.
+ */
+export declare type RewriteImports = {
+    pattern: string;
+    target: string;
+}[];
+/**
+ * Apply import rewrites to the given path.
+ */
+export declare function rewriteImportPath(importPath: string, rewriteImports: RewriteImports): string;
+/**
+ * Returns the import path for files generated by the base type generator
+ * protoc-gen-es.
+ */
+export declare function makeImportPath(file: DescFile, bootstrapWkt: boolean, filesToGenerate: DescFile[]): string;
+export declare const relativePathRE: RegExp;
+/**
+ * Derives an ECMAScript module import path from a file path. For example,
+ * the path `foo/bar.ts` is transformed into `./foo/bar.js`.
+ */
+export declare function deriveImportPath(filename: string): string;
+/**
+ * Makes an import path relative to the file importing it. For example,
+ * consider the following files:
+ * - foo/foo.js
+ * - baz.js
+ * If foo.js wants to import baz.js, we return ../baz.js
+ */
+export declare function makeImportPathRelative(importer: string, importPath: string): string;

package/dist/types/ecmascript/schema.d.ts

@@ -2,7 +2,8 @@ import type { CodeGeneratorRequest, DescFile } from "@bufbuild/protobuf";
 import { CodeGeneratorResponse } from "@bufbuild/protobuf";
 import type { GeneratedFile } from "./generated-file.js";
 import { RuntimeImports } from "./runtime-imports.js";
-import type { Target } from "./target";
+import type { Target } from "./target.js";
+import { RewriteImports } from "./import-path.js";
 /**
  * Schema describes the files and types that the plugin is requested to
  * generate.
@@ -37,5 +38,5 @@ interface SchemaController {
     schema: Schema;
     toResponse: (res: CodeGeneratorResponse) => void;
 }
-export declare function createSchema(request: CodeGeneratorRequest, targets: Target[], pluginName: string, pluginVersion: string, tsNocheck: boolean, bootstrapWkt: boolean): SchemaController;
+export declare function createSchema(request: CodeGeneratorRequest, targets: Target[], pluginName: string, pluginVersion: string, tsNocheck: boolean, bootstrapWkt: boolean, rewriteImports: RewriteImports): SchemaController;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protoplugin",
-  "version": "0.0.10",
+  "version": "0.1.0",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "Helps to create your own Protocol Buffers code generators.",
   "repository": {
@@ -12,20 +12,18 @@
   "scripts": {
     "clean": "rm -rf ./dist/cjs/* ./dist/esm/* ./dist/types/*",
     "build": "npm run build:cjs && npm run build:esm+types",
-    "build:cjs": "npx tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
-    "build:esm+types": "npx tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
+    "build:cjs": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm+types": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
   },
   "type": "module",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
-      "default": "./dist/esm/index.js"
+      "require": "./dist/cjs/index.js"
     },
     "./ecmascript": {
       "import": "./dist/esm/ecmascript/index.js",
-      "require": "./dist/cjs/ecmascript/index.js",
-      "default": "./dist/esm/ecmascript/index.js"
+      "require": "./dist/cjs/ecmascript/index.js"
     }
   },
   "types": "./dist/types/index.d.ts",
@@ -37,7 +35,7 @@
     }
   },
   "dependencies": {
-    "@bufbuild/protobuf": "0.0.10"
+    "@bufbuild/protobuf": "0.1.0"
   },
   "devDependencies": {
     "typescript": "^4.7.4"