@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/esm/codegenv1/symbols.js

@@ -0,0 +1,55 @@
+// 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.
+export const packageName = "@bufbuild/protobuf";
+export const wktPublicImportPaths = {
+    "google/protobuf/compiler/plugin.proto": packageName + "/wkt",
+    "google/protobuf/any.proto": packageName + "/wkt",
+    "google/protobuf/api.proto": packageName + "/wkt",
+    "google/protobuf/descriptor.proto": packageName + "/wkt",
+    "google/protobuf/duration.proto": packageName + "/wkt",
+    "google/protobuf/empty.proto": packageName + "/wkt",
+    "google/protobuf/field_mask.proto": packageName + "/wkt",
+    "google/protobuf/source_context.proto": packageName + "/wkt",
+    "google/protobuf/struct.proto": packageName + "/wkt",
+    "google/protobuf/timestamp.proto": packageName + "/wkt",
+    "google/protobuf/type.proto": packageName + "/wkt",
+    "google/protobuf/wrappers.proto": packageName + "/wkt",
+};
+// prettier-ignore
+export const symbols = {
+    isMessage: { typeOnly: false, bootstrapWktFrom: "../../is-message.js", from: packageName },
+    Message: { typeOnly: true, bootstrapWktFrom: "../../types.js", from: packageName },
+    create: { typeOnly: false, bootstrapWktFrom: "../../create.js", from: packageName },
+    fromJson: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: packageName },
+    fromJsonString: { typeOnly: false, bootstrapWktFrom: "../../from-json.js", from: packageName },
+    fromBinary: { typeOnly: false, bootstrapWktFrom: "../../from-binary.js", from: packageName },
+    toBinary: { typeOnly: false, bootstrapWktFrom: "../../to-binary.js", from: packageName },
+    toJson: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: packageName },
+    toJsonString: { typeOnly: false, bootstrapWktFrom: "../../to-json.js", from: packageName },
+    protoInt64: { typeOnly: false, bootstrapWktFrom: "../../proto-int64.js", from: packageName },
+    codegen: {
+        boot: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/boot.js", from: packageName + "/codegenv1" },
+        fileDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/file.js", from: packageName + "/codegenv1" },
+        enumDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: packageName + "/codegenv1" },
+        extDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/extension.js", from: packageName + "/codegenv1" },
+        messageDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/message.js", from: packageName + "/codegenv1" },
+        serviceDesc: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/service.js", from: packageName + "/codegenv1" },
+        tsEnum: { typeOnly: false, bootstrapWktFrom: "../../codegenv1/enum.js", from: packageName + "/codegenv1" },
+        GenDescFile: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" },
+        GenDescEnum: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" },
+        GenDescExtension: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" },
+        GenDescMessage: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" },
+        GenDescService: { typeOnly: true, bootstrapWktFrom: "../../codegenv1/types.js", from: packageName + "/codegenv1" },
+    },
+};

package/dist/esm/codegenv1/types.d.ts

@@ -0,0 +1,19 @@
+import type { Message } from "../types.js";
+import type { DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../desc-types.js";
+export type GenDescFile = DescFile;
+export type GenDescMessage<RuntimeShape extends Message> = DescMessage & brand<RuntimeShape>;
+export type GenDescEnum<RuntimeShape> = DescEnum & brand<RuntimeShape>;
+export type GenDescExtension<Extendee extends Message = Message, RuntimeShape = unknown> = DescExtension & brand<Extendee, RuntimeShape>;
+export type GenDescService<RuntimeShape extends GenDescServiceShape> = DescService & brand<RuntimeShape>;
+export type GenDescServiceShape = {
+    [localName: string]: {
+        kind: "unary" | "server_streaming" | "client_streaming" | "bidi_streaming";
+        I: Message;
+        O: Message;
+    };
+};
+declare class brand<A, B = unknown> {
+    protected a: A | boolean;
+    protected b: B | boolean;
+}
+export {};

package/dist/esm/{field-list.js → codegenv1/types.js}

@@ -11,4 +11,10 @@
 // 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.
+class brand {
+    constructor() {
+        this.a = false;
+        this.b = false;
+    }
+}
 export {};

package/dist/esm/create.d.ts

@@ -0,0 +1,9 @@
+import type { DescMessage } from "./desc-types.js";
+import type { MessageInitShape, MessageShape } from "./types.js";
+/**
+ * Create a new message instance.
+ *
+ * The second argument is an optional initializer object, where all fields are
+ * optional.
+ */
+export declare function create<Desc extends DescMessage>(messageDesc: Desc, init?: MessageInitShape<Desc>): MessageShape<Desc>;

package/dist/esm/create.js

@@ -0,0 +1,239 @@
+// 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.
+import { isMessage } from "./is-message.js";
+import { localName } from "./reflect/names.js";
+import { LongType, ScalarType, scalarZeroValue } from "./reflect/scalar.js";
+import { FieldError } from "./reflect/error.js";
+import { isObject } from "./reflect/guard.js";
+import { unsafeGet, unsafeOneofCase, unsafeSet } from "./reflect/unsafe.js";
+import { isWrapperDesc } from "./wkt/wrappers.js";
+// bootstrap-inject google.protobuf.Edition.EDITION_PROTO3: const $name: Edition.$localName = $number;
+const EDITION_PROTO3 = 999;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.EXPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const EXPLICIT = 1;
+// bootstrap-inject google.protobuf.FeatureSet.FieldPresence.IMPLICIT: const $name: FeatureSet_FieldPresence.$localName = $number;
+const IMPLICIT = 2;
+/**
+ * Create a new message instance.
+ *
+ * The second argument is an optional initializer object, where all fields are
+ * optional.
+ */
+export function create(messageDesc, init) {
+    if (isMessage(init, messageDesc)) {
+        return init;
+    }
+    const message = createZeroMessage(messageDesc);
+    if (init !== undefined) {
+        initMessage(messageDesc, message, init);
+    }
+    return message;
+}
+/**
+ * Sets field values from a MessageInitShape on a zero message.
+ */
+function initMessage(messageDesc, message, init) {
+    for (const member of messageDesc.members) {
+        let value = init[localName(member)];
+        if (value == null) {
+            // intentionally ignore undefined and null
+            continue;
+        }
+        let field;
+        if (member.kind == "oneof") {
+            const oneofField = unsafeOneofCase(init, member);
+            if (!oneofField) {
+                continue;
+            }
+            field = oneofField;
+            value = unsafeGet(init, oneofField);
+        }
+        else {
+            field = member;
+        }
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- no need to convert enum
+        switch (field.fieldKind) {
+            case "message":
+                if (isWrapperDesc(field.message)) {
+                    value = initScalar(field.message.fields[0], value);
+                }
+                else {
+                    value = toMessage(value, field.message);
+                }
+                break;
+            case "scalar":
+                value = initScalar(field, value);
+                break;
+            case "list":
+                value = initList(field, value);
+                break;
+            case "map":
+                value = initMap(field, value);
+                break;
+        }
+        unsafeSet(message, field, value);
+    }
+    return message;
+}
+function initScalar(field, value) {
+    if (field.scalar == ScalarType.BYTES) {
+        return toU8Arr(value);
+    }
+    return value;
+}
+function initMap(field, value) {
+    if (isObject(value)) {
+        if (field.scalar == ScalarType.BYTES) {
+            return convertObjectValues(value, toU8Arr);
+        }
+        if (field.mapKind == "message") {
+            return convertObjectValues(value, (val) => toMessage(val, field.message));
+        }
+    }
+    return value;
+}
+function initList(field, value) {
+    if (Array.isArray(value)) {
+        if (field.scalar == ScalarType.BYTES) {
+            return value.map(toU8Arr);
+        }
+        if (field.listKind == "message") {
+            return value.map((item) => toMessage(item, field.message));
+        }
+    }
+    return value;
+}
+function toMessage(value, message) {
+    if (!isMessage(value, message) && isObject(value)) {
+        return create(message, value);
+    }
+    return value;
+}
+// converts any ArrayLike<number> to Uint8Array if necessary.
+function toU8Arr(value) {
+    return Array.isArray(value) ? new Uint8Array(value) : value;
+}
+function convertObjectValues(obj, fn) {
+    const ret = {};
+    for (const entry of Object.entries(obj)) {
+        ret[entry[0]] = fn(entry[1]);
+    }
+    return ret;
+}
+const tokenZeroMessageField = Symbol();
+const messagePrototypes = new WeakMap();
+/**
+ * Create a zero message.
+ */
+function createZeroMessage(desc) {
+    let msg;
+    if (desc.file.edition == EDITION_PROTO3) {
+        // we special case proto3: since it does not have default values, we let
+        // the `optional` keyword generate an optional property.
+        msg = {};
+        for (const member of desc.members) {
+            if (member.kind == "field") {
+                if (member.fieldKind == "scalar" ||
+                    member.fieldKind == "enum" ||
+                    member.fieldKind == "message") {
+                    if (member.presence == EXPLICIT) {
+                        // skips message fields and optional scalar/enum
+                        continue;
+                    }
+                }
+            }
+            msg[localName(member)] = createZeroField(member);
+        }
+    }
+    else {
+        // for everything but proto3, we support default values, and track presence
+        // via the prototype chain
+        const cached = messagePrototypes.get(desc);
+        let prototype;
+        let members;
+        if (cached) {
+            ({ prototype, members } = cached);
+        }
+        else {
+            prototype = {};
+            members = new Set();
+            for (const member of desc.members) {
+                if (member.kind == "oneof") {
+                    // we can only put immutable values on the prototype,
+                    // oneof ADTs are mutable
+                    continue;
+                }
+                if (member.fieldKind != "scalar" && member.fieldKind != "enum") {
+                    // only scalar and enum values are immutable, map, list, and message
+                    // are not
+                    continue;
+                }
+                if (member.presence == IMPLICIT) {
+                    // implicit presence tracks field presence by zero values
+                    // e.g. 0, false, "", are unset, 1, true, "x" are set
+                    continue;
+                }
+                members.add(member);
+                prototype[localName(member)] = createZeroField(member);
+            }
+            messagePrototypes.set(desc, { prototype, members });
+        }
+        msg = Object.create(prototype);
+        for (const member of desc.members) {
+            if (members.has(member)) {
+                continue;
+            }
+            if (member.kind == "field") {
+                if (member.fieldKind == "message") {
+                    continue;
+                }
+                if (member.fieldKind == "scalar" || member.fieldKind == "enum") {
+                    if (member.presence != IMPLICIT) {
+                        continue;
+                    }
+                }
+            }
+            msg[localName(member)] = createZeroField(member);
+        }
+    }
+    msg.$typeName = desc.typeName;
+    return msg;
+}
+/**
+ * Returns a zero value for oneof groups, and for every field kind except
+ * messages. Scalar and enum fields can have default values.
+ */
+function createZeroField(field) {
+    if (field.kind == "oneof") {
+        return { case: undefined };
+    }
+    if (field.fieldKind == "list") {
+        return [];
+    }
+    if (field.fieldKind == "map") {
+        return {}; // Object.create(null) would be desirable here, but is unsupported by react https://react.dev/reference/react/use-server#serializable-parameters-and-return-values
+    }
+    if (field.fieldKind == "message") {
+        return tokenZeroMessageField;
+    }
+    const defaultValue = field.getDefaultValue();
+    if (defaultValue !== undefined) {
+        return field.fieldKind == "scalar" && field.longType == LongType.STRING
+            ? defaultValue.toString()
+            : defaultValue;
+    }
+    return field.fieldKind == "scalar"
+        ? scalarZeroValue(field.scalar, field.longType)
+        : field.enum.values[0].number;
+}