@code-yeongyu/senpi 2026.8.20-2 → 2026.8.20

package/node_modules/@bufbuild/protobuf/dist/esm/create.js

@@ -15,6 +15,7 @@ import { isMessage } from "./is-message.js";
 import { ScalarType, } from "./descriptors.js";
 import { scalarZeroValue } from "./reflect/scalar.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 = $number;
 const EDITION_PROTO3 = 999;
@@ -32,232 +33,182 @@ export function create(schema, init) {
     if (isMessage(init, schema)) {
         return init;
     }
-    return compiledCreate(schema)(init);
-}
-const compiledCreates = new WeakMap();
-/**
- * Return the compiled create function for a message, compiling it on first use. */
-function compiledCreate(desc) {
-    let compiled = compiledCreates.get(desc);
-    if (compiled === undefined) {
-        compiled = compileCreate(desc);
-        compiledCreates.set(desc, compiled);
+    const message = createZeroMessage(schema);
+    if (init !== undefined) {
+        initMessage(schema, message, init);
     }
-    return compiled;
-}
-/** Singular field: scalar, enum, or message. */
-const INIT_SINGULAR = 0;
-/** List field: a zero message has a fresh empty array. */
-const INIT_LIST = 1;
-/** Map field: a zero message has a fresh empty object. */
-const INIT_MAP = 2;
-/** Oneof group: the ADT is always stored, cases convert by case name. */
-const INIT_ONEOF = 3;
-/* Compile the create function for this message type. */
-function compileCreate(desc) {
-    const typeName = desc.typeName;
-    const { properties, prototype } = compileInitMessage(desc);
-    return (init) => {
-        let message;
-        if (prototype !== undefined) {
-            message = Object.create(prototype);
-            message.$typeName = typeName;
-        }
-        else {
-            message = { $typeName: typeName };
-        }
-        for (let i = 0; i < properties.length; i++) {
-            const property = properties[i];
-            const name = property.name;
-            const initValue = init === null || init === void 0 ? void 0 : init[name];
-            switch (property.kind) {
-                case INIT_SINGULAR:
-                    if (initValue != null) {
-                        message[name] =
-                            property.convert !== undefined
-                                ? property.convert(initValue)
-                                : initValue;
-                    }
-                    else if (property.constant !== undefined) {
-                        message[name] = property.constant;
-                    }
-                    break;
-                case INIT_LIST:
-                    message[name] =
-                        property.convert !== undefined && Array.isArray(initValue)
-                            ? initValue.map(property.convert)
-                            : (initValue !== null && initValue !== void 0 ? initValue : []);
-                    break;
-                case INIT_MAP:
-                    // Object.create(null) would be desirable for the fresh map, but is
-                    // unsupported by React:
-                    // https://react.dev/reference/react/use-server#serializable-parameters-and-return-values
-                    if (property.convert === undefined || !isObject(initValue)) {
-                        message[name] = initValue !== null && initValue !== void 0 ? initValue : {};
-                    }
-                    else {
-                        const converted = {};
-                        const keys = Object.keys(initValue);
-                        for (let k = 0; k < keys.length; k++) {
-                            converted[keys[k]] = property.convert(initValue[keys[k]]);
-                        }
-                        message[name] = converted;
-                    }
-                    break;
-                case INIT_ONEOF: {
-                    const oneofValue = initValue;
-                    if ((oneofValue === null || oneofValue === void 0 ? void 0 : oneofValue.case) != null) {
-                        const convert = property.convert.get(oneofValue.case);
-                        if (convert !== undefined) {
-                            message[name] = {
-                                case: oneofValue.case,
-                                value: convert(oneofValue.value),
-                            };
-                            break;
-                        }
-                    }
-                    message[name] = { case: undefined };
-                    break;
-                }
-            }
-        }
-        return message;
-    };
+    return message;
 }
 /**
- * Classify every member once, so that creating a message is a walk over a
- * compact list instead of a walk over the descriptor.
+ * Sets field values from a MessageInitShape on a zero message.
  */
-function compileInitMessage(desc) {
-    var _a, _b;
-    const properties = [];
-    const prototype = {};
-    const usePrototype = needsPrototypeChain(desc);
-    for (const member of desc.members) {
-        const name = member.localName;
-        if (member.kind == "oneof") {
-            properties.push({
-                name,
-                kind: INIT_ONEOF,
-                constant: undefined,
-                convert: compileConvertOneof(member),
-            });
+function initMessage(messageDesc, message, init) {
+    for (const member of messageDesc.members) {
+        let value = init[member.localName];
+        if (value == null) {
+            // intentionally ignore undefined and null
             continue;
         }
-        switch (member.fieldKind) {
-            case "message": {
-                // Singular message fields are absent from a zero message.
-                properties.push({
-                    name,
-                    kind: INIT_SINGULAR,
-                    constant: undefined,
-                    convert: compileConvertMessage(member),
-                });
-                break;
+        let field;
+        if (member.kind == "oneof") {
+            const oneofField = unsafeOneofCase(init, member);
+            if (!oneofField) {
+                continue;
             }
-            case "list": {
-                properties.push({
-                    name,
-                    kind: INIT_LIST,
-                    constant: undefined,
-                    convert: member.listKind == "message"
-                        ? ((_a = compileConvertMessage(member)) !== null && _a !== void 0 ? _a : ((value) => value))
-                        : member.scalar == ScalarType.BYTES
-                            ? toU8Arr
-                            : undefined,
-                });
+            field = oneofField;
+            value = unsafeGet(init, oneofField);
+        }
+        else {
+            field = member;
+        }
+        switch (field.fieldKind) {
+            case "message":
+                value = toMessage(field, value);
                 break;
-            }
-            case "map": {
-                properties.push({
-                    name,
-                    kind: INIT_MAP,
-                    constant: undefined,
-                    convert: member.mapKind == "message"
-                        ? ((_b = compileConvertMessage(member)) !== null && _b !== void 0 ? _b : ((value) => value))
-                        : member.scalar == ScalarType.BYTES
-                            ? toU8Arr
-                            : undefined,
-                });
+            case "scalar":
+                value = initScalar(field, value);
                 break;
-            }
-            default: {
-                const zeroValue = createZeroValue(member);
-                properties.push({
-                    name,
-                    kind: INIT_SINGULAR,
-                    constant: member.presence == IMPLICIT ? zeroValue : undefined,
-                    convert: member.fieldKind == "scalar" && member.scalar == ScalarType.BYTES
-                        ? toU8Arr
-                        : undefined,
-                });
-                if (usePrototype) {
-                    prototype[name] = zeroValue;
-                }
+            case "list":
+                value = initList(field, value);
+                break;
+            case "map":
+                value = initMap(field, value);
                 break;
-            }
         }
+        unsafeSet(message, field, value);
     }
-    return {
-        properties,
-        prototype: usePrototype ? prototype : undefined,
-    };
+    return message;
 }
-/**
- * Compile the conversion of each case of a oneof group, keyed by case name.
- */
-function compileConvertOneof(oneof) {
-    const converters = new Map();
-    for (const field of oneof.fields) {
-        let convert;
-        if (field.fieldKind == "message") {
-            convert = compileConvertMessage(field);
+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);
         }
-        else if (field.fieldKind == "scalar" &&
-            field.scalar == ScalarType.BYTES) {
-            convert = toU8Arr;
+        if (field.mapKind == "message") {
+            return convertObjectValues(value, (val) => toMessage(field, val));
         }
-        converters.set(field.localName, convert !== null && convert !== void 0 ? convert : ((value) => value));
     }
-    return converters;
+    return value;
 }
-/**
- * Compile the conversion of an init value for a message field, a message
- * list item, or a message map value. Returns undefined if values are used
- * as-is.
- */
-function compileConvertMessage(field) {
+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(field, item));
+        }
+    }
+    return value;
+}
+function toMessage(field, value) {
     if (field.fieldKind == "message" &&
         !field.oneof &&
         isWrapperDesc(field.message)) {
         // Types from google/protobuf/wrappers.proto are unwrapped when used in
         // a singular field that is not part of a oneof group.
-        return field.message.fields[0].scalar == ScalarType.BYTES
-            ? toU8Arr
-            : undefined;
-    }
-    if (field.message.typeName == "google.protobuf.Struct" &&
-        field.parent.typeName !== "google.protobuf.Value") {
-        // google.protobuf.Struct is represented with JsonObject when used in a
-        // field, except when used in google.protobuf.Value.
-        return undefined;
+        return initScalar(field.message.fields[0], value);
     }
-    const messageDesc = field.message;
-    // Resolved on first use, not here: the message type can be this very field's
-    // parent, whose create function is still being compiled.
-    let compiled;
-    return (value) => {
-        if (!isObject(value) || isMessage(value, messageDesc)) {
+    if (isObject(value)) {
+        if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName !== "google.protobuf.Value") {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
             return value;
         }
-        compiled !== null && compiled !== void 0 ? compiled : (compiled = compiledCreate(messageDesc));
-        return compiled(value);
-    };
+        if (!isMessage(value, field.message)) {
+            return create(field.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 (!needsPrototypeChain(desc)) {
+        msg = {
+            $typeName: desc.typeName,
+        };
+        for (const member of desc.members) {
+            if (member.kind == "oneof" || member.presence == IMPLICIT) {
+                msg[member.localName] = createZeroField(member);
+            }
+        }
+    }
+    else {
+        // 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.
+                    // message, map, list fields are mutable, and also have IMPLICIT presence.
+                    continue;
+                }
+                members.add(member);
+                prototype[member.localName] = createZeroField(member);
+            }
+            messagePrototypes.set(desc, { prototype, members });
+        }
+        msg = Object.create(prototype);
+        msg.$typeName = desc.typeName;
+        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[member.localName] = createZeroField(member);
+        }
+    }
+    return msg;
+}
 /**
  * Do we need the prototype chain to track field presence?
  */
@@ -277,10 +228,22 @@ function needsPrototypeChain(desc) {
     }
 }
 /**
- * Returns the zero value for a scalar or enum field. Scalar and enum fields
- * can have default values.
+ * Returns a zero value for oneof groups, and for every field kind except
+ * messages. Scalar and enum fields can have default values.
  */
-function createZeroValue(field) {
+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.longAsString