@aptre/protobuf-es-lite 0.2.10 → 0.2.11

package/dist/is-message.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCompleteField = exports.isCompleteMessage = exports.isField = exports.isMessage = void 0;
-const field_js_1 = require("./field.js");
+import { resolveMessageType } from "./field.js";
 /**
  * Check whether the given partial is a valid message.
  */
-function isMessage(arg, fields) {
+export function isMessage(arg, fields) {
     if (arg == null || typeof arg !== "object") {
         return false;
     }
@@ -24,11 +21,10 @@ function isMessage(arg, fields) {
         }
     });
 }
-exports.isMessage = isMessage;
 /**
  * Check whether the given partial field is a valid field value.
  */
-function isField(value, field) {
+export function isField(value, field) {
     if (value == null) {
         return false;
     }
@@ -46,7 +42,7 @@ function isField(value, field) {
         case "scalar":
             return true;
         case "message":
-            const messageType = (0, field_js_1.resolveMessageType)(field.T);
+            const messageType = resolveMessageType(field.T);
             return isMessage(value, messageType.fields.list());
         case "enum":
             return typeof value === "number";
@@ -59,7 +55,7 @@ function isField(value, field) {
                     case "enum":
                         return typeof val === "number";
                     case "message":
-                        const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+                        const messageType = resolveMessageType(field.V.T);
                         return isMessage(val, messageType.fields.list());
                     default:
                         return valueKind;
@@ -69,11 +65,10 @@ function isField(value, field) {
             return fieldKind;
     }
 }
-exports.isField = isField;
 /**
  * Check whether the given partial has all fields present recursively.
  */
-function isCompleteMessage(arg, fields) {
+export function isCompleteMessage(arg, fields) {
     // arg is CompleteMessage<T> {
     if (arg == null || typeof arg !== "object") {
         return false;
@@ -89,11 +84,10 @@ function isCompleteMessage(arg, fields) {
         }
     });
 }
-exports.isCompleteMessage = isCompleteMessage;
 /**
  * Check whether the given partial field has a full value present recursively.
  */
-function isCompleteField(value, field) {
+export function isCompleteField(value, field) {
     // value is CompleteField<F> {
     if (field.oneof) {
         // For oneof fields, only one field should be set
@@ -109,7 +103,7 @@ function isCompleteField(value, field) {
         case "scalar":
             return true;
         case "message":
-            const messageType = (0, field_js_1.resolveMessageType)(field.T);
+            const messageType = resolveMessageType(field.T);
             return isCompleteMessage(value, messageType.fields.list());
         case "enum":
             return typeof value === "number";
@@ -122,7 +116,7 @@ function isCompleteField(value, field) {
                     case "enum":
                         return typeof val === "number";
                     case "message":
-                        const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+                        const messageType = resolveMessageType(field.V.T);
                         return isCompleteMessage(val, messageType.fields.list());
                     default:
                         return valueKind;
@@ -132,4 +126,3 @@ function isCompleteField(value, field) {
             return fieldKind;
     }
 }
-exports.isCompleteField = isCompleteField;

package/dist/json.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearField = exports.writeMessage = exports.readMessage = exports.makeWriteOptions = exports.makeReadOptions = void 0;
-const field_js_1 = require("./field.js");
-const assert_js_1 = require("./assert.js");
-const scalar_js_1 = require("./scalar.js");
-const field_wrapper_js_1 = require("./field-wrapper.js");
-const proto_int64_js_1 = require("./proto-int64.js");
-const proto_base64_js_1 = require("./proto-base64.js");
+import { isFieldSet, resolveMessageType, } from "./field.js";
+import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
+import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
+import { wrapField } from "./field-wrapper.js";
+import { protoInt64 } from "./proto-int64.js";
+import { protoBase64 } from "./proto-base64.js";
 // Default options for parsing JSON.
 const jsonReadDefaults = {
     ignoreUnknownFields: false,
@@ -18,14 +15,12 @@ const jsonWriteDefaults = {
     useProtoFieldName: false,
     prettySpaces: 0,
 };
-function makeReadOptions(options) {
+export function makeReadOptions(options) {
     return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
 }
-exports.makeReadOptions = makeReadOptions;
-function makeWriteOptions(options) {
+export function makeWriteOptions(options) {
     return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
 }
-exports.makeWriteOptions = makeWriteOptions;
 function debugJsonValue(json) {
     if (json === null) {
         return "null";
@@ -39,7 +34,7 @@ function debugJsonValue(json) {
             return String(json);
     }
 }
-function readMessage(fields, typeName, json, options, message) {
+export function readMessage(fields, typeName, json, options, message) {
     if (json == null || Array.isArray(json) || typeof json != "object") {
         throw new Error(`cannot decode message ${typeName} from JSON: ${debugJsonValue(json)}`);
     }
@@ -69,13 +64,12 @@ function readMessage(fields, typeName, json, options, message) {
     }
     return message;
 }
-exports.readMessage = readMessage;
-function writeMessage(message, fields, options) {
+export function writeMessage(message, fields, options) {
     const json = {};
     let field;
     try {
         for (field of fields.byNumber()) {
-            if (!(0, field_js_1.isFieldSet)(field, message)) {
+            if (!isFieldSet(field, message)) {
                 // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
                 if (field.req) {
                     throw `required field not set`;
@@ -128,13 +122,12 @@ function writeMessage(message, fields, options) {
     }
     return json;
 }
-exports.writeMessage = writeMessage;
 // Read a JSON value for a field.
 // The "parentType" argument is only used to provide context in errors.
 function readField(target, jsonValue, field, options) {
     let localName = field.localName;
     if (field.repeated) {
-        (0, assert_js_1.assert)(field.kind != "map");
+        assert(field.kind != "map");
         if (jsonValue === null) {
             return;
         }
@@ -151,7 +144,7 @@ function readField(target, jsonValue, field, options) {
             }
             switch (field.kind) {
                 case "message":
-                    const messageType = (0, field_js_1.resolveMessageType)(field.T);
+                    const messageType = resolveMessageType(field.T);
                     targetArray.push(messageType.fromJson(jsonItem, options));
                     break;
                 case "enum":
@@ -203,7 +196,7 @@ function readField(target, jsonValue, field, options) {
             }
             switch (field.V.kind) {
                 case "message":
-                    const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+                    const messageType = resolveMessageType(field.V.T);
                     targetMap[key] = messageType.fromJson(jsonMapValue, options);
                     break;
                 case "enum":
@@ -214,7 +207,7 @@ function readField(target, jsonValue, field, options) {
                     break;
                 case "scalar":
                     try {
-                        targetMap[key] = readScalar(field.V.T, jsonMapValue, scalar_js_1.LongType.BIGINT, true);
+                        targetMap[key] = readScalar(field.V.T, jsonMapValue, LongType.BIGINT, true);
                     }
                     catch (e) {
                         let m = `cannot decode map value for field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
@@ -234,7 +227,7 @@ function readField(target, jsonValue, field, options) {
         }
         switch (field.kind) {
             case "message":
-                const messageType = (0, field_js_1.resolveMessageType)(field.T);
+                const messageType = resolveMessageType(field.T);
                 if (jsonValue === null &&
                     messageType.typeName != "google.protobuf.Value") {
                     return;
@@ -312,7 +305,7 @@ function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
 function readScalar(type, json, longType, nullAsZeroValue) {
     if (json === null) {
         if (nullAsZeroValue) {
-            return (0, scalar_js_1.scalarZeroValue)(type, longType);
+            return scalarZeroValue(type, longType);
         }
         return tokenNull;
     }
@@ -321,8 +314,8 @@ function readScalar(type, json, longType, nullAsZeroValue) {
     switch (type) {
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
-        case scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FLOAT:
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
             if (json === "NaN")
                 return Number.NaN;
             if (json === "Infinity")
@@ -349,15 +342,15 @@ function readScalar(type, json, longType, nullAsZeroValue) {
                 // infinity and -infinity are handled by string representation above, so this is an error
                 break;
             }
-            if (type == scalar_js_1.ScalarType.FLOAT)
-                (0, assert_js_1.assertFloat32)(float);
+            if (type == ScalarType.FLOAT)
+                assertFloat32(float);
             return float;
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
-        case scalar_js_1.ScalarType.UINT32:
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+        case ScalarType.UINT32:
             let int32;
             if (typeof json == "number")
                 int32 = json;
@@ -367,34 +360,34 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             }
             if (int32 === undefined)
                 break;
-            if (type == scalar_js_1.ScalarType.UINT32 || type == scalar_js_1.ScalarType.FIXED32)
-                (0, assert_js_1.assertUInt32)(int32);
+            if (type == ScalarType.UINT32 || type == ScalarType.FIXED32)
+                assertUInt32(int32);
             else
-                (0, assert_js_1.assertInt32)(int32);
+                assertInt32(int32);
             return int32;
         // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.INT64:
-        case scalar_js_1.ScalarType.SFIXED64:
-        case scalar_js_1.ScalarType.SINT64:
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
             if (typeof json != "number" && typeof json != "string")
                 break;
-            const long = proto_int64_js_1.protoInt64.parse(json);
+            const long = protoInt64.parse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? long.toString() : long;
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
             if (typeof json != "number" && typeof json != "string")
                 break;
-            const uLong = proto_int64_js_1.protoInt64.uParse(json);
+            const uLong = protoInt64.uParse(json);
             // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
             return longType ? uLong.toString() : uLong;
         // bool:
-        case scalar_js_1.ScalarType.BOOL:
+        case ScalarType.BOOL:
             if (typeof json !== "boolean")
                 break;
             return json;
         // string:
-        case scalar_js_1.ScalarType.STRING:
+        case ScalarType.STRING:
             if (typeof json !== "string") {
                 break;
             }
@@ -409,17 +402,17 @@ function readScalar(type, json, longType, nullAsZeroValue) {
             return json;
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
-        case scalar_js_1.ScalarType.BYTES:
+        case ScalarType.BYTES:
             if (json === "")
                 return new Uint8Array(0);
             if (typeof json !== "string")
                 break;
-            return proto_base64_js_1.protoBase64.dec(json);
+            return protoBase64.dec(json);
     }
     throw new Error();
 }
 function readMapKey(type, json) {
-    if (type === scalar_js_1.ScalarType.BOOL) {
+    if (type === ScalarType.BOOL) {
         // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (json) {
             case "true":
@@ -430,12 +423,12 @@ function readMapKey(type, json) {
                 break;
         }
     }
-    return readScalar(type, json, scalar_js_1.LongType.BIGINT, true).toString();
+    return readScalar(type, json, LongType.BIGINT, true).toString();
 }
 /**
  * Resets the field, so that isFieldSet() will return false.
  */
-function clearField(field, target) {
+export function clearField(field, target) {
     const localName = field.localName;
     const implicitPresence = !field.opt && !field.req;
     if (field.repeated) {
@@ -454,7 +447,7 @@ function clearField(field, target) {
                 break;
             case "scalar":
                 target[localName] =
-                    implicitPresence ? (0, scalar_js_1.scalarZeroValue)(field.T, field.L) : undefined;
+                    implicitPresence ? scalarZeroValue(field.T, field.L) : undefined;
                 break;
             case "message":
                 target[localName] = undefined;
@@ -462,7 +455,6 @@ function clearField(field, target) {
         }
     }
 }
-exports.clearField = clearField;
 // Decide whether an unset field should be emitted with JSON write option `emitDefaultValues`
 function canEmitFieldDefaultValue(field) {
     if (field.repeated || field.kind == "map") {
@@ -486,7 +478,7 @@ function canEmitFieldDefaultValue(field) {
 }
 function writeField(field, value, options) {
     if (field.kind == "map") {
-        (0, assert_js_1.assert)(typeof value == "object" && value != null);
+        assert(typeof value == "object" && value != null);
         const jsonObj = {};
         const entries = Object.entries(value);
         switch (field.V.kind) {
@@ -498,7 +490,7 @@ function writeField(field, value, options) {
             case "message":
                 for (const [entryKey, entryValue] of entries) {
                     // JSON standard allows only (double quoted) string as property key
-                    const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+                    const messageType = resolveMessageType(field.V.T);
                     jsonObj[entryKey.toString()] = messageType.toJson(entryValue, options);
                 }
                 break;
@@ -515,7 +507,7 @@ function writeField(field, value, options) {
             : undefined;
     }
     if (field.repeated) {
-        (0, assert_js_1.assert)(Array.isArray(value));
+        assert(Array.isArray(value));
         const jsonArr = [];
         switch (field.kind) {
             case "scalar":
@@ -544,26 +536,26 @@ function writeField(field, value, options) {
         case "enum":
             return writeEnum(field.T, value, options.enumAsInteger);
         case "message":
-            const messageType = (0, field_js_1.resolveMessageType)(field.T);
-            return messageType.toJson((0, field_wrapper_js_1.wrapField)(messageType.fieldWrapper, value));
+            const messageType = resolveMessageType(field.T);
+            return messageType.toJson(wrapField(messageType.fieldWrapper, value));
     }
 }
 function writeScalar(type, value) {
     switch (type) {
         // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.UINT32:
-            (0, assert_js_1.assert)(typeof value == "number");
+        case ScalarType.INT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+            assert(typeof value == "number");
             return value;
         // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
         // Either numbers or strings are accepted. Exponent notation is also accepted.
-        case scalar_js_1.ScalarType.FLOAT:
+        case ScalarType.FLOAT:
         // assertFloat32(value);
-        case scalar_js_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
-            (0, assert_js_1.assert)(typeof value == "number");
+        case ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+            assert(typeof value == "number");
             if (Number.isNaN(value))
                 return "NaN";
             if (value === Number.POSITIVE_INFINITY)
@@ -572,32 +564,32 @@ function writeScalar(type, value) {
                 return "-Infinity";
             return value;
         // string:
-        case scalar_js_1.ScalarType.STRING:
-            (0, assert_js_1.assert)(typeof value == "string");
+        case ScalarType.STRING:
+            assert(typeof value == "string");
             return value;
         // bool:
-        case scalar_js_1.ScalarType.BOOL:
-            (0, assert_js_1.assert)(typeof value == "boolean");
+        case ScalarType.BOOL:
+            assert(typeof value == "boolean");
             return value;
         // JSON value will be a decimal string. Either numbers or strings are accepted.
-        case scalar_js_1.ScalarType.UINT64:
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.INT64:
-        case scalar_js_1.ScalarType.SFIXED64:
-        case scalar_js_1.ScalarType.SINT64:
-            (0, assert_js_1.assert)(typeof value == "bigint" ||
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            assert(typeof value == "bigint" ||
                 typeof value == "string" ||
                 typeof value == "number");
             return value.toString();
         // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
         // Either standard or URL-safe base64 encoding with/without paddings are accepted.
-        case scalar_js_1.ScalarType.BYTES:
-            (0, assert_js_1.assert)(value instanceof Uint8Array);
-            return proto_base64_js_1.protoBase64.enc(value);
+        case ScalarType.BYTES:
+            assert(value instanceof Uint8Array);
+            return protoBase64.enc(value);
     }
 }
 function writeEnum(type, value, enumAsInteger) {
-    (0, assert_js_1.assert)(typeof value == "number");
+    assert(typeof value == "number");
     if (type.typeName == "google.protobuf.NullValue") {
         return null;
     }