@code-yeongyu/senpi 2026.8.19 → 2026.8.20-2

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

@@ -15,7 +15,6 @@ 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;
@@ -33,182 +32,232 @@ export function create(schema, init) {
     if (isMessage(init, schema)) {
         return init;
     }
-    const message = createZeroMessage(schema);
-    if (init !== undefined) {
-        initMessage(schema, message, init);
-    }
-    return message;
+    return compiledCreate(schema)(init);
 }
+const compiledCreates = new WeakMap();
 /**
- * Sets field values from a MessageInitShape on a zero message.
- */
-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;
+ * 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);
+    }
+    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;
         }
-        let field;
-        if (member.kind == "oneof") {
-            const oneofField = unsafeOneofCase(init, member);
-            if (!oneofField) {
-                continue;
+        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;
+                }
             }
-            field = oneofField;
-            value = unsafeGet(init, oneofField);
         }
-        else {
-            field = member;
+        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.
+ */
+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),
+            });
+            continue;
         }
-        switch (field.fieldKind) {
-            case "message":
-                value = toMessage(field, value);
+        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;
-            case "scalar":
-                value = initScalar(field, value);
+            }
+            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,
+                });
                 break;
-            case "list":
-                value = initList(field, value);
+            }
+            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,
+                });
                 break;
-            case "map":
-                value = initMap(field, value);
+            }
+            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;
+                }
                 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(field, val));
+            }
         }
     }
-    return value;
+    return {
+        properties,
+        prototype: usePrototype ? prototype : undefined,
+    };
 }
-function initList(field, value) {
-    if (Array.isArray(value)) {
-        if (field.scalar == ScalarType.BYTES) {
-            return value.map(toU8Arr);
+/**
+ * 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);
         }
-        if (field.listKind == "message") {
-            return value.map((item) => toMessage(field, item));
+        else if (field.fieldKind == "scalar" &&
+            field.scalar == ScalarType.BYTES) {
+            convert = toU8Arr;
         }
+        converters.set(field.localName, convert !== null && convert !== void 0 ? convert : ((value) => value));
     }
-    return value;
+    return converters;
 }
-function toMessage(field, 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) {
     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 initScalar(field.message.fields[0], value);
+        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;
     }
-    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.
+    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)) {
             return value;
         }
-        if (!isMessage(value, field.message)) {
-            return create(field.message, value);
-        }
-    }
-    return value;
+        compiled !== null && compiled !== void 0 ? compiled : (compiled = compiledCreate(messageDesc));
+        return compiled(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?
  */
@@ -228,22 +277,10 @@ function needsPrototypeChain(desc) {
     }
 }
 /**
- * Returns a zero value for oneof groups, and for every field kind except
- * messages. Scalar and enum fields can have default values.
+ * Returns the zero value for a scalar or enum field. 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;
-    }
+function createZeroValue(field) {
     const defaultValue = field.getDefaultValue();
     if (defaultValue !== undefined) {
         return field.fieldKind == "scalar" && field.longAsString