openrod 0.0.0 → 0.1.0

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/message.js

@@ -0,0 +1,152 @@
+// Copyright 2021-2026 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 { create } from "../create.js";
+import { isObject } from "./guard.js";
+import { isWrapperDesc } from "../wkt/wrappers.js";
+// google.protobuf.NullValue.NULL_VALUE;
+const NULL_VALUE = 0;
+/**
+ * Return the conversions between the local representation of the field
+ * value and the message it represents.
+ *
+ * @private
+ */
+export function localMessageMapper(field) {
+    // google.protobuf.Struct fields are stored as JsonObject.
+    if (usesJsonRepresentation(field)) {
+        return {
+            toMessage: (local) => wktStructToReflect(local),
+            toLocal: (message) => wktStructToLocal(message),
+        };
+    }
+    // Singular wrapper fields outside a oneof are unwrapped to the scalar value.
+    if (field.fieldKind == "message" &&
+        !field.oneof &&
+        isWrapperDesc(field.message)) {
+        const wrapperDesc = field.message;
+        const valueLocalName = wrapperDesc.fields[0].localName;
+        return {
+            toMessage: (local) => {
+                const message = create(wrapperDesc);
+                if (local !== undefined) {
+                    message[valueLocalName] = local;
+                }
+                return message;
+            },
+            toLocal: (message) => message[valueLocalName],
+        };
+    }
+    // For all other fields, the local value is the message itself.
+    const childDesc = field.message;
+    return {
+        toMessage: (local) => (local === undefined ? create(childDesc) : local),
+        toLocal: (message) => message,
+    };
+}
+/**
+ * Returns true if values of this field are stored as JsonValue instead of
+ * a message: google.protobuf.Struct is represented with JsonObject when
+ * used in a field, except when used in google.protobuf.Value.
+ */
+function usesJsonRepresentation(field) {
+    return (field.message.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value");
+}
+/**
+ * Convert the JsonValue representation of a google.protobuf.Struct to the
+ * message representation.
+ *
+ * @private
+ */
+export function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if (isObject(json)) {
+        for (const k of Object.keys(json)) {
+            struct.fields[k] = wktValueToReflect(json[k]);
+        }
+    }
+    return struct;
+}
+/**
+ * Convert a google.protobuf.Struct message to its JsonValue representation.
+ *
+ * @private
+ */
+export function wktStructToLocal(val) {
+    const json = {};
+    for (const k of Object.keys(val.fields)) {
+        json[k] = wktValueToLocal(val.fields[k]);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                value.kind = { case: "nullValue", value: NULL_VALUE };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.d.ts

@@ -0,0 +1,30 @@
+import type { AnyDesc } from "../descriptors.js";
+/**
+ * Return a fully-qualified name for a Protobuf descriptor.
+ * For a file descriptor, return the original file path.
+ *
+ * See https://protobuf.com/docs/language-spec#fully-qualified-names
+ */
+export declare function qualifiedName(desc: AnyDesc): string;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ *
+ * See https://protobuf.com/docs/language-spec#default-json-names
+ *
+ * The function protoSnakeCase provides the reverse.
+ */
+export declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Converts protoCamelCase to snake_case.
+ *
+ * This function is the reverse of function protoCamelCase. Note that some names
+ * are not reversible - for example, "foo__bar" -> "fooBar" -> "foo_bar".
+ */
+export declare function protoSnakeCase(lowerCamelCase: string): string;
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
+ */
+export declare function safeObjectProperty(name: string): string;

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/names.js

@@ -0,0 +1,109 @@
+// Copyright 2021-2026 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.
+/**
+ * Return a fully-qualified name for a Protobuf descriptor.
+ * For a file descriptor, return the original file path.
+ *
+ * See https://protobuf.com/docs/language-spec#fully-qualified-names
+ */
+export function qualifiedName(desc) {
+    switch (desc.kind) {
+        case "field":
+        case "oneof":
+        case "rpc":
+            return desc.parent.typeName + "." + desc.name;
+        case "enum_value": {
+            const p = desc.parent.parent
+                ? desc.parent.parent.typeName
+                : desc.parent.file.proto.package;
+            return p + (p.length > 0 ? "." : "") + desc.name;
+        }
+        case "service":
+        case "message":
+        case "enum":
+        case "extension":
+            return desc.typeName;
+        case "file":
+            return desc.proto.name;
+    }
+}
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ *
+ * See https://protobuf.com/docs/language-spec#default-json-names
+ *
+ * The function protoSnakeCase provides the reverse.
+ */
+export function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+/**
+ * Converts protoCamelCase to snake_case.
+ *
+ * This function is the reverse of function protoCamelCase. Note that some names
+ * are not reversible - for example, "foo__bar" -> "fooBar" -> "foo_bar".
+ */
+export function protoSnakeCase(lowerCamelCase) {
+    return lowerCamelCase.replace(/[A-Z]/g, (letter) => "_" + letter.toLowerCase());
+}
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Escapes names that are reserved for ECMAScript built-in object properties.
+ *
+ * Also see safeIdentifier() from @bufbuild/protoplugin.
+ */
+export function safeObjectProperty(name) {
+    return reservedObjectProperties.has(name) ? name + "$" : name;
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.d.ts

@@ -0,0 +1,35 @@
+import type { AnyDesc, DescEnum, DescExtension, DescFile, DescMessage, DescService } from "../descriptors.js";
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+export declare function nestedTypes(desc: DescFile | DescMessage): Iterable<DescMessage | DescEnum | DescExtension | DescService>;
+/**
+ * Iterate over types referenced by fields of the given message.
+ *
+ * For example:
+ *
+ * ```proto
+ * syntax="proto3";
+ *
+ * message Example {
+ *   Msg singular = 1;
+ *   repeated Level list = 2;
+ * }
+ *
+ * message Msg {}
+ *
+ * enum Level {
+ *   LEVEL_UNSPECIFIED = 0;
+ * }
+ * ```
+ *
+ * The message Example references the message Msg, and the enum Level.
+ */
+export declare function usedTypes(descMessage: DescMessage): Iterable<DescMessage | DescEnum>;
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+export declare function parentTypes(desc: AnyDesc): Parent[];
+type Parent = DescFile | DescEnum | DescMessage | DescService;
+export {};

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/nested-types.js

@@ -0,0 +1,105 @@
+// Copyright 2021-2026 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.
+/**
+ * Iterate over all types - enumerations, extensions, services, messages -
+ * and enumerations, extensions and messages nested in messages.
+ */
+export function* nestedTypes(desc) {
+    switch (desc.kind) {
+        case "file":
+            for (const message of desc.messages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.enums;
+            yield* desc.services;
+            yield* desc.extensions;
+            break;
+        case "message":
+            for (const message of desc.nestedMessages) {
+                yield message;
+                yield* nestedTypes(message);
+            }
+            yield* desc.nestedEnums;
+            yield* desc.nestedExtensions;
+            break;
+    }
+}
+/**
+ * Iterate over types referenced by fields of the given message.
+ *
+ * For example:
+ *
+ * ```proto
+ * syntax="proto3";
+ *
+ * message Example {
+ *   Msg singular = 1;
+ *   repeated Level list = 2;
+ * }
+ *
+ * message Msg {}
+ *
+ * enum Level {
+ *   LEVEL_UNSPECIFIED = 0;
+ * }
+ * ```
+ *
+ * The message Example references the message Msg, and the enum Level.
+ */
+export function usedTypes(descMessage) {
+    return usedTypesInternal(descMessage, new Set());
+}
+function* usedTypesInternal(descMessage, seen) {
+    var _a, _b;
+    for (const field of descMessage.fields) {
+        const ref = (_b = (_a = field.enum) !== null && _a !== void 0 ? _a : field.message) !== null && _b !== void 0 ? _b : undefined;
+        if (!ref || seen.has(ref.typeName)) {
+            continue;
+        }
+        seen.add(ref.typeName);
+        yield ref;
+        if (ref.kind == "message") {
+            yield* usedTypesInternal(ref, seen);
+        }
+    }
+}
+/**
+ * Returns the ancestors of a given Protobuf element, up to the file.
+ */
+export function parentTypes(desc) {
+    const parents = [];
+    while (desc.kind !== "file") {
+        const p = parent(desc);
+        desc = p;
+        parents.push(p);
+    }
+    return parents;
+}
+function parent(desc) {
+    var _a;
+    switch (desc.kind) {
+        case "enum_value":
+        case "field":
+        case "oneof":
+        case "rpc":
+            return desc.parent;
+        case "service":
+            return desc.file;
+        case "extension":
+        case "enum":
+        case "message":
+            return (_a = desc.parent) !== null && _a !== void 0 ? _a : desc.file;
+    }
+}

package/node_modules/@bufbuild/protobuf/dist/esm/reflect/path.d.ts

@@ -0,0 +1,107 @@
+import { type DescExtension, type DescField, type DescMessage, type DescOneof } from "../descriptors.js";
+import type { Registry } from "../registry.js";
+/**
+ * A path to a (nested) member of a Protobuf message, such as a field, oneof,
+ * extension, list element, or map entry.
+ *
+ * Note that we may add additional types to this union in the future to support
+ * more use cases.
+ */
+export type Path = (DescField | DescExtension | DescOneof | {
+    kind: "list_sub";
+    index: number;
+} | {
+    kind: "map_sub";
+    key: string | number | bigint | boolean;
+})[];
+/**
+ * Builds a Path.
+ */
+export type PathBuilder = {
+    /**
+     * The root message of the path.
+     */
+    readonly schema: DescMessage;
+    /**
+     * Add field access.
+     *
+     * Throws an InvalidPathError if the field cannot be added to the path.
+     */
+    field(field: DescField): PathBuilder;
+    /**
+     * Access a oneof.
+     *
+     * Throws an InvalidPathError if the oneof cannot be added to the path.
+     *
+     */
+    oneof(oneof: DescOneof): PathBuilder;
+    /**
+     * Access an extension.
+     *
+     * Throws an InvalidPathError if the extension cannot be added to the path.
+     */
+    extension(extension: DescExtension): PathBuilder;
+    /**
+     * Access a list field by index.
+     *
+     * Throws an InvalidPathError if the list access cannot be added to the path.
+     */
+    list(index: number): PathBuilder;
+    /**
+     * Access a map field by key.
+     *
+     * Throws an InvalidPathError if the map access cannot be added to the path.
+     */
+    map(key: string | number | bigint | boolean): PathBuilder;
+    /**
+     * Append a path.
+     *
+     * Throws an InvalidPathError if the path cannot be added.
+     */
+    add(path: Path | PathBuilder): PathBuilder;
+    /**
+     * Return the path.
+     */
+    toPath(): Path;
+    /**
+     * Create a copy of this builder.
+     */
+    clone(): PathBuilder;
+    /**
+     * Get the current container - a list, map, or message.
+     */
+    getLeft(): DescMessage | (DescField & {
+        fieldKind: "list";
+    }) | (DescField & {
+        fieldKind: "map";
+    }) | undefined;
+};
+/**
+ * Create a PathBuilder.
+ */
+export declare function buildPath(schema: DescMessage): PathBuilder;
+/**
+ * Parse a Path from a string.
+ *
+ * Throws an InvalidPathError if the path is invalid.
+ *
+ * Note that a Registry must be provided via the options argument to parse
+ * paths that refer to an extension.
+ */
+export declare function parsePath(schema: DescMessage, path: string, options?: {
+    registry?: Registry | undefined;
+}): Path;
+/**
+ * Stringify a path.
+ */
+export declare function pathToString(path: Path): string;
+/**
+ * InvalidPathError is thrown for invalid Paths, for example during parsing from
+ * a string, or when a new Path is built.
+ */
+export declare class InvalidPathError extends Error {
+    name: string;
+    readonly schema: DescMessage;
+    readonly path: Path | string;
+    constructor(schema: DescMessage, message: string, path: string | Path);
+}