@aptre/protobuf-es-lite 0.2.7 → 0.2.8

package/dist/partial.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyPartialMessage = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
+const field_js_1 = require("./field.js");
 const is_message_js_1 = require("./is-message.js");
+const scalar_js_1 = require("./scalar.js");
 // applyPartialMessage applies a partial message to a message.
 function applyPartialMessage(source, target, fields) {
     if (source === undefined) {
@@ -23,16 +24,14 @@ function applyPartialMessage(source, target, fields) {
                 const sourceField = member.findField(sk);
                 let val = s[localName].value;
                 if (sourceField?.kind == "message") {
-                    const messageType = typeof sourceField.T === "function"
-                        ? sourceField.T()
-                        : sourceField.T;
+                    const messageType = (0, field_js_1.resolveMessageType)(sourceField.T);
                     if (!(0, is_message_js_1.isCompleteMessage)(val, messageType.fields.list())) {
                         val = messageType.create(val);
                     }
                 }
                 else if (sourceField &&
                     sourceField.kind === "scalar" &&
-                    sourceField.T === protobuf_1.ScalarType.BYTES) {
+                    sourceField.T === scalar_js_1.ScalarType.BYTES) {
                     val = toU8Arr(val);
                 }
                 t[localName] = { case: sk, value: val };
@@ -40,10 +39,11 @@ function applyPartialMessage(source, target, fields) {
             case "scalar":
             case "enum":
                 let copy = s[localName];
-                if (member.T === protobuf_1.ScalarType.BYTES) {
-                    copy = member.repeated
-                        ? copy.map(toU8Arr)
-                        : toU8Arr(copy);
+                if (member.T === scalar_js_1.ScalarType.BYTES) {
+                    copy =
+                        member.repeated ?
+                            copy.map(toU8Arr)
+                            : toU8Arr(copy);
                 }
                 t[localName] = copy;
                 break;
@@ -51,7 +51,7 @@ function applyPartialMessage(source, target, fields) {
                 switch (member.V.kind) {
                     case "scalar":
                     case "enum":
-                        if (member.V.T === protobuf_1.ScalarType.BYTES) {
+                        if (member.V.T === scalar_js_1.ScalarType.BYTES) {
                             for (const [k, v] of Object.entries(s[localName])) {
                                 t[localName][k] = toU8Arr(v);
                             }
@@ -61,7 +61,7 @@ function applyPartialMessage(source, target, fields) {
                         }
                         break;
                     case "message":
-                        const messageType = typeof member.V.T === "function" ? member.V.T() : member.V.T;
+                        const messageType = (0, field_js_1.resolveMessageType)(member.V.T);
                         for (const k of Object.keys(s[localName])) {
                             let val = s[localName][k];
                             if (!messageType.fieldWrapper) {
@@ -75,7 +75,7 @@ function applyPartialMessage(source, target, fields) {
                 }
                 break;
             case "message":
-                const mt = typeof member.T === "function" ? member.T() : member.T;
+                const mt = (0, field_js_1.resolveMessageType)(member.T);
                 if (member.repeated) {
                     t[localName] = s[localName].map((val) => (0, is_message_js_1.isCompleteMessage)(val, mt.fields.list()) ? val : mt.create(val));
                 }
@@ -93,9 +93,8 @@ function applyPartialMessage(source, target, fields) {
                     }
                     else {
                         const messageType = mt;
-                        t[localName] = (0, is_message_js_1.isCompleteMessage)(val, messageType.fields.list())
-                            ? val
-                            : messageType.create(val);
+                        t[localName] =
+                            (0, is_message_js_1.isCompleteMessage)(val, messageType.fields.list()) ? val : (messageType.create(val));
                     }
                 }
                 break;

package/dist/proto-base64.d.ts

@@ -0,0 +1,18 @@
+export declare const protoBase64: {
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    readonly dec: (base64Str: string) => Uint8Array;
+    /**
+     * Encode a byte array to a base64 string.
+     */
+    readonly enc: (bytes: Uint8Array) => string;
+};

package/dist/proto-base64.js

@@ -0,0 +1,128 @@
+"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.protoBase64 = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
+// lookup table from base64 character to byte
+let encTable = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+// lookup table from base64 character *code* to byte because lookup by number is fast
+let decTable = [];
+for (let i = 0; i < encTable.length; i++)
+    decTable[encTable[i].charCodeAt(0)] = i;
+// support base64url variants
+decTable["-".charCodeAt(0)] = encTable.indexOf("+");
+decTable["_".charCodeAt(0)] = encTable.indexOf("/");
+exports.protoBase64 = {
+    /**
+     * Decodes a base64 string to a byte array.
+     *
+     * - ignores white-space, including line breaks and tabs
+     * - allows inner padding (can decode concatenated base64 strings)
+     * - does not require padding
+     * - understands base64url encoding:
+     *   "-" instead of "+",
+     *   "_" instead of "/",
+     *   no padding
+     */
+    dec(base64Str) {
+        // estimate byte size, not accounting for inner padding and whitespace
+        let es = (base64Str.length * 3) / 4;
+        if (base64Str[base64Str.length - 2] == "=")
+            es -= 2;
+        else if (base64Str[base64Str.length - 1] == "=")
+            es -= 1;
+        let bytes = new Uint8Array(es), bytePos = 0, // position in byte array
+        groupPos = 0, // position in base64 group
+        b, // current byte
+        p = 0; // previous byte
+        for (let i = 0; i < base64Str.length; i++) {
+            b = decTable[base64Str.charCodeAt(i)];
+            if (b === undefined) {
+                switch (base64Str[i]) {
+                    // @ts-ignore TS7029: Fallthrough case in switch
+                    case "=":
+                        groupPos = 0; // reset state when padding found
+                    // @ts-ignore TS7029: Fallthrough case in switch
+                    case "\n":
+                    case "\r":
+                    case "\t":
+                    case " ":
+                        continue; // skip white-space, and padding
+                    default:
+                        throw Error("invalid base64 string.");
+                }
+            }
+            switch (groupPos) {
+                case 0:
+                    p = b;
+                    groupPos = 1;
+                    break;
+                case 1:
+                    bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
+                    p = b;
+                    groupPos = 2;
+                    break;
+                case 2:
+                    bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
+                    p = b;
+                    groupPos = 3;
+                    break;
+                case 3:
+                    bytes[bytePos++] = ((p & 3) << 6) | b;
+                    groupPos = 0;
+                    break;
+            }
+        }
+        if (groupPos == 1)
+            throw Error("invalid base64 string.");
+        return bytes.subarray(0, bytePos);
+    },
+    /**
+     * Encode a byte array to a base64 string.
+     */
+    enc(bytes) {
+        let base64 = "", groupPos = 0, // position in base64 group
+        b, // current byte
+        p = 0; // carry over from previous byte
+        for (let i = 0; i < bytes.length; i++) {
+            b = bytes[i];
+            switch (groupPos) {
+                case 0:
+                    base64 += encTable[b >> 2];
+                    p = (b & 3) << 4;
+                    groupPos = 1;
+                    break;
+                case 1:
+                    base64 += encTable[p | (b >> 4)];
+                    p = (b & 15) << 2;
+                    groupPos = 2;
+                    break;
+                case 2:
+                    base64 += encTable[p | (b >> 6)];
+                    base64 += encTable[b & 63];
+                    groupPos = 0;
+                    break;
+            }
+        }
+        // add output padding
+        if (groupPos) {
+            base64 += encTable[p];
+            base64 += "=";
+            if (groupPos == 1)
+                base64 += "=";
+        }
+        return base64;
+    },
+};

package/dist/proto-double.d.ts

@@ -0,0 +1,5 @@
+export declare const protoDouble: {
+    readonly NaN: number;
+    readonly POSITIVE_INFINITY: number;
+    readonly NEGATIVE_INFINITY: number;
+};

package/dist/proto-double.js

@@ -0,0 +1,29 @@
+"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.protoDouble = void 0;
+// Export global Number constants. This is done so that we can safely use
+// these global constants when generating code and be assured we're using
+// the correct values. We cannot rely on globalThis since we support ES2017
+// and globalThis was introduced in ES2020. We also don't want to explicitly
+// generate code using, for example, Number.NaN, since this could clash with
+// a message name of Number. Instead we can export them here since this will
+// be in a different scope as the generated code and we are guaranteed to use
+// the intended global values.
+exports.protoDouble = {
+    NaN: Number.NaN,
+    POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
+    NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
+};

package/dist/proto-int64.d.ts

@@ -0,0 +1,95 @@
+/**
+ * We use the `bigint` primitive to represent 64-bit integral types. If bigint
+ * is unavailable, we fall back to a string representation, which means that
+ * all values typed as `bigint` will actually be strings.
+ *
+ * If your code is intended to run in an environment where bigint may be
+ * unavailable, it must handle both the bigint and the string representation.
+ * For presenting values, this is straight-forward with implicit or explicit
+ * conversion to string:
+ *
+ * ```ts
+ * let el = document.createElement("span");
+ * el.innerText = message.int64Field; // assuming a protobuf int64 field
+ *
+ * console.log(`int64: ${message.int64Field}`);
+ *
+ * let str: string = message.int64Field.toString();
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values and are sure the values
+ * can be safely represented as an IEEE-754 double precision number, you can
+ * convert to a JavaScript Number:
+ *
+ * ```ts
+ * console.log(message.int64Field.toString())
+ * let num = Number(message.int64Field);
+ * num = num + 1;
+ * message.int64Field = protoInt64.parse(num);
+ * ```
+ *
+ * If you need to manipulate 64-bit integral values that are outside the
+ * range of safe representation as a JavaScript Number, we recommend you
+ * use a third party library, for example the npm package "long":
+ *
+ * ```ts
+ * // convert the field value to a Long
+ * const bits = protoInt64.enc(message.int64Field);
+ * const longValue = Long.fromBits(bits.lo, bits.hi);
+ *
+ * // perform arithmetic
+ * const longResult = longValue.subtract(1);
+ *
+ * // set the result in the field
+ * message.int64Field = protoInt64.dec(longResult.low, longResult.high);
+ *
+ * // Assuming int64Field contains 9223372036854775807:
+ * console.log(message.int64Field); // 9223372036854775806
+ * ```
+ */
+interface Int64Support {
+    /**
+     * 0n if bigint is available, "0" if unavailable.
+     */
+    readonly zero: bigint;
+    /**
+     * Is bigint available?
+     */
+    readonly supported: boolean;
+    /**
+     * Parse a signed 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    parse(value: string | number | bigint): bigint;
+    /**
+     * Parse an unsigned 64-bit integer.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uParse(value: string | number | bigint): bigint;
+    /**
+     * Convert a signed 64-bit integral value to a two's complement.
+     */
+    enc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert an unsigned 64-bit integral value to a two's complement.
+     */
+    uEnc(value: string | number | bigint): {
+        lo: number;
+        hi: number;
+    };
+    /**
+     * Convert a two's complement to a signed 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    dec(lo: number, hi: number): bigint;
+    /**
+     * Convert a two's complement to an unsigned 64-bit integral value.
+     * Returns a bigint if available, a string otherwise.
+     */
+    uDec(lo: number, hi: number): bigint;
+}
+export declare const protoInt64: Int64Support;
+export {};

package/dist/proto-int64.js

@@ -0,0 +1,116 @@
+"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.protoInt64 = void 0;
+const assert_js_1 = require("./assert.js");
+const varint_js_1 = require("./varint.js");
+function makeInt64Support() {
+    const dv = new DataView(new ArrayBuffer(8));
+    // note that Safari 14 implements BigInt, but not the DataView methods
+    const ok = typeof BigInt === "function" &&
+        typeof dv.getBigInt64 === "function" &&
+        typeof dv.getBigUint64 === "function" &&
+        typeof dv.setBigInt64 === "function" &&
+        typeof dv.setBigUint64 === "function" &&
+        (typeof process != "object" ||
+            typeof process.env != "object" ||
+            process.env.BUF_BIGINT_DISABLE !== "1");
+    if (ok) {
+        const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
+        return {
+            zero: BigInt(0),
+            supported: true,
+            parse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > MAX || bi < MIN) {
+                    throw new Error(`int64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            uParse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > UMAX || bi < UMIN) {
+                    throw new Error(`uint64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            enc(value) {
+                dv.setBigInt64(0, this.parse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            uEnc(value) {
+                dv.setBigInt64(0, this.uParse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            dec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigInt64(0, true);
+            },
+            uDec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigUint64(0, true);
+            },
+        };
+    }
+    const assertInt64String = (value) => (0, assert_js_1.assert)(/^-?[0-9]+$/.test(value), `int64 invalid: ${value}`);
+    const assertUInt64String = (value) => (0, assert_js_1.assert)(/^[0-9]+$/.test(value), `uint64 invalid: ${value}`);
+    return {
+        zero: "0",
+        supported: false,
+        parse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return value;
+        },
+        uParse(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return value;
+        },
+        enc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
+        },
+        uEnc(value) {
+            if (typeof value != "string") {
+                value = value.toString();
+            }
+            assertUInt64String(value);
+            return (0, varint_js_1.int64FromString)(value);
+        },
+        dec(lo, hi) {
+            return (0, varint_js_1.int64ToString)(lo, hi);
+        },
+        uDec(lo, hi) {
+            return (0, varint_js_1.uInt64ToString)(lo, hi);
+        },
+    };
+}
+exports.protoInt64 = makeInt64Support();

package/dist/protoc-gen-es-lite/protoc-gen-es-lite-plugin.d.ts

@@ -0,0 +1 @@
+export declare const protocGenEsLite: import("../protoplugin/plugin.js").Plugin;

package/dist/{protoc-gen-es-lite-plugin.js → protoc-gen-es-lite/protoc-gen-es-lite-plugin.js}

@@ -15,10 +15,10 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.protocGenEsLite = void 0;
-const protoplugin_1 = require("@bufbuild/protoplugin");
+const index_js_1 = require("../protoplugin/index.js");
 const typescript_js_1 = require("./typescript.js");
 // import { version } from "../package.json";
-exports.protocGenEsLite = (0, protoplugin_1.createEcmaScriptPlugin)({
+exports.protocGenEsLite = (0, index_js_1.createEcmaScriptPlugin)({
     name: "protoc-gen-es-lite",
     version: `unknown`,
     generateTs: typescript_js_1.generateTs,

package/dist/{typescript.d.ts → protoc-gen-es-lite/typescript.d.ts}

@@ -1,6 +1,7 @@
-import type { DescEnum, DescExtension, DescField, DescFile, DescMessage } from "@bufbuild/protobuf";
-import type { GeneratedFile, ImportSymbol, Printable, Schema } from "@bufbuild/protoplugin/ecmascript";
+import type { GeneratedFile, ImportSymbol, Printable, Schema } from "../protoplugin/ecmascript/index.js";
+import { DescEnum, DescExtension, DescField, DescFile, DescMessage } from "../descriptor-set.js";
 export declare function generateTs(schema: Schema): void;
+export declare function checkSupportedSyntax(file: DescFile): void;
 export declare function makeImportPath(file: DescFile): string;
 export declare function generateFieldInfo(f: GeneratedFile, field: DescField | DescExtension): void;
 export declare const createTypeImport: (desc: DescMessage | DescEnum | DescExtension) => ImportSymbol;