@bufbuild/protobuf 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/cjs/reflect/reflect.js

@@ -14,6 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reflectMap = exports.reflectList = exports.reflect = void 0;
+const descriptors_js_1 = require("../descriptors.js");
 const reflect_check_js_1 = require("./reflect-check.js");
 const error_js_1 = require("./error.js");
 const unsafe_js_1 = require("./unsafe.js");
@@ -22,124 +23,131 @@ const wrappers_js_1 = require("../wkt/wrappers.js");
 const scalar_js_1 = require("./scalar.js");
 const proto_int64_js_1 = require("../proto-int64.js");
 const guard_js_1 = require("./guard.js");
+/**
+ * Create a ReflectMessage.
+ */
 function reflect(messageDesc, message, 
 // TODO either remove this option, or support it in reflect-list and reflect-map as well
 opt) {
-    message !== null && message !== void 0 ? message : (message = (0, create_js_1.create)(messageDesc));
-    const check = (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true;
-    let fieldsByNumber;
-    let sortedFields;
-    return {
-        message,
-        [unsafe_js_1.unsafeLocal]: message,
-        desc: messageDesc,
-        fields: messageDesc.fields,
-        oneofs: messageDesc.oneofs,
-        members: messageDesc.members,
-        get sortedFields() {
-            return (sortedFields !== null && sortedFields !== void 0 ? sortedFields : (sortedFields = messageDesc.fields
-                .concat()
-                .sort((a, b) => a.number - b.number)));
-        },
-        findNumber(number) {
-            if (!fieldsByNumber) {
-                fieldsByNumber = new Map(messageDesc.fields.map((f) => [f.number, f]));
-            }
-            return fieldsByNumber.get(number);
-        },
-        oneofCase(oneof) {
-            assertOwn(message, oneof);
-            return (0, unsafe_js_1.unsafeOneofCase)(message, oneof);
-        },
-        isSet(field) {
-            assertOwn(message, field);
-            return (0, unsafe_js_1.unsafeIsSet)(message, field);
-        },
-        clear(field) {
-            assertOwn(message, field);
-            (0, unsafe_js_1.unsafeClear)(message, field);
-        },
-        get(field) {
-            assertOwn(message, field);
-            let value = (0, unsafe_js_1.unsafeGet)(message, field);
-            switch (field.fieldKind) {
-                case "list":
-                    return reflectList(field, value);
-                case "map":
-                    // TODO fix types
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                    return reflectMap(field, value); // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
-                case "message":
-                    if (value !== undefined &&
-                        !field.oneof &&
-                        (0, wrappers_js_1.isWrapperDesc)(field.message)) {
-                        value = {
-                            $typeName: field.message.typeName,
-                            value: longToReflect(field.message.fields[0], value),
-                        };
-                    }
-                    return reflect(field.message, value);
-                case "scalar":
-                    return longToReflect(field, value);
-                case "enum":
-                    return value;
-            }
-        },
-        set(field, value) {
-            assertOwn(message, field);
-            if (check) {
-                const err = (0, reflect_check_js_1.checkField)(field, value);
-                if (err) {
-                    return err;
+    return new ReflectMessageImpl(messageDesc, message, (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true);
+}
+exports.reflect = reflect;
+class ReflectMessageImpl {
+    get sortedFields() {
+        var _a;
+        return ((_a = this._sortedFields) !== null && _a !== void 0 ? _a : (this._sortedFields = this.desc.fields
+            .concat()
+            .sort((a, b) => a.number - b.number)));
+    }
+    constructor(messageDesc, message, 
+    // TODO either remove this option, or support it in reflect-list and reflect-map as well
+    check = true) {
+        this.check = check;
+        this.desc = messageDesc;
+        this.message = this[unsafe_js_1.unsafeLocal] = message !== null && message !== void 0 ? message : (0, create_js_1.create)(messageDesc);
+        this.fields = messageDesc.fields;
+        this.oneofs = messageDesc.oneofs;
+        this.members = messageDesc.members;
+    }
+    findNumber(number) {
+        if (!this._fieldsByNumber) {
+            this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+        }
+        return this._fieldsByNumber.get(number);
+    }
+    oneofCase(oneof) {
+        assertOwn(this.message, oneof);
+        return (0, unsafe_js_1.unsafeOneofCase)(this.message, oneof);
+    }
+    isSet(field) {
+        assertOwn(this.message, field);
+        return (0, unsafe_js_1.unsafeIsSet)(this.message, field);
+    }
+    clear(field) {
+        assertOwn(this.message, field);
+        (0, unsafe_js_1.unsafeClear)(this.message, field);
+    }
+    get(field) {
+        assertOwn(this.message, field);
+        let value = (0, unsafe_js_1.unsafeGet)(this.message, field);
+        switch (field.fieldKind) {
+            case "list":
+                return new ReflectListImpl(field, value, this.check);
+            case "map":
+                // TODO fix types
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return reflectMap(field, value, this.check); // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+            case "message":
+                if (value !== undefined &&
+                    !field.oneof &&
+                    (0, wrappers_js_1.isWrapperDesc)(field.message)) {
+                    value = {
+                        $typeName: field.message.typeName,
+                        value: longToReflect(field.message.fields[0], value),
+                    };
                 }
+                return new ReflectMessageImpl(field.message, value, this.check);
+            case "scalar":
+                return (value === undefined
+                    ? (0, scalar_js_1.scalarZeroValue)(field.scalar, false)
+                    : longToReflect(field, value));
+            case "enum":
+                return (value !== null && value !== void 0 ? value : field.enum.values[0].number);
+        }
+    }
+    set(field, value) {
+        assertOwn(this.message, field);
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkField)(field, value);
+            if (err) {
+                return err;
             }
-            let local = value;
-            if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
-                local = value[unsafe_js_1.unsafeLocal];
-            }
-            else if ((0, guard_js_1.isReflectMessage)(value)) {
-                const msg = value.message;
-                local = !field.oneof && (0, wrappers_js_1.isWrapper)(msg) ? msg.value : msg;
-            }
-            else {
-                local = longToLocal(field, value);
-            }
-            (0, unsafe_js_1.unsafeSet)(message, field, local);
-            return undefined;
-        },
-        addListItem(field, value) {
-            assertOwn(message, field);
-            assertKind(field, "list");
-            if (check) {
-                if ((0, reflect_check_js_1.checkListItem)(field, 0, value)) {
-                    const arr = (0, unsafe_js_1.unsafeGet)(message, field);
-                    return (0, reflect_check_js_1.checkListItem)(field, arr.length, value);
-                }
+        }
+        let local;
+        if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
+            local = value[unsafe_js_1.unsafeLocal];
+        }
+        else if ((0, guard_js_1.isReflectMessage)(value)) {
+            const msg = value.message;
+            local = !field.oneof && (0, wrappers_js_1.isWrapper)(msg) ? msg.value : msg;
+        }
+        else {
+            local = longToLocal(field, value);
+        }
+        (0, unsafe_js_1.unsafeSet)(this.message, field, local);
+        return undefined;
+    }
+    addListItem(field, value) {
+        assertOwn(this.message, field);
+        assertKind(field, "list");
+        if (this.check) {
+            if ((0, reflect_check_js_1.checkListItem)(field, 0, value)) {
+                const arr = (0, unsafe_js_1.unsafeGet)(this.message, field);
+                return (0, reflect_check_js_1.checkListItem)(field, arr.length, value);
             }
-            (0, unsafe_js_1.unsafeAddListItem)(message, field, listItemToLocal(field, value));
-            return undefined;
-        },
-        setMapEntry(field, key, value) {
-            assertOwn(message, field);
-            assertKind(field, "map");
-            if (check) {
-                const err = (0, reflect_check_js_1.checkMapEntry)(field, key, value);
-                if (err) {
-                    return err;
-                }
+        }
+        (0, unsafe_js_1.unsafeAddListItem)(this.message, field, listItemToLocal(field, value));
+        return undefined;
+    }
+    setMapEntry(field, key, value) {
+        assertOwn(this.message, field);
+        assertKind(field, "map");
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkMapEntry)(field, key, value);
+            if (err) {
+                return err;
             }
-            (0, unsafe_js_1.unsafeSetMapEntry)(message, field, mapKeyToLocal(key), mapValueToLocal(field, value));
-            return undefined;
-        },
-        getUnknown() {
-            return message.$unknown;
-        },
-        setUnknown(value) {
-            message.$unknown = value;
-        },
-    };
+        }
+        (0, unsafe_js_1.unsafeSetMapEntry)(this.message, field, mapKeyToLocal(key), mapValueToLocal(field, value));
+        return undefined;
+    }
+    getUnknown() {
+        return this.message.$unknown;
+    }
+    setUnknown(value) {
+        this.message.$unknown = value;
+    }
 }
-exports.reflect = reflect;
 function assertKind(field, kind) {
     if (field.fieldKind != kind) {
         throw new error_js_1.FieldError(field, `${field.toString()} is ${field.fieldKind}`, "ForeignFieldError");
@@ -150,144 +158,166 @@ function assertOwn(owner, member) {
         throw new error_js_1.FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
     }
 }
-function reflectList(field, unsafeInput) {
-    const arr = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [];
-    return {
-        [unsafe_js_1.unsafeLocal]: arr,
-        field() {
-            return field;
-        },
-        get size() {
-            return arr.length;
-        },
-        get(index) {
-            const item = arr[index];
-            return item === undefined
-                ? undefined
-                : listItemToReflect(field, item);
-        },
-        set(index, item) {
-            if (index < 0 || index >= arr.length) {
-                return new error_js_1.FieldError(field, `list item #${index + 1}: out of range`);
-            }
-            const err = (0, reflect_check_js_1.checkListItem)(field, index, item);
-            if (!err) {
-                arr[index] = listItemToLocal(field, item);
-            }
-            return err;
-        },
-        add(...items) {
-            let err;
-            for (let i = 0; i < items.length && !err; i++) {
-                err = (0, reflect_check_js_1.checkListItem)(field, arr.length + i, items[i]);
-            }
-            if (!err) {
-                for (const item of items) {
-                    arr.push(listItemToLocal(field, item));
-                }
-            }
-            return err;
-        },
-        clear() {
-            arr.splice(0, arr.length);
-        },
-        [Symbol.iterator]() {
-            return this.values();
-        },
-        keys() {
-            return arr.keys();
-        },
-        *values() {
-            for (const item of arr) {
-                yield listItemToReflect(field, item);
-            }
-        },
-        *entries() {
-            for (let i = 0; i < arr.length; i++) {
-                yield [i, listItemToReflect(field, arr[i])];
-            }
-        },
-    };
+/**
+ * Create a ReflectList.
+ */
+function reflectList(field, unsafeInput, check = true) {
+    return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
 }
 exports.reflectList = reflectList;
-function reflectMap(field, unsafeInput) {
-    const obj = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
-    return {
-        [unsafe_js_1.unsafeLocal]: obj,
-        field() {
-            return field;
-        },
-        set(key, value) {
-            const err = (0, reflect_check_js_1.checkMapEntry)(field, key, value);
-            if (!err) {
-                obj[mapKeyToLocal(key)] = mapValueToLocal(field, value);
-            }
-            return err;
-        },
-        delete(key) {
-            const k = mapKeyToLocal(key);
-            const has = Object.prototype.hasOwnProperty.call(obj, k);
-            if (has) {
-                delete obj[k];
-            }
-            return has;
-        },
-        clear() {
-            for (const key of Object.keys(obj)) {
-                delete obj[key];
-            }
-        },
-        get(key) {
-            let val = obj[mapKeyToLocal(key)];
-            if (val !== undefined) {
-                val = mapValueToReflect(field, val);
-            }
-            return val;
-        },
-        has(key) {
-            return Object.prototype.hasOwnProperty.call(obj, mapKeyToLocal(key));
-        },
-        *keys() {
-            for (const objKey of Object.keys(obj)) {
-                yield mapKeyToReflect(objKey, field.mapKey);
-            }
-        },
-        *entries() {
-            for (const objEntry of Object.entries(obj)) {
-                yield [
-                    mapKeyToReflect(objEntry[0], field.mapKey),
-                    mapValueToReflect(field, objEntry[1]),
-                ];
-            }
-        },
-        [Symbol.iterator]() {
-            return this.entries();
-        },
-        get size() {
-            return Object.keys(obj).length;
-        },
-        *values() {
-            for (const val of Object.values(obj)) {
-                yield mapValueToReflect(field, val);
+class ReflectListImpl {
+    field() {
+        return this._field;
+    }
+    get size() {
+        return this._arr.length;
+    }
+    constructor(field, unsafeInput, check) {
+        this._field = field;
+        this._arr = this[unsafe_js_1.unsafeLocal] = unsafeInput;
+        this.check = check;
+    }
+    get(index) {
+        const item = this._arr[index];
+        return item === undefined
+            ? undefined
+            : listItemToReflect(this._field, item, this.check);
+    }
+    set(index, item) {
+        if (index < 0 || index >= this._arr.length) {
+            return new error_js_1.FieldError(this._field, `list item #${index + 1}: out of range`);
+        }
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkListItem)(this._field, index, item);
+            if (err) {
+                return err;
             }
-        },
-        forEach(callbackfn, thisArg) {
-            for (const mapEntry of this.entries()) {
-                callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+        }
+        this._arr[index] = listItemToLocal(this._field, item);
+        return undefined;
+    }
+    add(...items) {
+        if (this.check) {
+            for (let i = 0; i < items.length; i++) {
+                const err = (0, reflect_check_js_1.checkListItem)(this._field, this._arr.length + i, items[i]);
+                if (err) {
+                    return err;
+                }
             }
-        },
-    };
+        }
+        for (const item of items) {
+            this._arr.push(listItemToLocal(this._field, item));
+        }
+        return undefined;
+    }
+    clear() {
+        this._arr.splice(0, this._arr.length);
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    keys() {
+        return this._arr.keys();
+    }
+    *values() {
+        for (const item of this._arr) {
+            yield listItemToReflect(this._field, item, this.check);
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._arr.length; i++) {
+            yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+        }
+    }
+}
+/**
+ * Create a ReflectMap.
+ */
+function reflectMap(field, unsafeInput, check = true) {
+    return new ReflectMapImpl(field, unsafeInput, check);
 }
 exports.reflectMap = reflectMap;
+class ReflectMapImpl {
+    constructor(field, unsafeInput, check = true) {
+        this.obj = this[unsafe_js_1.unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+        this.check = check;
+        this._field = field;
+    }
+    field() {
+        return this._field;
+    }
+    set(key, value) {
+        if (this.check) {
+            const err = (0, reflect_check_js_1.checkMapEntry)(this._field, key, value);
+            if (err) {
+                return err;
+            }
+        }
+        this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+        return undefined;
+    }
+    delete(key) {
+        const k = mapKeyToLocal(key);
+        const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+        if (has) {
+            delete this.obj[k];
+        }
+        return has;
+    }
+    clear() {
+        for (const key of Object.keys(this.obj)) {
+            delete this.obj[key];
+        }
+    }
+    get(key) {
+        let val = this.obj[mapKeyToLocal(key)];
+        if (val !== undefined) {
+            val = mapValueToReflect(this._field, val, this.check);
+        }
+        return val;
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+    }
+    *keys() {
+        for (const objKey of Object.keys(this.obj)) {
+            yield mapKeyToReflect(objKey, this._field.mapKey);
+        }
+    }
+    *entries() {
+        for (const objEntry of Object.entries(this.obj)) {
+            yield [
+                mapKeyToReflect(objEntry[0], this._field.mapKey),
+                mapValueToReflect(this._field, objEntry[1], this.check),
+            ];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get size() {
+        return Object.keys(this.obj).length;
+    }
+    *values() {
+        for (const val of Object.values(this.obj)) {
+            yield mapValueToReflect(this._field, val, this.check);
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        for (const mapEntry of this.entries()) {
+            callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+        }
+    }
+}
 function listItemToLocal(field, value) {
     if ((0, guard_js_1.isReflectMessage)(value)) {
         return value.message;
     }
     return longToLocal(field, value);
 }
-function listItemToReflect(field, value) {
+function listItemToReflect(field, value, check) {
     if (field.listKind == "message") {
-        return reflect(field.message, value);
+        return new ReflectMessageImpl(field.message, value, check);
     }
     return longToReflect(field, value);
 }
@@ -297,9 +327,9 @@ function mapValueToLocal(field, value) {
     }
     return longToLocal(field, value);
 }
-function mapValueToReflect(field, value) {
+function mapValueToReflect(field, value, check) {
     if (field.mapKind == "message") {
-        return reflect(field.message, value);
+        return new ReflectMessageImpl(field.message, value, check);
     }
     return value;
 }
@@ -313,20 +343,20 @@ function mapKeyToLocal(key) {
  */
 function mapKeyToReflect(key, type) {
     switch (type) {
-        case scalar_js_1.ScalarType.STRING:
+        case descriptors_js_1.ScalarType.STRING:
             return key;
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.UINT32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32: {
+        case descriptors_js_1.ScalarType.INT32:
+        case descriptors_js_1.ScalarType.FIXED32:
+        case descriptors_js_1.ScalarType.UINT32:
+        case descriptors_js_1.ScalarType.SFIXED32:
+        case descriptors_js_1.ScalarType.SINT32: {
             const n = Number.parseInt(key);
             if (Number.isFinite(n)) {
                 return n;
             }
             break;
         }
-        case scalar_js_1.ScalarType.BOOL:
+        case descriptors_js_1.ScalarType.BOOL:
             switch (key) {
                 case "true":
                     return true;
@@ -334,8 +364,8 @@ function mapKeyToReflect(key, type) {
                     return false;
             }
             break;
-        case scalar_js_1.ScalarType.UINT64:
-        case scalar_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+        case descriptors_js_1.ScalarType.FIXED64:
             try {
                 return proto_int64_js_1.protoInt64.uParse(key);
             }
@@ -356,54 +386,50 @@ function mapKeyToReflect(key, type) {
     return key;
 }
 function longToReflect(field, value) {
-    if (field.scalar !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-        switch (field.scalar) {
-            case scalar_js_1.ScalarType.INT64:
-            case scalar_js_1.ScalarType.SFIXED64:
-            case scalar_js_1.ScalarType.SINT64:
-                if ("longType" in field &&
-                    field.longType == scalar_js_1.LongType.STRING &&
-                    typeof value == "string") {
-                    value = proto_int64_js_1.protoInt64.parse(value);
-                }
-                break;
-            case scalar_js_1.ScalarType.FIXED64:
-            case scalar_js_1.ScalarType.UINT64:
-                if ("longType" in field &&
-                    field.longType == scalar_js_1.LongType.STRING &&
-                    typeof value == "string") {
-                    value = proto_int64_js_1.protoInt64.uParse(value);
-                }
-                break;
-        }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if ("longAsString" in field &&
+                field.longAsString &&
+                typeof value == "string") {
+                value = proto_int64_js_1.protoInt64.parse(value);
+            }
+            break;
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+            if ("longAsString" in field &&
+                field.longAsString &&
+                typeof value == "string") {
+                value = proto_int64_js_1.protoInt64.uParse(value);
+            }
+            break;
     }
     return value;
 }
 function longToLocal(field, value) {
-    if (field.scalar !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-        switch (field.scalar) {
-            case scalar_js_1.ScalarType.INT64:
-            case scalar_js_1.ScalarType.SFIXED64:
-            case scalar_js_1.ScalarType.SINT64:
-                if ("longType" in field && field.longType == scalar_js_1.LongType.STRING) {
-                    value = String(value);
-                }
-                else if (typeof value == "string" || typeof value == "number") {
-                    value = proto_int64_js_1.protoInt64.parse(value);
-                }
-                break;
-            case scalar_js_1.ScalarType.FIXED64:
-            case scalar_js_1.ScalarType.UINT64:
-                if ("longType" in field && field.longType == scalar_js_1.LongType.STRING) {
-                    value = String(value);
-                }
-                else if (typeof value == "string" || typeof value == "number") {
-                    value = proto_int64_js_1.protoInt64.uParse(value);
-                }
-                break;
-        }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case descriptors_js_1.ScalarType.INT64:
+        case descriptors_js_1.ScalarType.SFIXED64:
+        case descriptors_js_1.ScalarType.SINT64:
+            if ("longAsString" in field && field.longAsString) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = proto_int64_js_1.protoInt64.parse(value);
+            }
+            break;
+        case descriptors_js_1.ScalarType.FIXED64:
+        case descriptors_js_1.ScalarType.UINT64:
+            if ("longAsString" in field && field.longAsString) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = proto_int64_js_1.protoInt64.uParse(value);
+            }
+            break;
     }
     return value;
 }