@aptre/protobuf-es-lite 0.2.7 → 0.2.9

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

@@ -0,0 +1,407 @@
+"use strict";
+// Copyright 2021-2024 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.createGeneratedFile = void 0;
+const import_symbol_js_1 = require("./import-symbol.js");
+const import_path_js_1 = require("./import-path.js");
+const jsdoc_js_1 = require("./jsdoc.js");
+const proto_int64_js_1 = require("../../proto-int64.js");
+const scalar_js_1 = require("../../scalar.js");
+function createGeneratedFile(name, importPath, jsImportStyle, rewriteImportPath, createTypeImport, runtimeImports, createPreamble) {
+    let preamble;
+    const el = [];
+    return {
+        preamble(file) {
+            preamble = createPreamble(file);
+        },
+        print(printableOrFragments, ...rest) {
+            let printables;
+            if (printableOrFragments != null &&
+                Object.prototype.hasOwnProperty.call(printableOrFragments, "raw")) {
+                // If called with a tagged template literal
+                printables = buildPrintablesFromFragments(printableOrFragments, rest);
+            }
+            else {
+                // If called with just an array of Printables
+                printables =
+                    printableOrFragments != null ?
+                        [printableOrFragments, ...rest]
+                        : rest;
+            }
+            printableToEl(printables, el, createTypeImport, runtimeImports);
+            el.push("\n");
+        },
+        export(name) {
+            return (0, import_symbol_js_1.createImportSymbol)(name, importPath);
+        },
+        exportDecl(declaration, name) {
+            return {
+                kind: "es_export_decl",
+                declaration,
+                name,
+            };
+        },
+        string(string) {
+            // We do not use LiteralString, which was added later, to maintain backwards compatibility
+            return escapeString(string);
+        },
+        jsDoc(textOrDesc, indentation) {
+            return (0, jsdoc_js_1.createJsDocBlock)(textOrDesc, indentation);
+        },
+        import(typeOrName, from) {
+            if (typeof typeOrName == "string") {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return (0, import_symbol_js_1.createImportSymbol)(typeOrName, from);
+            }
+            return createTypeImport(typeOrName);
+        },
+        jsImportStyle,
+        getFileInfo() {
+            return {
+                name,
+                content: elToContent(el, importPath, rewriteImportPath, jsImportStyle == "legacy_commonjs"),
+                preamble,
+            };
+        },
+    };
+}
+exports.createGeneratedFile = createGeneratedFile;
+function elToContent(el, importerPath, rewriteImportPath, legacyCommonJs) {
+    if (el.length == 0) {
+        return "";
+    }
+    const c = [];
+    if (legacyCommonJs) {
+        c.push(`"use strict";\n`);
+        c.push(`Object.defineProperty(exports, "__esModule", { value: true });\n`);
+        c.push(`\n`);
+    }
+    const symbolToIdentifier = processImports(el, importerPath, rewriteImportPath, (typeOnly, from, names) => {
+        if (legacyCommonJs) {
+            const p = names.map(({ name, alias }) => alias == undefined ? name : `${name}: ${alias}`);
+            const what = `{ ${p.join(", ")} }`;
+            c.push(`const ${what} = require(${escapeString(from)});\n`);
+        }
+        else {
+            const p = names.map(({ name, alias }) => alias == undefined ? name : `${name} as ${alias}`);
+            const what = `{ ${p.join(", ")} }`;
+            if (typeOnly) {
+                c.push(`import type ${what} from ${escapeString(from)};\n`);
+            }
+            else {
+                c.push(`import ${what} from ${escapeString(from)};\n`);
+            }
+        }
+    });
+    if (c.length > 0) {
+        c.push("\n");
+    }
+    const legacyCommonJsExportNames = [];
+    for (const e of el) {
+        if (typeof e == "string") {
+            c.push(e);
+        }
+        else {
+            switch (e.kind) {
+                case "es_symbol": {
+                    const ident = symbolToIdentifier.get(e.id);
+                    if (ident != undefined) {
+                        c.push(ident);
+                    }
+                    break;
+                }
+                case "es_export_stmt":
+                    if (legacyCommonJs) {
+                        legacyCommonJsExportNames.push(e.name);
+                    }
+                    else {
+                        c.push("export ");
+                    }
+                    if (e.declaration !== undefined && e.declaration.length > 0) {
+                        c.push(e.declaration, " ");
+                    }
+                    c.push(e.name);
+                    break;
+            }
+        }
+    }
+    if (legacyCommonJs) {
+        if (legacyCommonJsExportNames.length > 0) {
+            c.push(`\n`);
+        }
+        for (const name of legacyCommonJsExportNames) {
+            c.push(`exports.`, name, " = ", name, ";\n");
+        }
+    }
+    return c.join("");
+}
+function printableToEl(printables, el, createTypeImport, runtimeImports) {
+    for (const p of printables) {
+        if (Array.isArray(p)) {
+            printableToEl(p, el, createTypeImport, runtimeImports);
+        }
+        else {
+            switch (typeof p) {
+                case "string":
+                    el.push(p);
+                    break;
+                case "number":
+                    elNumber(el, p, runtimeImports);
+                    break;
+                case "boolean":
+                    el.push(p.toString());
+                    break;
+                case "bigint":
+                    elBigint(el, p, runtimeImports);
+                    break;
+                case "object":
+                    if (p instanceof Uint8Array) {
+                        elUint8Array(el, p);
+                        break;
+                    }
+                    switch (p.kind) {
+                        case "es_symbol":
+                            el.push(p);
+                            break;
+                        case "es_jsdoc":
+                            el.push(p.toString());
+                            break;
+                        case "es_string":
+                            el.push(escapeString(p.value));
+                            break;
+                        case "es_proto_int64":
+                            elProtoInt64(el, p, runtimeImports);
+                            break;
+                        case "es_export_decl":
+                            el.push({
+                                kind: "es_export_stmt",
+                                declaration: p.declaration,
+                                name: typeof p.name == "string" ?
+                                    p.name
+                                    : createTypeImport(p.name).name,
+                            });
+                            break;
+                        case "es_ref_message":
+                        case "es_ref_enum":
+                            el.push(p.typeOnly ?
+                                createTypeImport(p.type).toTypeOnly()
+                                : createTypeImport(p.type));
+                            break;
+                        case "message":
+                        case "extension":
+                        case "enum":
+                            el.push(createTypeImport(p));
+                            break;
+                    }
+                    break;
+                default:
+                    throw `cannot print ${typeof p}`;
+            }
+        }
+    }
+}
+function buildPrintablesFromFragments(fragments, values) {
+    const printables = [];
+    fragments.forEach((fragment, i) => {
+        printables.push(fragment);
+        if (fragments.length - 1 !== i) {
+            printables.push(values[i]);
+        }
+    });
+    return printables;
+}
+function processImports(el, importerPath, rewriteImportPath, makeImportStatement) {
+    // identifiers to use in the output
+    const symbolToIdentifier = new Map();
+    // symbols that need a value import (as opposed to a type-only import)
+    const symbolToIsValue = new Map();
+    // taken in this file
+    const identifiersTaken = new Set();
+    // foreign symbols need an import
+    const foreignSymbols = [];
+    // Walk through all symbols used and populate the collections above.
+    for (const s of el) {
+        if (typeof s != "object") {
+            continue;
+        }
+        switch (s.kind) {
+            case "es_symbol":
+                symbolToIdentifier.set(s.id, s.name);
+                if (!s.typeOnly) {
+                    // a symbol is only type-imported as long as all uses are type-only
+                    symbolToIsValue.set(s.id, true);
+                }
+                if (s.from === importerPath) {
+                    identifiersTaken.add(s.name);
+                }
+                else {
+                    foreignSymbols.push(s);
+                }
+                break;
+            case "es_export_stmt":
+                identifiersTaken.add(s.name);
+                break;
+        }
+    }
+    // Walk through all foreign symbols and make their identifiers unique.
+    const handledSymbols = new Set();
+    for (const s of foreignSymbols) {
+        if (handledSymbols.has(s.id)) {
+            continue;
+        }
+        handledSymbols.add(s.id);
+        if (!identifiersTaken.has(s.name)) {
+            identifiersTaken.add(s.name);
+            continue;
+        }
+        let i = 1;
+        let alias;
+        for (;;) {
+            // We choose '$' because it is invalid in proto identifiers.
+            alias = `${s.name}$${i}`;
+            if (!identifiersTaken.has(alias)) {
+                break;
+            }
+            i++;
+        }
+        identifiersTaken.add(alias);
+        symbolToIdentifier.set(s.id, alias);
+    }
+    const sourceToImport = new Map();
+    for (const s of foreignSymbols) {
+        let i = sourceToImport.get(s.from);
+        if (i == undefined) {
+            i = {
+                types: new Map(),
+                values: new Map(),
+            };
+            sourceToImport.set(s.from, i);
+        }
+        let alias = symbolToIdentifier.get(s.id);
+        if (alias == s.name) {
+            alias = undefined;
+        }
+        if (symbolToIsValue.get(s.id)) {
+            i.values.set(s.name, alias);
+        }
+        else {
+            i.types.set(s.name, alias);
+        }
+    }
+    // Make import statements.
+    const handledSource = new Set();
+    const buildNames = (map) => {
+        const names = [];
+        map.forEach((value, key) => names.push({ name: key, alias: value }));
+        names.sort((a, b) => a.name.localeCompare(b.name));
+        return names;
+    };
+    for (const s of foreignSymbols) {
+        if (handledSource.has(s.from)) {
+            continue;
+        }
+        handledSource.add(s.from);
+        const i = sourceToImport.get(s.from);
+        if (i == undefined) {
+            // should never happen
+            continue;
+        }
+        const from = (0, import_path_js_1.makeImportPathRelative)(importerPath, rewriteImportPath(s.from));
+        if (i.types.size > 0) {
+            makeImportStatement(true, from, buildNames(i.types));
+        }
+        if (i.values.size > 0) {
+            makeImportStatement(false, from, buildNames(i.values));
+        }
+    }
+    return symbolToIdentifier;
+}
+function elBigint(el, value, runtimeImports) {
+    if (value == proto_int64_js_1.protoInt64.zero) {
+        // Loose comparison will match between 0n and 0.
+        el.push(runtimeImports.protoInt64, ".zero");
+    }
+    else {
+        el.push(runtimeImports.protoInt64, value > 0 ? ".uParse(" : ".parse(", escapeString(value.toString()), ")");
+    }
+}
+function elNumber(el, value, runtimeImports) {
+    if (Number.isNaN(value)) {
+        el.push(runtimeImports.protoDouble, ".NaN");
+    }
+    else if (value === Number.POSITIVE_INFINITY) {
+        el.push(runtimeImports.protoDouble, ".POSITIVE_INFINITY");
+    }
+    else if (value === Number.NEGATIVE_INFINITY) {
+        el.push(runtimeImports.protoDouble, ".NEGATIVE_INFINITY");
+    }
+    else {
+        el.push(value.toString(10));
+    }
+}
+function elUint8Array(el, value) {
+    if (value.length === 0) {
+        el.push("new Uint8Array(0)");
+        return;
+    }
+    el.push("new Uint8Array([");
+    const strings = [];
+    for (const n of value) {
+        strings.push("0x" + n.toString(16).toUpperCase().padStart(2, "0"));
+    }
+    el.push(strings.join(", "));
+    el.push("])");
+}
+function elProtoInt64(el, literal, runtimeImports) {
+    switch (literal.longType) {
+        case scalar_js_1.LongType.STRING:
+            el.push(escapeString(literal.value.toString()));
+            break;
+        case scalar_js_1.LongType.BIGINT:
+            if (literal.value == proto_int64_js_1.protoInt64.zero) {
+                // Loose comparison will match between 0n and 0.
+                el.push(runtimeImports.protoInt64, ".zero");
+                break;
+            }
+            switch (literal.type) {
+                case scalar_js_1.ScalarType.UINT64:
+                case scalar_js_1.ScalarType.FIXED64:
+                    el.push(runtimeImports.protoInt64);
+                    el.push(".uParse(");
+                    el.push(escapeString(literal.value.toString()));
+                    el.push(")");
+                    break;
+                default:
+                    el.push(runtimeImports.protoInt64);
+                    el.push(".parse(");
+                    el.push(escapeString(literal.value.toString()));
+                    el.push(")");
+                    break;
+            }
+    }
+}
+function escapeString(value) {
+    return ('"' +
+        value
+            .split("\\")
+            .join("\\\\")
+            .split('"')
+            .join('\\"')
+            .split("\r")
+            .join("\\r")
+            .split("\n")
+            .join("\\n") +
+        '"');
+}

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

@@ -0,0 +1,65 @@
+import { DescFile } from "../../descriptor-set.js";
+/**
+ * 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 type RewriteImports = {
+    pattern: string;
+    target: string;
+}[];
+/**
+ * Apply import rewrites to the given import path, and change all .js extensions
+ * to the given import extension.
+ */
+export declare function rewriteImportPath(importPath: string, rewriteImports: RewriteImports, importExtension: string): 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/protoplugin/ecmascript/import-path.js

@@ -0,0 +1,156 @@
+"use strict";
+// Copyright 2021-2024 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 codegen_info_js_1 = require("../../codegen-info.js");
+const cache = new WeakMap();
+/**
+ * Apply import rewrites to the given import path, and change all .js extensions
+ * to the given import extension.
+ */
+function rewriteImportPath(importPath, rewriteImports, importExtension) {
+    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)) {
+            if (exports.relativePathRE.test(importPath)) {
+                importPath =
+                    target.replace(/\/$/, "") + importPath.replace(exports.relativePathRE, "/");
+            }
+            else {
+                importPath = target;
+            }
+            break;
+        }
+    }
+    if (importExtension != ".js" && importPath.endsWith(".js")) {
+        importPath =
+            importPath.substring(0, importPath.length - 3) + importExtension;
+    }
+    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) &&
+        codegen_info_js_1.codegenInfo.wktSourceFiles.includes(file.name + ".proto")) {
+        return codegen_info_js_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
+        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/protoplugin/ecmascript/import-symbol.d.ts

@@ -0,0 +1,39 @@
+/**
+ * An import symbol represents an ECMAScript import.
+ */
+export type ImportSymbol = {
+    readonly kind: "es_symbol";
+    /**
+     * The name to import.
+     */
+    readonly name: string;
+    /**
+     * The import path.
+     *
+     * The path can point to a package, for example `@foo/bar/baz.js`, or
+     * to a file, for example `./bar/baz.js`.
+     *
+     * Note that while paths to a file begin with a `./`, they must be
+     * relative to the project root.
+     */
+    readonly from: string;
+    /**
+     * Whether this is a type-only import - an import that only exists in
+     * TypeScript.
+     */
+    readonly typeOnly: boolean;
+    /**
+     * Create a copy of this import, and make it type-only for TypeScript.
+     */
+    toTypeOnly(): ImportSymbol;
+    /**
+     * The unique ID based on name and from, disregarding typeOnly.
+     */
+    readonly id: EsSymbolId;
+};
+/**
+ * Create a new import symbol.
+ */
+export declare function createImportSymbol(name: string, from: string, typeOnly?: boolean): ImportSymbol;
+type EsSymbolId = string;
+export {};