@aptre/protobuf-es-lite 0.1.0

package/dist/json.js

@@ -0,0 +1,624 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearField = exports.writeMessage = exports.readMessage = exports.makeWriteOptions = exports.makeReadOptions = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+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");
+// Default options for parsing JSON.
+const jsonReadDefaults = {
+    ignoreUnknownFields: false,
+};
+// Default options for serializing to JSON.
+const jsonWriteDefaults = {
+    emitDefaultValues: false,
+    enumAsInteger: false,
+    useProtoFieldName: false,
+    prettySpaces: 0,
+};
+function makeReadOptions(options) {
+    return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
+}
+exports.makeReadOptions = makeReadOptions;
+function makeWriteOptions(options) {
+    return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
+}
+exports.makeWriteOptions = makeWriteOptions;
+function debugJsonValue(json) {
+    if (json === null) {
+        return "null";
+    }
+    switch (typeof json) {
+        case "object":
+            return Array.isArray(json) ? "array" : "object";
+        case "string":
+            return json.length > 100 ? "string" : `"${json.split('"').join('\\"')}"`;
+        default:
+            return String(json);
+    }
+}
+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)}`);
+    }
+    const oneofSeen = new Map();
+    const registry = options.typeRegistry;
+    for (const [jsonKey, jsonValue] of Object.entries(json)) {
+        const field = fields.findJsonName(jsonKey);
+        if (field) {
+            if (field.oneof) {
+                if (jsonValue === null && field.kind == "scalar") {
+                    // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+                    continue;
+                }
+                const seen = oneofSeen.get(field.oneof);
+                if (seen !== undefined) {
+                    throw new Error(`cannot decode message ${typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`);
+                }
+                oneofSeen.set(field.oneof, jsonKey);
+            }
+            readField(message, jsonValue, field, options);
+        }
+        else {
+            let found = false;
+            if (registry?.findExtension &&
+                jsonKey.startsWith("[") &&
+                jsonKey.endsWith("]")) {
+                // TODO: handle extension
+                /*
+                    const ext = registry.findExtension(
+                      jsonKey.substring(1, jsonKey.length - 1),
+                    );
+                    if (ext && ext.extendee.typeName == typeName) {
+                      found = true;
+                      const [container, get] = createExtensionContainer(ext);
+                      readField(container, jsonValue, ext.field, options, ext);
+                      // We pass on the options as BinaryReadOptions/BinaryWriteOptions,
+                      // so that users can bring their own binary reader and writer factories
+                      // if necessary.
+                      setExtension(
+                        message,
+                        ext as Extension<T>,
+                        get(),
+                        options as Partial<BinaryReadOptions & BinaryWriteOptions>,
+                      );
+                    }
+                    */
+            }
+            if (!found && !options.ignoreUnknownFields) {
+                throw new Error(`cannot decode message ${typeName} from JSON: key "${jsonKey}" is unknown`);
+            }
+        }
+    }
+    return message;
+}
+exports.readMessage = readMessage;
+function writeMessage(message, fields, options) {
+    const json = {};
+    let field;
+    try {
+        for (field of fields.byNumber()) {
+            if (!(0, field_js_1.isFieldSet)(field, message)) {
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                if (field.req) {
+                    throw `required field not set`;
+                }
+                if (!options.emitDefaultValues) {
+                    continue;
+                }
+                if (!canEmitFieldDefaultValue(field)) {
+                    continue;
+                }
+            }
+            const value = field.oneof
+                ? message[field.oneof.localName].value
+                : message[field.localName];
+            const jsonValue = writeField(field, value, options);
+            if (jsonValue !== undefined) {
+                json[options.useProtoFieldName ? field.name : field.jsonName] =
+                    jsonValue;
+            }
+        }
+        // TODO: handle extensions
+        /*
+            const registry = options.typeRegistry;
+            if (registry?.findExtensionFor) {
+              for (const uf of listUnknownFields(message)) {
+                const ext = registry.findExtensionFor(typeName, uf.no);
+                if (ext && hasExtension(message, ext)) {
+                  // We pass on the options as BinaryReadOptions, so that users can bring their own
+                  // binary reader factory if necessary.
+                  const value = getExtension(
+                    message,
+                    ext,
+                    options as Partial<BinaryReadOptions>,
+                  );
+                  const jsonValue = writeField(ext.field, value, options);
+                  if (jsonValue !== undefined) {
+                    json[ext.field.jsonName] = jsonValue;
+                  }
+                }
+              }
+            }
+            */
+    }
+    catch (e) {
+        const m = field
+            ? `cannot encode field ${field.name} to JSON`
+            : `cannot encode message to JSON`;
+        const r = e instanceof Error ? e.message : String(e);
+        throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
+    }
+    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");
+        if (jsonValue === null) {
+            return;
+        }
+        if (!Array.isArray(jsonValue)) {
+            throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+        }
+        const targetArray = target[localName];
+        for (const jsonItem of jsonValue) {
+            if (jsonItem === null) {
+                throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonItem)}`);
+            }
+            switch (field.kind) {
+                case "message":
+                    targetArray.push(field.T.fromJson(jsonItem, options));
+                    break;
+                case "enum":
+                    const enumValue = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
+                    if (enumValue !== tokenIgnoredUnknownEnum) {
+                        targetArray.push(enumValue);
+                    }
+                    break;
+                case "scalar":
+                    try {
+                        targetArray.push(readScalar(field.T, jsonItem, field.L, true));
+                    }
+                    catch (e) {
+                        let m = `cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonItem)}`;
+                        if (e instanceof Error && e.message.length > 0) {
+                            m += `: ${e.message}`;
+                        }
+                        throw new Error(m);
+                    }
+                    break;
+            }
+        }
+    }
+    else if (field.kind == "map") {
+        if (jsonValue === null) {
+            return;
+        }
+        if (typeof jsonValue != "object" || Array.isArray(jsonValue)) {
+            throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+        }
+        const targetMap = target[localName];
+        for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
+            if (jsonMapValue === null) {
+                throw new Error(`cannot decode field ${field.name} from JSON: map value null`);
+            }
+            let key;
+            try {
+                key = readMapKey(field.K, jsonMapKey);
+            }
+            catch (e) {
+                let m = `cannot decode map key for field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                }
+                throw new Error(m);
+            }
+            switch (field.V.kind) {
+                case "message":
+                    targetMap[key] = field.V.T.fromJson(jsonMapValue, options);
+                    break;
+                case "enum":
+                    const enumValue = readEnum(field.V.T, jsonMapValue, options.ignoreUnknownFields, true);
+                    if (enumValue !== tokenIgnoredUnknownEnum) {
+                        targetMap[key] = enumValue;
+                    }
+                    break;
+                case "scalar":
+                    try {
+                        targetMap[key] = readScalar(field.V.T, jsonMapValue, protobuf_1.LongType.BIGINT, true);
+                    }
+                    catch (e) {
+                        let m = `cannot decode map value for field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                        if (e instanceof Error && e.message.length > 0) {
+                            m += `: ${e.message}`;
+                        }
+                        throw new Error(m);
+                    }
+                    break;
+            }
+        }
+    }
+    else {
+        if (field.oneof) {
+            target = target[field.oneof.localName] = { case: localName };
+            localName = "value";
+        }
+        switch (field.kind) {
+            case "message":
+                const messageType = field.T;
+                if (jsonValue === null &&
+                    messageType.typeName != "google.protobuf.Value") {
+                    return;
+                }
+                let currentValue = target[localName];
+                target[localName] = currentValue = messageType.fromJson(jsonValue, options);
+                if (messageType.fieldWrapper && !field.oneof) {
+                    target[localName] = messageType.fieldWrapper.unwrapField(currentValue);
+                }
+                break;
+            case "enum":
+                const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, false);
+                switch (enumValue) {
+                    case tokenNull:
+                        clearField(field, target);
+                        break;
+                    case tokenIgnoredUnknownEnum:
+                        break;
+                    default:
+                        target[localName] = enumValue;
+                        break;
+                }
+                break;
+            case "scalar":
+                try {
+                    const scalarValue = readScalar(field.T, jsonValue, field.L, false);
+                    switch (scalarValue) {
+                        case tokenNull:
+                            clearField(field, target);
+                            break;
+                        default:
+                            target[localName] = scalarValue;
+                            break;
+                    }
+                }
+                catch (e) {
+                    let m = `cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                    if (e instanceof Error && e.message.length > 0) {
+                        m += `: ${e.message}`;
+                    }
+                    throw new Error(m);
+                }
+                break;
+        }
+    }
+}
+const tokenNull = Symbol();
+const tokenIgnoredUnknownEnum = Symbol();
+function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
+    if (json === null) {
+        if (type.typeName == "google.protobuf.NullValue") {
+            return 0; // google.protobuf.NullValue.NULL_VALUE = 0
+        }
+        return nullAsZeroValue ? type.values[0].no : tokenNull;
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (typeof json) {
+        case "number":
+            if (Number.isInteger(json)) {
+                return json;
+            }
+            break;
+        case "string":
+            const value = type.findName(json);
+            if (value !== undefined) {
+                return value.no;
+            }
+            if (ignoreUnknownFields) {
+                return tokenIgnoredUnknownEnum;
+            }
+            break;
+    }
+    throw new Error(`cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`);
+}
+function readScalar(type, json, longType, nullAsZeroValue) {
+    if (json === null) {
+        if (nullAsZeroValue) {
+            return (0, scalar_js_1.scalarZeroValue)(type, longType);
+        }
+        return tokenNull;
+    }
+    // every valid case in the switch below returns, and every fall
+    // through is regarded as a failure.
+    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 protobuf_1.ScalarType.DOUBLE:
+        case protobuf_1.ScalarType.FLOAT:
+            if (json === "NaN")
+                return Number.NaN;
+            if (json === "Infinity")
+                return Number.POSITIVE_INFINITY;
+            if (json === "-Infinity")
+                return Number.NEGATIVE_INFINITY;
+            if (json === "") {
+                // empty string is not a number
+                break;
+            }
+            if (typeof json == "string" && json.trim().length !== json.length) {
+                // extra whitespace
+                break;
+            }
+            if (typeof json != "string" && typeof json != "number") {
+                break;
+            }
+            const float = Number(json);
+            if (Number.isNaN(float)) {
+                // not a number
+                break;
+            }
+            if (!Number.isFinite(float)) {
+                // infinity and -infinity are handled by string representation above, so this is an error
+                break;
+            }
+            if (type == protobuf_1.ScalarType.FLOAT)
+                (0, assert_js_1.assertFloat32)(float);
+            return float;
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case protobuf_1.ScalarType.INT32:
+        case protobuf_1.ScalarType.FIXED32:
+        case protobuf_1.ScalarType.SFIXED32:
+        case protobuf_1.ScalarType.SINT32:
+        case protobuf_1.ScalarType.UINT32:
+            let int32;
+            if (typeof json == "number")
+                int32 = json;
+            else if (typeof json == "string" && json.length > 0) {
+                if (json.trim().length === json.length)
+                    int32 = Number(json);
+            }
+            if (int32 === undefined)
+                break;
+            if (type == protobuf_1.ScalarType.UINT32 || type == protobuf_1.ScalarType.FIXED32)
+                (0, assert_js_1.assertUInt32)(int32);
+            else
+                (0, assert_js_1.assertInt32)(int32);
+            return int32;
+        // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
+        case protobuf_1.ScalarType.INT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.SINT64:
+            if (typeof json != "number" && typeof json != "string")
+                break;
+            const long = protobuf_1.protoInt64.parse(json);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            return longType ? long.toString() : long;
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.UINT64:
+            if (typeof json != "number" && typeof json != "string")
+                break;
+            const uLong = protobuf_1.protoInt64.uParse(json);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            return longType ? uLong.toString() : uLong;
+        // bool:
+        case protobuf_1.ScalarType.BOOL:
+            if (typeof json !== "boolean")
+                break;
+            return json;
+        // string:
+        case protobuf_1.ScalarType.STRING:
+            if (typeof json !== "string") {
+                break;
+            }
+            // A string must always contain UTF-8 encoded or 7-bit ASCII.
+            // We validate with encodeURIComponent, which appears to be the fastest widely available option.
+            try {
+                encodeURIComponent(json);
+            }
+            catch (e) {
+                throw new Error("invalid UTF8");
+            }
+            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 protobuf_1.ScalarType.BYTES:
+            if (json === "")
+                return new Uint8Array(0);
+            if (typeof json !== "string")
+                break;
+            return protobuf_1.protoBase64.dec(json);
+    }
+    throw new Error();
+}
+function readMapKey(type, json) {
+    if (type === protobuf_1.ScalarType.BOOL) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (json) {
+            case "true":
+                json = true;
+                break;
+            case "false":
+                json = false;
+                break;
+        }
+    }
+    return readScalar(type, json, protobuf_1.LongType.BIGINT, true).toString();
+}
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+function clearField(field, target) {
+    const localName = field.localName;
+    const implicitPresence = !field.opt && !field.req;
+    if (field.repeated) {
+        target[localName] = [];
+    }
+    else if (field.oneof) {
+        target[field.oneof.localName] = { case: undefined };
+    }
+    else {
+        switch (field.kind) {
+            case "map":
+                target[localName] = {};
+                break;
+            case "enum":
+                target[localName] = implicitPresence ? field.T.values[0].no : undefined;
+                break;
+            case "scalar":
+                target[localName] = implicitPresence
+                    ? (0, scalar_js_1.scalarZeroValue)(field.T, field.L)
+                    : undefined;
+                break;
+            case "message":
+                target[localName] = undefined;
+                break;
+        }
+    }
+}
+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") {
+        // maps are {}, repeated fields are []
+        return true;
+    }
+    if (field.oneof) {
+        // oneof fields are never emitted
+        return false;
+    }
+    if (field.kind == "message") {
+        // singular message field are allowed to emit JSON null, but we do not
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (field.opt || field.req) {
+        // the field uses explicit presence, so we cannot emit a zero value
+        return false;
+    }
+    return true;
+}
+function writeField(field, value, options) {
+    if (field.kind == "map") {
+        (0, assert_js_1.assert)(typeof value == "object" && value != null);
+        const jsonObj = {};
+        const entries = Object.entries(value);
+        switch (field.V.kind) {
+            case "scalar":
+                for (const [entryKey, entryValue] of entries) {
+                    jsonObj[entryKey.toString()] = writeScalar(field.V.T, entryValue); // JSON standard allows only (double quoted) string as property key
+                }
+                break;
+            case "message":
+                for (const [entryKey, entryValue] of entries) {
+                    // JSON standard allows only (double quoted) string as property key
+                    jsonObj[entryKey.toString()] = field.V.T.toJson(entryValue, options);
+                }
+                break;
+            case "enum":
+                const enumType = field.V.T;
+                for (const [entryKey, entryValue] of entries) {
+                    // JSON standard allows only (double quoted) string as property key
+                    jsonObj[entryKey.toString()] = writeEnum(enumType, entryValue, options.enumAsInteger);
+                }
+                break;
+        }
+        return options.emitDefaultValues || entries.length > 0
+            ? jsonObj
+            : undefined;
+    }
+    if (field.repeated) {
+        (0, assert_js_1.assert)(Array.isArray(value));
+        const jsonArr = [];
+        switch (field.kind) {
+            case "scalar":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(writeScalar(field.T, value[i]));
+                }
+                break;
+            case "enum":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(writeEnum(field.T, value[i], options.enumAsInteger));
+                }
+                break;
+            case "message":
+                for (let i = 0; i < value.length; i++) {
+                    jsonArr.push(value[i].toJson(options));
+                }
+                break;
+        }
+        return options.emitDefaultValues || jsonArr.length > 0
+            ? jsonArr
+            : undefined;
+    }
+    switch (field.kind) {
+        case "scalar":
+            return writeScalar(field.T, value);
+        case "enum":
+            return writeEnum(field.T, value, options.enumAsInteger);
+        case "message":
+            return (0, field_wrapper_js_1.wrapField)(field.T.fieldWrapper, value).toJson(options);
+    }
+}
+function writeScalar(type, value) {
+    switch (type) {
+        // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+        case protobuf_1.ScalarType.INT32:
+        case protobuf_1.ScalarType.SFIXED32:
+        case protobuf_1.ScalarType.SINT32:
+        case protobuf_1.ScalarType.FIXED32:
+        case protobuf_1.ScalarType.UINT32:
+            (0, assert_js_1.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 protobuf_1.ScalarType.FLOAT:
+        // assertFloat32(value);
+        case protobuf_1.ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+            (0, assert_js_1.assert)(typeof value == "number");
+            if (Number.isNaN(value))
+                return "NaN";
+            if (value === Number.POSITIVE_INFINITY)
+                return "Infinity";
+            if (value === Number.NEGATIVE_INFINITY)
+                return "-Infinity";
+            return value;
+        // string:
+        case protobuf_1.ScalarType.STRING:
+            (0, assert_js_1.assert)(typeof value == "string");
+            return value;
+        // bool:
+        case protobuf_1.ScalarType.BOOL:
+            (0, assert_js_1.assert)(typeof value == "boolean");
+            return value;
+        // JSON value will be a decimal string. Either numbers or strings are accepted.
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.INT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.SINT64:
+            (0, assert_js_1.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 protobuf_1.ScalarType.BYTES:
+            (0, assert_js_1.assert)(value instanceof Uint8Array);
+            return protobuf_1.protoBase64.enc(value);
+    }
+}
+function writeEnum(type, value, enumAsInteger) {
+    (0, assert_js_1.assert)(typeof value == "number");
+    if (type.typeName == "google.protobuf.NullValue") {
+        return null;
+    }
+    if (enumAsInteger) {
+        return value;
+    }
+    const val = type.findNumber(value);
+    return val?.name ?? value; // if we don't know the enum value, just return the number
+}