Erster Commit
This commit is contained in:
+247
@@ -0,0 +1,247 @@
|
||||
"use strict";
|
||||
// Copyright 2021-2024 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.
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.makeUtilCommon = void 0;
|
||||
const enum_js_1 = require("./enum.js");
|
||||
const scalars_js_1 = require("./scalars.js");
|
||||
const scalar_js_1 = require("../scalar.js");
|
||||
const is_message_js_1 = require("../is-message.js");
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
|
||||
function makeUtilCommon() {
|
||||
return {
|
||||
setEnumType: enum_js_1.setEnumType,
|
||||
initPartial(source, target) {
|
||||
if (source === undefined) {
|
||||
return;
|
||||
}
|
||||
const type = target.getType();
|
||||
for (const member of type.fields.byMember()) {
|
||||
const localName = member.localName, t = target, s = source;
|
||||
if (s[localName] == null) {
|
||||
// TODO if source is a Message instance, we should use isFieldSet() here to support future field presence
|
||||
continue;
|
||||
}
|
||||
switch (member.kind) {
|
||||
case "oneof":
|
||||
const sk = s[localName].case;
|
||||
if (sk === undefined) {
|
||||
continue;
|
||||
}
|
||||
const sourceField = member.findField(sk);
|
||||
let val = s[localName].value;
|
||||
if (sourceField &&
|
||||
sourceField.kind == "message" &&
|
||||
!(0, is_message_js_1.isMessage)(val, sourceField.T)) {
|
||||
val = new sourceField.T(val);
|
||||
}
|
||||
else if (sourceField &&
|
||||
sourceField.kind === "scalar" &&
|
||||
sourceField.T === scalar_js_1.ScalarType.BYTES) {
|
||||
val = toU8Arr(val);
|
||||
}
|
||||
t[localName] = { case: sk, value: val };
|
||||
break;
|
||||
case "scalar":
|
||||
case "enum":
|
||||
let copy = s[localName];
|
||||
if (member.T === scalar_js_1.ScalarType.BYTES) {
|
||||
copy = member.repeated
|
||||
? copy.map(toU8Arr)
|
||||
: toU8Arr(copy);
|
||||
}
|
||||
t[localName] = copy;
|
||||
break;
|
||||
case "map":
|
||||
switch (member.V.kind) {
|
||||
case "scalar":
|
||||
case "enum":
|
||||
if (member.V.T === scalar_js_1.ScalarType.BYTES) {
|
||||
for (const [k, v] of Object.entries(s[localName])) {
|
||||
t[localName][k] = toU8Arr(v);
|
||||
}
|
||||
}
|
||||
else {
|
||||
Object.assign(t[localName], s[localName]);
|
||||
}
|
||||
break;
|
||||
case "message":
|
||||
const messageType = member.V.T;
|
||||
for (const k of Object.keys(s[localName])) {
|
||||
let val = s[localName][k];
|
||||
if (!messageType.fieldWrapper) {
|
||||
// We only take partial input for messages that are not a wrapper type.
|
||||
// For those messages, we recursively normalize the partial input.
|
||||
val = new messageType(val);
|
||||
}
|
||||
t[localName][k] = val;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case "message":
|
||||
const mt = member.T;
|
||||
if (member.repeated) {
|
||||
t[localName] = s[localName].map((val) => (0, is_message_js_1.isMessage)(val, mt) ? val : new mt(val));
|
||||
}
|
||||
else {
|
||||
const val = s[localName];
|
||||
if (mt.fieldWrapper) {
|
||||
if (
|
||||
// We can't use BytesValue.typeName as that will create a circular import
|
||||
mt.typeName === "google.protobuf.BytesValue") {
|
||||
t[localName] = toU8Arr(val);
|
||||
}
|
||||
else {
|
||||
t[localName] = val;
|
||||
}
|
||||
}
|
||||
else {
|
||||
t[localName] = (0, is_message_js_1.isMessage)(val, mt) ? val : new mt(val);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
// TODO use isFieldSet() here to support future field presence
|
||||
equals(type, a, b) {
|
||||
if (a === b) {
|
||||
return true;
|
||||
}
|
||||
if (!a || !b) {
|
||||
return false;
|
||||
}
|
||||
return type.fields.byMember().every((m) => {
|
||||
const va = a[m.localName];
|
||||
const vb = b[m.localName];
|
||||
if (m.repeated) {
|
||||
if (va.length !== vb.length) {
|
||||
return false;
|
||||
}
|
||||
// eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
|
||||
switch (m.kind) {
|
||||
case "message":
|
||||
return va.every((a, i) => m.T.equals(a, vb[i]));
|
||||
case "scalar":
|
||||
return va.every((a, i) => (0, scalars_js_1.scalarEquals)(m.T, a, vb[i]));
|
||||
case "enum":
|
||||
return va.every((a, i) => (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, a, vb[i]));
|
||||
}
|
||||
throw new Error(`repeated cannot contain ${m.kind}`);
|
||||
}
|
||||
switch (m.kind) {
|
||||
case "message":
|
||||
let a = va;
|
||||
let b = vb;
|
||||
if (m.T.fieldWrapper) {
|
||||
if (a !== undefined && !(0, is_message_js_1.isMessage)(a)) {
|
||||
a = m.T.fieldWrapper.wrapField(a);
|
||||
}
|
||||
if (b !== undefined && !(0, is_message_js_1.isMessage)(b)) {
|
||||
b = m.T.fieldWrapper.wrapField(b);
|
||||
}
|
||||
}
|
||||
return m.T.equals(a, b);
|
||||
case "enum":
|
||||
return (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va, vb);
|
||||
case "scalar":
|
||||
return (0, scalars_js_1.scalarEquals)(m.T, va, vb);
|
||||
case "oneof":
|
||||
if (va.case !== vb.case) {
|
||||
return false;
|
||||
}
|
||||
const s = m.findField(va.case);
|
||||
if (s === undefined) {
|
||||
return true;
|
||||
}
|
||||
// eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
|
||||
switch (s.kind) {
|
||||
case "message":
|
||||
return s.T.equals(va.value, vb.value);
|
||||
case "enum":
|
||||
return (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va.value, vb.value);
|
||||
case "scalar":
|
||||
return (0, scalars_js_1.scalarEquals)(s.T, va.value, vb.value);
|
||||
}
|
||||
throw new Error(`oneof cannot contain ${s.kind}`);
|
||||
case "map":
|
||||
const keys = Object.keys(va).concat(Object.keys(vb));
|
||||
switch (m.V.kind) {
|
||||
case "message":
|
||||
const messageType = m.V.T;
|
||||
return keys.every((k) => messageType.equals(va[k], vb[k]));
|
||||
case "enum":
|
||||
return keys.every((k) => (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va[k], vb[k]));
|
||||
case "scalar":
|
||||
const scalarType = m.V.T;
|
||||
return keys.every((k) => (0, scalars_js_1.scalarEquals)(scalarType, va[k], vb[k]));
|
||||
}
|
||||
break;
|
||||
}
|
||||
});
|
||||
},
|
||||
// TODO use isFieldSet() here to support future field presence
|
||||
clone(message) {
|
||||
const type = message.getType(), target = new type(), any = target;
|
||||
for (const member of type.fields.byMember()) {
|
||||
const source = message[member.localName];
|
||||
let copy;
|
||||
if (member.repeated) {
|
||||
copy = source.map(cloneSingularField);
|
||||
}
|
||||
else if (member.kind == "map") {
|
||||
copy = any[member.localName];
|
||||
for (const [key, v] of Object.entries(source)) {
|
||||
copy[key] = cloneSingularField(v);
|
||||
}
|
||||
}
|
||||
else if (member.kind == "oneof") {
|
||||
const f = member.findField(source.case);
|
||||
copy = f
|
||||
? { case: source.case, value: cloneSingularField(source.value) }
|
||||
: { case: undefined };
|
||||
}
|
||||
else {
|
||||
copy = cloneSingularField(source);
|
||||
}
|
||||
any[member.localName] = copy;
|
||||
}
|
||||
for (const uf of type.runtime.bin.listUnknownFields(message)) {
|
||||
type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data);
|
||||
}
|
||||
return target;
|
||||
},
|
||||
};
|
||||
}
|
||||
exports.makeUtilCommon = makeUtilCommon;
|
||||
// clone a single field value - i.e. the element type of repeated fields, the value type of maps
|
||||
function cloneSingularField(value) {
|
||||
if (value === undefined) {
|
||||
return value;
|
||||
}
|
||||
if ((0, is_message_js_1.isMessage)(value)) {
|
||||
return value.clone();
|
||||
}
|
||||
if (value instanceof Uint8Array) {
|
||||
const c = new Uint8Array(value.byteLength);
|
||||
c.set(value);
|
||||
return c;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
// converts any ArrayLike<number> to Uint8Array if necessary.
|
||||
function toU8Arr(input) {
|
||||
return input instanceof Uint8Array ? input : new Uint8Array(input);
|
||||
}
|
||||
Reference in New Issue
Block a user