@in-human-resources/backend-proto 0.1.4 → 0.1.6

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/feature-set.js

@@ -0,0 +1,116 @@
+// 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 { Edition, FeatureSet, FeatureSetDefaults, } from "../google/protobuf/descriptor_pb.js";
+import { protoBase64 } from "../proto-base64.js";
+/**
+ * Return the edition feature defaults supported by @bufbuild/protobuf.
+ */
+function getFeatureSetDefaults(options) {
+    return FeatureSetDefaults.fromBinary(protoBase64.dec(
+    /*upstream-inject-feature-defaults-start*/ "ChMY5gciACoMCAEQAhgCIAMoATACChMY5wciACoMCAIQARgBIAIoATABChMY6AciDAgBEAEYASACKAEwASoAIOYHKOgH" /*upstream-inject-feature-defaults-end*/), options);
+}
+/**
+ * Create an edition feature resolver with the given feature set defaults, or
+ * the feature set defaults supported by @bufbuild/protobuf.
+ */
+export function createFeatureResolver(edition, compiledFeatureSetDefaults, serializationOptions) {
+    var _a;
+    const fds = compiledFeatureSetDefaults !== null && compiledFeatureSetDefaults !== void 0 ? compiledFeatureSetDefaults : getFeatureSetDefaults(serializationOptions);
+    const min = fds.minimumEdition;
+    const max = fds.maximumEdition;
+    if (min === undefined ||
+        max === undefined ||
+        fds.defaults.some((d) => d.edition === undefined)) {
+        throw new Error("Invalid FeatureSetDefaults");
+    }
+    if (edition < min) {
+        throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
+    }
+    if (max < edition) {
+        throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
+    }
+    let highestMatch = undefined;
+    for (const c of fds.defaults) {
+        const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
+        if (e > edition) {
+            continue;
+        }
+        if (highestMatch !== undefined && highestMatch.e > e) {
+            continue;
+        }
+        let f;
+        if (c.fixedFeatures && c.overridableFeatures) {
+            f = c.fixedFeatures;
+            f.fromBinary(c.overridableFeatures.toBinary());
+        }
+        else if (c.fixedFeatures) {
+            f = c.fixedFeatures;
+        }
+        else if (c.overridableFeatures) {
+            f = c.overridableFeatures;
+        }
+        else {
+            f = new FeatureSet();
+        }
+        highestMatch = {
+            e,
+            f,
+        };
+    }
+    if (highestMatch === undefined) {
+        throw new Error(`No valid default found for edition ${Edition[edition]}`);
+    }
+    const featureSetBin = highestMatch.f.toBinary(serializationOptions);
+    return (...rest) => {
+        const f = FeatureSet.fromBinary(featureSetBin, serializationOptions);
+        for (const c of rest) {
+            if (c !== undefined) {
+                f.fromBinary(c.toBinary(serializationOptions), serializationOptions);
+            }
+        }
+        if (!validateMergedFeatures(f)) {
+            throw new Error(`Invalid FeatureSet for edition ${Edition[edition]}`);
+        }
+        return f;
+    };
+}
+// When protoc generates google.protobuf.FeatureSetDefaults, it ensures that
+// fields are not repeated or required, do not use oneof, and have a default
+// value.
+//
+// When features for an element are resolved, features of the element and its
+// parents are merged into the default FeatureSet for the edition. Because unset
+// fields in the FeatureSet of an element do not unset the default FeatureSet
+// values, a resolved FeatureSet is guaranteed to have all fields set. This is
+// also the case for extensions to FeatureSet that a user might provide, and for
+// features from the future.
+//
+// We cannot exhaustively validate correctness of FeatureSetDefaults at runtime
+// without knowing the schema: If no value for a feature is provided, we do not
+// know that it exists at all.
+//
+// As a sanity check, we validate that all fields known to our version of
+// FeatureSet are set.
+function validateMergedFeatures(featureSet) {
+    for (const fi of FeatureSet.fields.list()) {
+        const v = featureSet[fi.localName];
+        if (v === undefined) {
+            return false;
+        }
+        if (fi.kind == "enum" && v === 0) {
+            return false;
+        }
+    }
+    return true;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-list.d.ts

@@ -0,0 +1,18 @@
+import type { FieldInfo, OneofInfo, PartialFieldInfo } from "../field.js";
+import type { FieldList } from "../field-list.js";
+export type FieldListSource = readonly PartialFieldInfo[] | readonly FieldInfo[] | (() => readonly PartialFieldInfo[]) | (() => readonly FieldInfo[]);
+export declare class InternalFieldList implements FieldList {
+    private readonly _fields;
+    private readonly _normalizer;
+    private all?;
+    private numbersAsc?;
+    private jsonNames?;
+    private numbers?;
+    private members?;
+    constructor(fields: FieldListSource, normalizer: (p: FieldListSource) => FieldInfo[]);
+    findJsonName(jsonName: string): FieldInfo | undefined;
+    find(fieldNo: number): FieldInfo | undefined;
+    list(): readonly FieldInfo[];
+    byNumber(): readonly FieldInfo[];
+    byMember(): readonly (FieldInfo | OneofInfo)[];
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-list.js

@@ -0,0 +1,72 @@
+// 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 class InternalFieldList {
+    constructor(fields, normalizer) {
+        this._fields = fields;
+        this._normalizer = normalizer;
+    }
+    findJsonName(jsonName) {
+        if (!this.jsonNames) {
+            const t = {};
+            for (const f of this.list()) {
+                t[f.jsonName] = t[f.name] = f;
+            }
+            this.jsonNames = t;
+        }
+        return this.jsonNames[jsonName];
+    }
+    find(fieldNo) {
+        if (!this.numbers) {
+            const t = {};
+            for (const f of this.list()) {
+                t[f.no] = f;
+            }
+            this.numbers = t;
+        }
+        return this.numbers[fieldNo];
+    }
+    list() {
+        if (!this.all) {
+            this.all = this._normalizer(this._fields);
+        }
+        return this.all;
+    }
+    byNumber() {
+        if (!this.numbersAsc) {
+            this.numbersAsc = this.list()
+                .concat()
+                .sort((a, b) => a.no - b.no);
+        }
+        return this.numbersAsc;
+    }
+    byMember() {
+        if (!this.members) {
+            this.members = [];
+            const a = this.members;
+            let o;
+            for (const f of this.list()) {
+                if (f.oneof) {
+                    if (f.oneof !== o) {
+                        o = f.oneof;
+                        a.push(o);
+                    }
+                }
+                else {
+                    a.push(f);
+                }
+            }
+        }
+        return this.members;
+    }
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-normalize.d.ts

@@ -0,0 +1,9 @@
+import type { FieldListSource } from "./field-list.js";
+import type { FieldInfo } from "../field.js";
+/**
+ * Convert a collection of field info to an array of normalized FieldInfo.
+ *
+ * The argument `packedByDefault` specifies whether fields that do not specify
+ * `packed` should be packed (proto3) or unpacked (proto2).
+ */
+export declare function normalizeFieldInfos(fieldInfos: FieldListSource, packedByDefault: boolean): FieldInfo[];

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-normalize.js

@@ -0,0 +1,65 @@
+// 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 { InternalOneofInfo } from "./field.js";
+import { fieldJsonName, localFieldName } from "./names.js";
+import { LongType, ScalarType } from "../scalar.js";
+/**
+ * Convert a collection of field info to an array of normalized FieldInfo.
+ *
+ * The argument `packedByDefault` specifies whether fields that do not specify
+ * `packed` should be packed (proto3) or unpacked (proto2).
+ */
+export function normalizeFieldInfos(fieldInfos, packedByDefault) {
+    var _a, _b, _c, _d, _e, _f;
+    const r = [];
+    let o;
+    for (const field of typeof fieldInfos == "function"
+        ? fieldInfos()
+        : fieldInfos) {
+        const f = field;
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = (_a = field.jsonName) !== null && _a !== void 0 ? _a : fieldJsonName(field.name);
+        f.repeated = (_b = field.repeated) !== null && _b !== void 0 ? _b : false;
+        if (field.kind == "scalar") {
+            f.L = (_c = field.L) !== null && _c !== void 0 ? _c : LongType.BIGINT;
+        }
+        f.delimited = (_d = field.delimited) !== null && _d !== void 0 ? _d : false;
+        f.req = (_e = field.req) !== null && _e !== void 0 ? _e : false;
+        f.opt = (_f = field.opt) !== null && _f !== void 0 ? _f : false;
+        if (field.packed === undefined) {
+            if (packedByDefault) {
+                f.packed =
+                    field.kind == "enum" ||
+                        (field.kind == "scalar" &&
+                            field.T != ScalarType.BYTES &&
+                            field.T != ScalarType.STRING);
+            }
+            else {
+                f.packed = false;
+            }
+        }
+        // We do not surface options at this time
+        // f.options = field.options ?? emptyReadonlyObject;
+        if (field.oneof !== undefined) {
+            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+            if (!o || o.name != ooname) {
+                o = new InternalOneofInfo(ooname);
+            }
+            f.oneof = o;
+            o.addField(f);
+        }
+        r.push(f);
+    }
+    return r;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-wrapper.d.ts

@@ -0,0 +1,25 @@
+import { Message } from "../message.js";
+import type { MessageType } from "../message-type.js";
+import type { DescExtension, DescField } from "../descriptor-set.js";
+import { ScalarType } from "../scalar.js";
+/**
+ * A field wrapper unwraps a message to a primitive value that is more
+ * ergonomic for use as a message field.
+ *
+ * Note that this feature exists for google/protobuf/wrappers.proto
+ * and cannot be used to arbitrarily modify types in generated code.
+ */
+export interface FieldWrapper<T extends Message<T> = any, U = any> {
+    wrapField(value: U): T;
+    unwrapField(value: T): U;
+}
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export declare function wrapField<T extends Message<T>>(type: MessageType<T>, value: any): T;
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+export declare function getUnwrappedFieldType(field: DescField | DescExtension): ScalarType | undefined;

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field-wrapper.js

@@ -0,0 +1,53 @@
+// 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 { Message } from "../message.js";
+import { ScalarType } from "../scalar.js";
+import { isMessage } from "../is-message.js";
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export function wrapField(type, value) {
+    if (isMessage(value) || !type.fieldWrapper) {
+        return value;
+    }
+    return type.fieldWrapper.wrapField(value);
+}
+/**
+ * If the given field uses one of the well-known wrapper types, return
+ * the primitive type it wraps.
+ */
+export function getUnwrappedFieldType(field) {
+    if (field.fieldKind !== "message") {
+        return undefined;
+    }
+    if (field.repeated) {
+        return undefined;
+    }
+    if (field.oneof != undefined) {
+        return undefined;
+    }
+    return wktWrapperToScalarType[field.message.typeName];
+}
+const wktWrapperToScalarType = {
+    "google.protobuf.DoubleValue": ScalarType.DOUBLE,
+    "google.protobuf.FloatValue": ScalarType.FLOAT,
+    "google.protobuf.Int64Value": ScalarType.INT64,
+    "google.protobuf.UInt64Value": ScalarType.UINT64,
+    "google.protobuf.Int32Value": ScalarType.INT32,
+    "google.protobuf.UInt32Value": ScalarType.UINT32,
+    "google.protobuf.BoolValue": ScalarType.BOOL,
+    "google.protobuf.StringValue": ScalarType.STRING,
+    "google.protobuf.BytesValue": ScalarType.BYTES,
+};

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field.d.ts

@@ -0,0 +1,16 @@
+import type { FieldInfo, OneofInfo } from "../field.js";
+export declare class InternalOneofInfo implements OneofInfo {
+    readonly kind = "oneof";
+    readonly name: string;
+    readonly localName: string;
+    readonly repeated = false;
+    readonly packed = false;
+    readonly opt = false;
+    readonly req = false;
+    readonly default: undefined;
+    readonly fields: FieldInfo[];
+    private _lookup?;
+    constructor(name: string);
+    addField(field: FieldInfo): void;
+    findField(localName: string): FieldInfo | undefined;
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/field.js

@@ -0,0 +1,41 @@
+// 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 { localOneofName } from "./names.js";
+import { assert } from "./assert.js";
+export class InternalOneofInfo {
+    constructor(name) {
+        this.kind = "oneof";
+        this.repeated = false;
+        this.packed = false;
+        this.opt = false;
+        this.req = false;
+        this.default = undefined;
+        this.fields = [];
+        this.name = name;
+        this.localName = localOneofName(name);
+    }
+    addField(field) {
+        assert(field.oneof === this, `field ${field.name} not one of ${this.name}`);
+        this.fields.push(field);
+    }
+    findField(localName) {
+        if (!this._lookup) {
+            this._lookup = Object.create(null);
+            for (let i = 0; i < this.fields.length; i++) {
+                this._lookup[this.fields[i].localName] = this.fields[i];
+            }
+        }
+        return this._lookup[localName];
+    }
+}

package/gen/ts/node_modules/@bufbuild/protobuf/dist/esm/private/json-format.d.ts

@@ -0,0 +1,2 @@
+import type { JsonFormat } from "../json-format.js";
+export declare function makeJsonFormat(): JsonFormat;