@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.2-alpha.2

package/dist/esm/google/varint.js

@@ -43,34 +43,34 @@
  * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
  */
 export function varint64read() {
-  let lowBits = 0;
-  let highBits = 0;
-  for (let shift = 0; shift < 28; shift += 7) {
-    let b = this.buf[this.pos++];
-    lowBits |= (b & 0x7f) << shift;
-    if ((b & 0x80) == 0) {
-      this.assertBounds();
-      return [lowBits, highBits];
+    let lowBits = 0;
+    let highBits = 0;
+    for (let shift = 0; shift < 28; shift += 7) {
+        let b = this.buf[this.pos++];
+        lowBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
     }
-  }
-  let middleByte = this.buf[this.pos++];
-  // last four bits of the first 32 bit number
-  lowBits |= (middleByte & 0x0f) << 28;
-  // 3 upper bits are part of the next 32 bit number
-  highBits = (middleByte & 0x70) >> 4;
-  if ((middleByte & 0x80) == 0) {
-    this.assertBounds();
-    return [lowBits, highBits];
-  }
-  for (let shift = 3; shift <= 31; shift += 7) {
-    let b = this.buf[this.pos++];
-    highBits |= (b & 0x7f) << shift;
-    if ((b & 0x80) == 0) {
-      this.assertBounds();
-      return [lowBits, highBits];
+    let middleByte = this.buf[this.pos++];
+    // last four bits of the first 32 bit number
+    lowBits |= (middleByte & 0x0f) << 28;
+    // 3 upper bits are part of the next 32 bit number
+    highBits = (middleByte & 0x70) >> 4;
+    if ((middleByte & 0x80) == 0) {
+        this.assertBounds();
+        return [lowBits, highBits];
+    }
+    for (let shift = 3; shift <= 31; shift += 7) {
+        let b = this.buf[this.pos++];
+        highBits |= (b & 0x7f) << shift;
+        if ((b & 0x80) == 0) {
+            this.assertBounds();
+            return [lowBits, highBits];
+        }
     }
-  }
-  throw new Error("invalid varint");
+    throw new Error("invalid varint");
 }
 /**
  * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
@@ -80,31 +80,31 @@ export function varint64read() {
  * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
  */
 export function varint64write(lo, hi, bytes) {
-  for (let i = 0; i < 28; i = i + 7) {
-    const shift = lo >>> i;
-    const hasNext = !(shift >>> 7 == 0 && hi == 0);
-    const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
-    bytes.push(byte);
-    if (!hasNext) {
-      return;
+    for (let i = 0; i < 28; i = i + 7) {
+        const shift = lo >>> i;
+        const hasNext = !(shift >>> 7 == 0 && hi == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
+    }
+    const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+    const hasMoreBits = !(hi >> 3 == 0);
+    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+    if (!hasMoreBits) {
+        return;
     }
-  }
-  const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
-  const hasMoreBits = !(hi >> 3 == 0);
-  bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
-  if (!hasMoreBits) {
-    return;
-  }
-  for (let i = 3; i < 31; i = i + 7) {
-    const shift = hi >>> i;
-    const hasNext = !(shift >>> 7 == 0);
-    const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
-    bytes.push(byte);
-    if (!hasNext) {
-      return;
+    for (let i = 3; i < 31; i = i + 7) {
+        const shift = hi >>> i;
+        const hasNext = !(shift >>> 7 == 0);
+        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+        bytes.push(byte);
+        if (!hasNext) {
+            return;
+        }
     }
-  }
-  bytes.push((hi >>> 31) & 0x01);
+    bytes.push((hi >>> 31) & 0x01);
 }
 // constants for binary math
 const TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
@@ -119,31 +119,32 @@ const TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
  * Copyright 2008 Google Inc.
  */
 export function int64fromString(dec) {
-  // Check for minus sign.
-  let minus = dec[0] == "-";
-  if (minus) dec = dec.slice(1);
-  // Work 6 decimal digits at a time, acting like we're converting base 1e6
-  // digits to binary. This is safe to do with floating point math because
-  // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
-  const base = 1e6;
-  let lowBits = 0;
-  let highBits = 0;
-  function add1e6digit(begin, end) {
-    // Note: Number('') is 0.
-    const digit1e6 = Number(dec.slice(begin, end));
-    highBits *= base;
-    lowBits = lowBits * base + digit1e6;
-    // Carry bits from lowBits to
-    if (lowBits >= TWO_PWR_32_DBL) {
-      highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
-      lowBits = lowBits % TWO_PWR_32_DBL;
+    // Check for minus sign.
+    let minus = dec[0] == "-";
+    if (minus)
+        dec = dec.slice(1);
+    // Work 6 decimal digits at a time, acting like we're converting base 1e6
+    // digits to binary. This is safe to do with floating point math because
+    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
+    const base = 1e6;
+    let lowBits = 0;
+    let highBits = 0;
+    function add1e6digit(begin, end) {
+        // Note: Number('') is 0.
+        const digit1e6 = Number(dec.slice(begin, end));
+        highBits *= base;
+        lowBits = lowBits * base + digit1e6;
+        // Carry bits from lowBits to
+        if (lowBits >= TWO_PWR_32_DBL) {
+            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+            lowBits = lowBits % TWO_PWR_32_DBL;
+        }
     }
-  }
-  add1e6digit(-24, -18);
-  add1e6digit(-18, -12);
-  add1e6digit(-12, -6);
-  add1e6digit(-6);
-  return [minus, lowBits, highBits];
+    add1e6digit(-24, -18);
+    add1e6digit(-18, -12);
+    add1e6digit(-12, -6);
+    add1e6digit(-6);
+    return [minus, lowBits, highBits];
 }
 /**
  * Format 64 bit integer value (as two JS numbers) to decimal string.
@@ -151,54 +152,52 @@ export function int64fromString(dec) {
  * Copyright 2008 Google Inc.
  */
 export function int64toString(bitsLow, bitsHigh) {
-  // Skip the expensive conversion if the number is small enough to use the
-  // built-in conversions.
-  if (bitsHigh <= 0x1fffff) {
-    return "" + (TWO_PWR_32_DBL * bitsHigh + bitsLow);
-  }
-  // What this code is doing is essentially converting the input number from
-  // base-2 to base-1e7, which allows us to represent the 64-bit range with
-  // only 3 (very large) digits. Those digits are then trivial to convert to
-  // a base-10 string.
-  // The magic numbers used here are -
-  // 2^24 = 16777216 = (1,6777216) in base-1e7.
-  // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
-  // Split 32:32 representation into 16:24:24 representation so our
-  // intermediate digits don't overflow.
-  let low = bitsLow & 0xffffff;
-  let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xffffff;
-  let high = (bitsHigh >> 16) & 0xffff;
-  // Assemble our three base-1e7 digits, ignoring carries. The maximum
-  // value in a digit at this step is representable as a 48-bit integer, which
-  // can be stored in a 64-bit floating point number.
-  let digitA = low + mid * 6777216 + high * 6710656;
-  let digitB = mid + high * 8147497;
-  let digitC = high * 2;
-  // Apply carries from A to B and from B to C.
-  let base = 10000000;
-  if (digitA >= base) {
-    digitB += Math.floor(digitA / base);
-    digitA %= base;
-  }
-  if (digitB >= base) {
-    digitC += Math.floor(digitB / base);
-    digitB %= base;
-  }
-  // Convert base-1e7 digits to base-10, with optional leading zeroes.
-  function decimalFrom1e7(digit1e7, needLeadingZeros) {
-    let partial = digit1e7 ? String(digit1e7) : "";
-    if (needLeadingZeros) {
-      return "0000000".slice(partial.length) + partial;
+    // Skip the expensive conversion if the number is small enough to use the
+    // built-in conversions.
+    if (bitsHigh <= 0x1fffff) {
+        return "" + (TWO_PWR_32_DBL * bitsHigh + bitsLow);
     }
-    return partial;
-  }
-  return (
-    decimalFrom1e7(digitC, /*needLeadingZeros=*/ 0) +
-    decimalFrom1e7(digitB, /*needLeadingZeros=*/ digitC) +
-    // If the final 1e7 digit didn't need leading zeros, we would have
-    // returned via the trivial code path at the top.
-    decimalFrom1e7(digitA, /*needLeadingZeros=*/ 1)
-  );
+    // What this code is doing is essentially converting the input number from
+    // base-2 to base-1e7, which allows us to represent the 64-bit range with
+    // only 3 (very large) digits. Those digits are then trivial to convert to
+    // a base-10 string.
+    // The magic numbers used here are -
+    // 2^24 = 16777216 = (1,6777216) in base-1e7.
+    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
+    // Split 32:32 representation into 16:24:24 representation so our
+    // intermediate digits don't overflow.
+    let low = bitsLow & 0xffffff;
+    let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xffffff;
+    let high = (bitsHigh >> 16) & 0xffff;
+    // Assemble our three base-1e7 digits, ignoring carries. The maximum
+    // value in a digit at this step is representable as a 48-bit integer, which
+    // can be stored in a 64-bit floating point number.
+    let digitA = low + mid * 6777216 + high * 6710656;
+    let digitB = mid + high * 8147497;
+    let digitC = high * 2;
+    // Apply carries from A to B and from B to C.
+    let base = 10000000;
+    if (digitA >= base) {
+        digitB += Math.floor(digitA / base);
+        digitA %= base;
+    }
+    if (digitB >= base) {
+        digitC += Math.floor(digitB / base);
+        digitB %= base;
+    }
+    // Convert base-1e7 digits to base-10, with optional leading zeroes.
+    function decimalFrom1e7(digit1e7, needLeadingZeros) {
+        let partial = digit1e7 ? String(digit1e7) : "";
+        if (needLeadingZeros) {
+            return "0000000".slice(partial.length) + partial;
+        }
+        return partial;
+    }
+    return (decimalFrom1e7(digitC, /*needLeadingZeros=*/ 0) +
+        decimalFrom1e7(digitB, /*needLeadingZeros=*/ digitC) +
+        // If the final 1e7 digit didn't need leading zeros, we would have
+        // returned via the trivial code path at the top.
+        decimalFrom1e7(digitA, /*needLeadingZeros=*/ 1));
 }
 /**
  * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
@@ -208,20 +207,21 @@ export function int64toString(bitsLow, bitsHigh) {
  * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
  */
 export function varint32write(value, bytes) {
-  if (value >= 0) {
-    // write value as varint 32
-    while (value > 0x7f) {
-      bytes.push((value & 0x7f) | 0x80);
-      value = value >>> 7;
+    if (value >= 0) {
+        // write value as varint 32
+        while (value > 0x7f) {
+            bytes.push((value & 0x7f) | 0x80);
+            value = value >>> 7;
+        }
+        bytes.push(value);
     }
-    bytes.push(value);
-  } else {
-    for (let i = 0; i < 9; i++) {
-      bytes.push((value & 127) | 128);
-      value = value >> 7;
+    else {
+        for (let i = 0; i < 9; i++) {
+            bytes.push((value & 127) | 128);
+            value = value >> 7;
+        }
+        bytes.push(1);
     }
-    bytes.push(1);
-  }
 }
 /**
  * Read an unsigned 32 bit varint.
@@ -229,37 +229,38 @@ export function varint32write(value, bytes) {
  * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
  */
 export function varint32read() {
-  let b = this.buf[this.pos++];
-  let result = b & 0x7f;
-  if ((b & 0x80) == 0) {
-    this.assertBounds();
-    return result;
-  }
-  b = this.buf[this.pos++];
-  result |= (b & 0x7f) << 7;
-  if ((b & 0x80) == 0) {
-    this.assertBounds();
-    return result;
-  }
-  b = this.buf[this.pos++];
-  result |= (b & 0x7f) << 14;
-  if ((b & 0x80) == 0) {
-    this.assertBounds();
-    return result;
-  }
-  b = this.buf[this.pos++];
-  result |= (b & 0x7f) << 21;
-  if ((b & 0x80) == 0) {
-    this.assertBounds();
-    return result;
-  }
-  // Extract only last 4 bits
-  b = this.buf[this.pos++];
-  result |= (b & 0x0f) << 28;
-  for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+    let b = this.buf[this.pos++];
+    let result = b & 0x7f;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
     b = this.buf[this.pos++];
-  if ((b & 0x80) != 0) throw new Error("invalid varint");
-  this.assertBounds();
-  // Result can have 32 bits, convert it to unsigned
-  return result >>> 0;
+    result |= (b & 0x7f) << 7;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 14;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    b = this.buf[this.pos++];
+    result |= (b & 0x7f) << 21;
+    if ((b & 0x80) == 0) {
+        this.assertBounds();
+        return result;
+    }
+    // Extract only last 4 bits
+    b = this.buf[this.pos++];
+    result |= (b & 0x0f) << 28;
+    for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+        b = this.buf[this.pos++];
+    if ((b & 0x80) != 0)
+        throw new Error("invalid varint");
+    this.assertBounds();
+    // Result can have 32 bits, convert it to unsigned
+    return result >>> 0;
 }

package/dist/esm/index.js

@@ -1,7 +1,20 @@
+// 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.
 export { proto3 } from "./proto3.js";
 export { proto2 } from "./proto2.js";
 export { protoInt64 } from "./proto-int64.js";
-export { Message } from "./message.js";
+export { Message, } from "./message.js";
 export { ScalarType } from "./field.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
 export { TypeRegistry } from "./type-registry.js";

package/dist/esm/json-format.js

@@ -1 +1,14 @@
+// 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.
 export {};

package/dist/esm/message-type.js

@@ -1 +1,14 @@
+// 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.
 export {};

package/dist/esm/message.js

@@ -1,3 +1,16 @@
+// 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.
 /**
  * Message is the base class of every message, generated, or created at
  * runtime.
@@ -6,89 +19,80 @@
  * run time, use proto3.makeMessageType().
  */
 export class Message {
-  /**
-   * Compare with a message of the same type.
-   */
-  equals(other) {
-    return this.getType().runtime.util.equals(this.getType(), this, other);
-  }
-  /**
-   * Create a deep copy.
-   */
-  clone() {
-    // return this.getType().runtime.util.clone(this);
-    return this.getType().runtime.util.clone(this);
-  }
-  /**
-   * Parse from binary data, merging fields.
-   *
-   * Repeated fields are appended. Map entries are added, overwriting
-   * existing keys.
-   *
-   * If a message field is already present, it will be merged with the
-   * new data.
-   */
-  fromBinary(bytes, options) {
-    const type = this.getType(),
-      format = type.runtime.bin,
-      opt = format.makeReadOptions(options);
-    format.readMessage(this, opt.readerFactory(bytes), bytes.byteLength, opt);
-    return this;
-  }
-  /**
-   * Parse a message from a JSON value.
-   */
-  fromJson(jsonValue, options) {
-    const type = this.getType(),
-      format = type.runtime.json,
-      opt = format.makeReadOptions(options);
-    format.readMessage(type, jsonValue, opt, this);
-    return this;
-  }
-  /**
-   * Parse a message from a JSON string.
-   */
-  fromJsonString(jsonString, options) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- assigning to JsonValue is safe here
-    return this.fromJson(JSON.parse(jsonString), options);
-  }
-  /**
-   * Serialize the message to binary data.
-   */
-  toBinary(options) {
-    const type = this.getType(),
-      bin = type.runtime.bin,
-      opt = bin.makeWriteOptions(options),
-      writer = opt.writerFactory();
-    bin.writeMessage(this, writer, opt);
-    return writer.finish();
-  }
-  /**
-   * Serialize the message to a JSON value, a JavaScript value that can be
-   * passed to JSON.stringify().
-   */
-  toJson(options) {
-    const type = this.getType(),
-      json = type.runtime.json,
-      opt = json.makeWriteOptions(options);
-    return json.writeMessage(this, opt);
-  }
-  /**
-   * Serialize the message to a JSON string.
-   */
-  toJsonString(options) {
-    const value = this.toJson(options);
-    return JSON.stringify(value, null, options?.prettySpaces ?? 0);
-  }
-  /**
-   * Retrieve the MessageType of this message - a singleton that represents
-   * the protobuf message declaration and provides metadata for reflection-
-   * based operations.
-   */
-  getType() {
-    // Any class that extends Message _must_ provide a complete static
-    // implementation of MessageType.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
-    return Object.getPrototypeOf(this).constructor;
-  }
+    /**
+     * Compare with a message of the same type.
+     */
+    equals(other) {
+        return this.getType().runtime.util.equals(this.getType(), this, other);
+    }
+    /**
+     * Create a deep copy.
+     */
+    clone() {
+        // return this.getType().runtime.util.clone(this);
+        return this.getType().runtime.util.clone(this);
+    }
+    /**
+     * Parse from binary data, merging fields.
+     *
+     * Repeated fields are appended. Map entries are added, overwriting
+     * existing keys.
+     *
+     * If a message field is already present, it will be merged with the
+     * new data.
+     */
+    fromBinary(bytes, options) {
+        const type = this.getType(), format = type.runtime.bin, opt = format.makeReadOptions(options);
+        format.readMessage(this, opt.readerFactory(bytes), bytes.byteLength, opt);
+        return this;
+    }
+    /**
+     * Parse a message from a JSON value.
+     */
+    fromJson(jsonValue, options) {
+        const type = this.getType(), format = type.runtime.json, opt = format.makeReadOptions(options);
+        format.readMessage(type, jsonValue, opt, this);
+        return this;
+    }
+    /**
+     * Parse a message from a JSON string.
+     */
+    fromJsonString(jsonString, options) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- assigning to JsonValue is safe here
+        return this.fromJson(JSON.parse(jsonString), options);
+    }
+    /**
+     * Serialize the message to binary data.
+     */
+    toBinary(options) {
+        const type = this.getType(), bin = type.runtime.bin, opt = bin.makeWriteOptions(options), writer = opt.writerFactory();
+        bin.writeMessage(this, writer, opt);
+        return writer.finish();
+    }
+    /**
+     * Serialize the message to a JSON value, a JavaScript value that can be
+     * passed to JSON.stringify().
+     */
+    toJson(options) {
+        const type = this.getType(), json = type.runtime.json, opt = json.makeWriteOptions(options);
+        return json.writeMessage(this, opt);
+    }
+    /**
+     * Serialize the message to a JSON string.
+     */
+    toJsonString(options) {
+        const value = this.toJson(options);
+        return JSON.stringify(value, null, options?.prettySpaces ?? 0);
+    }
+    /**
+     * Retrieve the MessageType of this message - a singleton that represents
+     * the protobuf message declaration and provides metadata for reflection-
+     * based operations.
+     */
+    getType() {
+        // Any class that extends Message _must_ provide a complete static
+        // implementation of MessageType.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+        return Object.getPrototypeOf(this).constructor;
+    }
 }