@milaboratories/pl-drivers 1.5.9 → 1.5.11

package/src/proto/google/protobuf/duration.ts

@@ -139,17 +139,18 @@ class Duration$Type extends MessageType<Duration> {
         no: 1,
         name: 'seconds',
         kind: 'scalar',
-        T: 3 /*ScalarType.INT64*/,
-        L: 0 /*LongType.BIGINT*/
+        T: 3 /* ScalarType.INT64 */,
+        L: 0, /* LongType.BIGINT */
       },
-      { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ }
+      { no: 2, name: 'nanos', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
     ]);
   }
+
   /**
    * Encode `Duration` to JSON string like "3.000001s".
    */
   internalJsonWrite(message: Duration, options: JsonWriteOptions): JsonValue {
-    let s = PbLong.from(message.seconds).toNumber();
+    const s = PbLong.from(message.seconds).toNumber();
     if (s > 315576000000 || s < -315576000000)
       throw new Error('Duration value out of range.');
     let text = message.seconds.toString();
@@ -165,42 +166,44 @@ class Duration$Type extends MessageType<Duration> {
     }
     return text + 's';
   }
+
   /**
    * Decode `Duration` from JSON string like "3.000001s"
    */
   internalJsonRead(
     json: JsonValue,
     options: JsonReadOptions,
-    target?: Duration
+    target?: Duration,
   ): Duration {
     if (typeof json !== 'string')
       throw new Error(
-        'Unable to parse Duration from JSON ' +
-          typeofJsonValue(json) +
-          '. Expected string.'
+        'Unable to parse Duration from JSON '
+        + typeofJsonValue(json)
+        + '. Expected string.',
       );
-    let match = json.match(/^(-?)([0-9]+)(?:\.([0-9]+))?s/);
+    const match = json.match(/^(-?)([0-9]+)(?:\.([0-9]+))?s/);
     if (match === null)
       throw new Error(
-        'Unable to parse Duration from JSON string. Invalid format.'
+        'Unable to parse Duration from JSON string. Invalid format.',
       );
     if (!target) target = this.create();
-    let [, sign, secs, nanos] = match;
-    let longSeconds = PbLong.from(sign + secs);
+    const [, sign, secs, nanos] = match;
+    const longSeconds = PbLong.from(sign + secs);
     if (
-      longSeconds.toNumber() > 315576000000 ||
-      longSeconds.toNumber() < -315576000000
+      longSeconds.toNumber() > 315576000000
+      || longSeconds.toNumber() < -315576000000
     )
       throw new Error(
-        'Unable to parse Duration from JSON string. Value out of range.'
+        'Unable to parse Duration from JSON string. Value out of range.',
       );
     target.seconds = longSeconds.toBigInt();
     if (typeof nanos == 'string') {
-      let nanosStr = sign + nanos + '0'.repeat(9 - nanos.length);
+      const nanosStr = sign + nanos + '0'.repeat(9 - nanos.length);
       target.nanos = parseInt(nanosStr);
     }
     return target;
   }
+
   create(value?: PartialMessage<Duration>): Duration {
     const message = globalThis.Object.create(this.messagePrototype!);
     message.seconds = 0n;
@@ -209,16 +212,17 @@ class Duration$Type extends MessageType<Duration> {
       reflectionMergePartial<Duration>(this, message, value);
     return message;
   }
+
   internalBinaryRead(
     reader: IBinaryReader,
     length: number,
     options: BinaryReadOptions,
-    target?: Duration
+    target?: Duration,
   ): Duration {
-    let message = target ?? this.create(),
+    const message = target ?? this.create(),
       end = reader.pos + length;
     while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
+      const [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case /* int64 seconds */ 1:
           message.seconds = reader.int64().toBigInt();
@@ -227,28 +231,29 @@ class Duration$Type extends MessageType<Duration> {
           message.nanos = reader.int32();
           break;
         default:
-          let u = options.readUnknownField;
+          const u = options.readUnknownField;
           if (u === 'throw')
             throw new globalThis.Error(
-              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
             );
-          let d = reader.skip(wireType);
+          const d = reader.skip(wireType);
           if (u !== false)
             (u === true ? UnknownFieldHandler.onRead : u)(
               this.typeName,
               message,
               fieldNo,
               wireType,
-              d
+              d,
             );
       }
     }
     return message;
   }
+
   internalBinaryWrite(
     message: Duration,
     writer: IBinaryWriter,
-    options: BinaryWriteOptions
+    options: BinaryWriteOptions,
   ): IBinaryWriter {
     /* int64 seconds = 1; */
     if (message.seconds !== 0n)
@@ -256,12 +261,12 @@ class Duration$Type extends MessageType<Duration> {
     /* int32 nanos = 2; */
     if (message.nanos !== 0)
       writer.tag(2, WireType.Varint).int32(message.nanos);
-    let u = options.writeUnknownFields;
+    const u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(
         this.typeName,
         message,
-        writer
+        writer,
       );
     return writer;
   }

package/src/proto/google/protobuf/timestamp.ts

@@ -170,12 +170,13 @@ class Timestamp$Type extends MessageType<Timestamp> {
         no: 1,
         name: 'seconds',
         kind: 'scalar',
-        T: 3 /*ScalarType.INT64*/,
-        L: 0 /*LongType.BIGINT*/
+        T: 3 /* ScalarType.INT64 */,
+        L: 0, /* LongType.BIGINT */
       },
-      { no: 2, name: 'nanos', kind: 'scalar', T: 5 /*ScalarType.INT32*/ }
+      { no: 2, name: 'nanos', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
     ]);
   }
+
   /**
    * Creates a new `Timestamp` for the current time.
    */
@@ -186,15 +187,17 @@ class Timestamp$Type extends MessageType<Timestamp> {
     msg.nanos = (ms % 1000) * 1000000;
     return msg;
   }
+
   /**
    * Converts a `Timestamp` to a JavaScript Date.
    */
   toDate(message: Timestamp): Date {
     return new Date(
-      PbLong.from(message.seconds).toNumber() * 1000 +
-        Math.ceil(message.nanos / 1000000)
+      PbLong.from(message.seconds).toNumber() * 1000
+      + Math.ceil(message.nanos / 1000000),
     );
   }
+
   /**
    * Converts a JavaScript Date to a `Timestamp`.
    */
@@ -205,26 +208,27 @@ class Timestamp$Type extends MessageType<Timestamp> {
     msg.nanos = (ms % 1000) * 1000000;
     return msg;
   }
+
   /**
    * In JSON format, the `Timestamp` type is encoded as a string
    * in the RFC 3339 format.
    */
   internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue {
-    let ms = PbLong.from(message.seconds).toNumber() * 1000;
+    const ms = PbLong.from(message.seconds).toNumber() * 1000;
     if (
-      ms < Date.parse('0001-01-01T00:00:00Z') ||
-      ms > Date.parse('9999-12-31T23:59:59Z')
+      ms < Date.parse('0001-01-01T00:00:00Z')
+      || ms > Date.parse('9999-12-31T23:59:59Z')
     )
       throw new Error(
-        'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'
+        'Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.',
       );
     if (message.nanos < 0)
       throw new Error(
-        'Unable to encode invalid Timestamp to JSON. Nanos must not be negative.'
+        'Unable to encode invalid Timestamp to JSON. Nanos must not be negative.',
       );
     let z = 'Z';
     if (message.nanos > 0) {
-      let nanosStr = (message.nanos + 1000000000).toString().substring(1);
+      const nanosStr = (message.nanos + 1000000000).toString().substring(1);
       if (nanosStr.substring(3) === '000000')
         z = '.' + nanosStr.substring(0, 3) + 'Z';
       else if (nanosStr.substring(6) === '000')
@@ -233,6 +237,7 @@ class Timestamp$Type extends MessageType<Timestamp> {
     }
     return new Date(ms).toISOString().replace('.000Z', z);
   }
+
   /**
    * In JSON format, the `Timestamp` type is encoded as a string
    * in the RFC 3339 format.
@@ -240,49 +245,50 @@ class Timestamp$Type extends MessageType<Timestamp> {
   internalJsonRead(
     json: JsonValue,
     options: JsonReadOptions,
-    target?: Timestamp
+    target?: Timestamp,
   ): Timestamp {
     if (typeof json !== 'string')
       throw new Error(
-        'Unable to parse Timestamp from JSON ' + typeofJsonValue(json) + '.'
+        'Unable to parse Timestamp from JSON ' + typeofJsonValue(json) + '.',
       );
-    let matches = json.match(
-      /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/
+    const matches = json.match(
+      /^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/,
     );
     if (!matches)
       throw new Error('Unable to parse Timestamp from JSON. Invalid format.');
-    let ms = Date.parse(
-      matches[1] +
-        '-' +
-        matches[2] +
-        '-' +
-        matches[3] +
-        'T' +
-        matches[4] +
-        ':' +
-        matches[5] +
-        ':' +
-        matches[6] +
-        (matches[8] ? matches[8] : 'Z')
+    const ms = Date.parse(
+      matches[1]
+      + '-'
+      + matches[2]
+      + '-'
+      + matches[3]
+      + 'T'
+      + matches[4]
+      + ':'
+      + matches[5]
+      + ':'
+      + matches[6]
+      + (matches[8] ? matches[8] : 'Z'),
     );
     if (Number.isNaN(ms))
       throw new Error('Unable to parse Timestamp from JSON. Invalid value.');
     if (
-      ms < Date.parse('0001-01-01T00:00:00Z') ||
-      ms > Date.parse('9999-12-31T23:59:59Z')
+      ms < Date.parse('0001-01-01T00:00:00Z')
+      || ms > Date.parse('9999-12-31T23:59:59Z')
     )
       throw new globalThis.Error(
-        'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.'
+        'Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.',
       );
     if (!target) target = this.create();
     target.seconds = PbLong.from(ms / 1000).toBigInt();
     target.nanos = 0;
     if (matches[7])
-      target.nanos =
-        parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length)) -
-        1000000000;
+      target.nanos
+        = parseInt('1' + matches[7] + '0'.repeat(9 - matches[7].length))
+        - 1000000000;
     return target;
   }
+
   create(value?: PartialMessage<Timestamp>): Timestamp {
     const message = globalThis.Object.create(this.messagePrototype!);
     message.seconds = 0n;
@@ -291,16 +297,17 @@ class Timestamp$Type extends MessageType<Timestamp> {
       reflectionMergePartial<Timestamp>(this, message, value);
     return message;
   }
+
   internalBinaryRead(
     reader: IBinaryReader,
     length: number,
     options: BinaryReadOptions,
-    target?: Timestamp
+    target?: Timestamp,
   ): Timestamp {
-    let message = target ?? this.create(),
+    const message = target ?? this.create(),
       end = reader.pos + length;
     while (reader.pos < end) {
-      let [fieldNo, wireType] = reader.tag();
+      const [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
         case /* int64 seconds */ 1:
           message.seconds = reader.int64().toBigInt();
@@ -309,28 +316,29 @@ class Timestamp$Type extends MessageType<Timestamp> {
           message.nanos = reader.int32();
           break;
         default:
-          let u = options.readUnknownField;
+          const u = options.readUnknownField;
           if (u === 'throw')
             throw new globalThis.Error(
-              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`
+              `Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`,
             );
-          let d = reader.skip(wireType);
+          const d = reader.skip(wireType);
           if (u !== false)
             (u === true ? UnknownFieldHandler.onRead : u)(
               this.typeName,
               message,
               fieldNo,
               wireType,
-              d
+              d,
             );
       }
     }
     return message;
   }
+
   internalBinaryWrite(
     message: Timestamp,
     writer: IBinaryWriter,
-    options: BinaryWriteOptions
+    options: BinaryWriteOptions,
   ): IBinaryWriter {
     /* int64 seconds = 1; */
     if (message.seconds !== 0n)
@@ -338,12 +346,12 @@ class Timestamp$Type extends MessageType<Timestamp> {
     /* int32 nanos = 2; */
     if (message.nanos !== 0)
       writer.tag(2, WireType.Varint).int32(message.nanos);
-    let u = options.writeUnknownFields;
+    const u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(
         this.typeName,
         message,
-        writer
+        writer,
       );
     return writer;
   }