@bufbuild/protobuf 0.0.9 → 0.1.1

package/dist/types/google/varint.d.ts

@@ -21,20 +21,32 @@ export declare function varint64write(lo: number, hi: number, bytes: number[]):
 /**
  * Parse decimal string of 64 bit integer value as two JS numbers.
  *
- * Returns tuple:
- * [0]: minus sign?
- * [1]: low bits
- * [2]: high bits
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
  *
- * Copyright 2008 Google Inc.
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
  */
-export declare function int64fromString(dec: string): [boolean, number, number];
+export declare function int64ToString(lo: number, hi: number): string;
 /**
- * Format 64 bit integer value (as two JS numbers) to decimal string.
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
  *
- * Copyright 2008 Google Inc.
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
  */
-export declare function int64toString(bitsLow: number, bitsHigh: number): string;
+export declare function uInt64ToString(lo: number, hi: number): string;
 /**
  * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
  *

package/dist/types/index.d.ts

@@ -20,9 +20,6 @@ export { createDescriptorSet } from "./create-descriptor-set.js";
 export { IMessageTypeRegistry } from "./type-registry.js";
 export { createRegistry } from "./create-registry.js";
 export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
-export { LegacyDescriptorRegistry } from "./legacy-descriptor-registry.js";
-export { LegacyDescriptorSet } from "./legacy-descriptor-set.js";
-export { TypeRegistry } from "./legacy-type-registry.js";
 export * from "./google/protobuf/compiler/plugin_pb.js";
 export * from "./google/protobuf/api_pb.js";
 export * from "./google/protobuf/any_pb.js";

package/dist/types/json-format.d.ts

@@ -1,7 +1,7 @@
 import type { Message } from "./message.js";
 import type { MessageType } from "./message-type.js";
 import type { ScalarType } from "./field.js";
-import type { IMessageTypeRegistry } from "./type-registry";
+import type { IMessageTypeRegistry } from "./type-registry.js";
 /**
  * JsonFormat is the contract for serializing messages to and from JSON.
  * Implementations may be specific to a proto syntax, and can be reflection

package/dist/types/message.d.ts

@@ -67,7 +67,9 @@ export declare class Message<T extends Message<T> = AnyMessage> {
  * PlainMessage<T> strips all methods from a message, leaving only fields
  * and oneof groups.
  */
-export declare type PlainMessage<T extends Message> = Omit<T, keyof Message>;
+export declare type PlainMessage<T extends Message> = {
+    [P in keyof T as T[P] extends Function ? never : P]: T[P];
+};
 /**
  * PartialMessage<T> constructs a type from a message. The resulting type
  * only contains the protobuf field members of the message, and all of them

package/dist/types/proto-int64.d.ts

@@ -29,22 +29,23 @@
  * ```
  *
  * If you need to manipulate 64-bit integral values that are outside the
- * range of safe representation as Number, you can work with the two's
- * complement directly. The following example negates a field value:
+ * range of safe representation as a JavaScript Number, we recommend you
+ * use a third party library, for example the npm package "long":
  *
  * ```ts
- * let t = protoInt64.enc(message.int64Field);
- * t.hi = ~t.hi;
- * if (t.lo) {
- *     t.lo = ~t.lo + 1;
- * } else {
- *     t.hi += 1;
- * }
- * message.int64Field = protoInt64.dec(t.lo, t.hi);
- * ```
+ * // convert the field value to a Long
+ * const bits = protoInt64.enc(message.int64Field);
+ * const longValue = Long.fromBits(bits.lo, bits.hi);
+ *
+ * // perform arithmetic
+ * const longResult = longValue.subtract(1);
  *
- * There are several 3rd party libraries that provide arithmetic operations
- * on a two's complement, for example the npm package "long".
+ * // set the result in the field
+ * message.int64Field = protoInt64.dec(longResult.low, longResult.high);
+ *
+ * // Assuming int64Field contains 9223372036854775807:
+ * console.log(message.int64Field); // 9223372036854775806
+ * ```
  */
 interface Int64Support {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protobuf",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "A complete implementation of Protocol Buffers in TypeScript, suitable for web browsers and Node.js.",
   "repository": {
@@ -12,19 +12,16 @@
   "scripts": {
     "clean": "rm -rf ./dist/cjs/* ./dist/esm/* ./dist/types/*",
     "build": "npm run build:cjs && npm run build:esm+types",
-    "build:cjs": "npx tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
-    "build:esm+types": "npx tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
+    "build:cjs": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm+types": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
   },
-  "main": "./dist/esm/index.js",
+  "main": "./dist/cjs/index.js",
   "type": "module",
   "types": "./dist/types/index.d.ts",
   "exports": {
     "import": "./dist/esm/index.js",
     "require": "./dist/cjs/index.js",
-    "default": "./dist/esm/index.js"
-  },
-  "devDependencies": {
-    "typescript": "^4.7.4"
+    "types": "./dist/types/index.d.ts"
   },
   "files": [
     "dist/**/"

package/dist/cjs/legacy-descriptor-registry.js

@@ -1,468 +0,0 @@
-"use strict";
-// Copyright 2021-2022 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LegacyDescriptorRegistry = void 0;
-const descriptor_pb_js_1 = require("./google/protobuf/descriptor_pb.js");
-const assert_js_1 = require("./private/assert.js");
-const proto3_js_1 = require("./proto3.js");
-const proto2_js_1 = require("./proto2.js");
-const field_js_1 = require("./field.js");
-const legacy_descriptor_set_js_1 = require("./legacy-descriptor-set.js");
-const proto_int64_js_1 = require("./proto-int64.js");
-const timestamp_pb_js_1 = require("./google/protobuf/timestamp_pb.js");
-const duration_pb_js_1 = require("./google/protobuf/duration_pb.js");
-const any_pb_js_1 = require("./google/protobuf/any_pb.js");
-const empty_pb_js_1 = require("./google/protobuf/empty_pb.js");
-const field_mask_pb_js_1 = require("./google/protobuf/field_mask_pb.js");
-const struct_pb_js_1 = require("./google/protobuf/struct_pb.js");
-const enum_js_1 = require("./private/enum.js");
-const wrappers_pb_js_1 = require("./google/protobuf/wrappers_pb.js");
-// well-known message types with specialized JSON representation
-const wkMessages = [
-    any_pb_js_1.Any,
-    duration_pb_js_1.Duration,
-    empty_pb_js_1.Empty,
-    field_mask_pb_js_1.FieldMask,
-    struct_pb_js_1.Struct,
-    struct_pb_js_1.Value,
-    struct_pb_js_1.ListValue,
-    timestamp_pb_js_1.Timestamp,
-    duration_pb_js_1.Duration,
-    wrappers_pb_js_1.DoubleValue,
-    wrappers_pb_js_1.FloatValue,
-    wrappers_pb_js_1.Int64Value,
-    wrappers_pb_js_1.Int32Value,
-    wrappers_pb_js_1.UInt32Value,
-    wrappers_pb_js_1.UInt64Value,
-    wrappers_pb_js_1.BoolValue,
-    wrappers_pb_js_1.StringValue,
-    wrappers_pb_js_1.BytesValue,
-];
-// well-known enum types with specialized JSON representation
-const wkEnums = [(0, enum_js_1.getEnumType)(struct_pb_js_1.NullValue)];
-/**
- * LegacyDescriptorRegistry is a type registry that dynamically creates types
- * from a set of google.protobuf.FileDescriptorProto.
- *
- * By default, all well-known types with a specialized JSON representation
- * are replaced with their generated counterpart in this package.
- *
- * @deprecated
- */
-class LegacyDescriptorRegistry {
-    constructor(descriptorSet, replaceWkt = true) {
-        this.enums = {};
-        this.messages = {};
-        this.services = {};
-        this.ds = descriptorSet !== null && descriptorSet !== void 0 ? descriptorSet : new legacy_descriptor_set_js_1.LegacyDescriptorSet();
-        if (replaceWkt) {
-            for (const mt of wkMessages) {
-                this.messages["." + mt.typeName] = mt;
-            }
-            for (const et of wkEnums) {
-                this.enums["." + et.typeName] = et;
-            }
-        }
-    }
-    /**
-     * Conveniently create a DescriptorRegistry from a FileDescriptorSet
-     * instance or a FileDescriptorSet in binary format.
-     */
-    static fromFileDescriptorSet(bytesOrSet) {
-        const set = bytesOrSet instanceof Uint8Array
-            ? descriptor_pb_js_1.FileDescriptorSet.fromBinary(bytesOrSet)
-            : new descriptor_pb_js_1.FileDescriptorSet(bytesOrSet);
-        const dr = new LegacyDescriptorRegistry();
-        dr.add(...set.file);
-        return dr;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    add(...files) {
-        this.ds.add(...files);
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findEnum(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.enums[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.enums[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const runtime = raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
-        const type = runtime.makeEnumType(typeName, raw.values.map((u) => ({
-            no: u.number,
-            name: u.name,
-            localName: u.name,
-        })), {});
-        this.enums[protoTypeName] = type;
-        return type;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findMessage(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.messages[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.messages[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const runtime = raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
-        const fields = [];
-        const type = runtime.makeMessageType(typeName, () => fields, {
-            localName: makeTypeLocalName(raw),
-        });
-        this.messages[protoTypeName] = type;
-        for (const field of raw.fields.map((f) => f.resolve(this.ds))) {
-            const fieldInfo = makeFieldInfo(field, this);
-            fields.push(fieldInfo);
-        }
-        return type;
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    findService(typeName) {
-        const protoTypeName = "." + typeName;
-        const existing = this.services[protoTypeName];
-        if (existing) {
-            return existing;
-        }
-        const raw = this.ds.services[protoTypeName];
-        if (!raw) {
-            return undefined;
-        }
-        const methods = {};
-        for (const u of raw.methods) {
-            const it = this.findMessage(u.inputTypeName);
-            const ot = this.findMessage(u.outputTypeName);
-            (0, assert_js_1.assert)(it, `message "${u.inputTypeName}" for ${u.toString()} not found`);
-            (0, assert_js_1.assert)(ot, `output message "${u.outputTypeName}" for ${u.toString()} not found`);
-            const m = {
-                name: u.name,
-                localName: localMethodName(u.name),
-                I: it,
-                O: ot,
-                kind: u.kind,
-                idempotency: u.idempotency,
-                options: {},
-            };
-            methods[m.localName] = m;
-        }
-        return (this.services[protoTypeName] = {
-            typeName: raw.typeName,
-            methods,
-        });
-    }
-}
-exports.LegacyDescriptorRegistry = LegacyDescriptorRegistry;
-function localMethodName(protoName) {
-    if (protoName.length == 0) {
-        return protoName;
-    }
-    return protoName[0].toLowerCase() + protoName.substring(1);
-}
-function makeTypeLocalName(type) {
-    var _a;
-    const typeName = type.typeName;
-    const packagePrefix = ((_a = type.file.proto.package) !== null && _a !== void 0 ? _a : "") + ".";
-    if (!typeName.startsWith(packagePrefix)) {
-        return type.name;
-    }
-    return typeName.substring(packagePrefix.length).split(".").join("_");
-}
-function makeFieldInfo(field, resolver) {
-    if (field.map !== undefined) {
-        return makeMapFieldInfo(field, resolver);
-    }
-    if (field.message) {
-        return makeMessageFieldInfo(field, resolver);
-    }
-    const fi = field.enum
-        ? makeEnumFieldInfo(field, resolver)
-        : makeScalarFieldInfo(field);
-    fi.default = parseDefaultValue(field);
-    return fi;
-}
-function makeMapFieldInfo(field, resolver) {
-    const base = {
-        kind: "map",
-        name: field.name,
-        no: field.number,
-        K: field.map.key,
-    };
-    if (field.map.value.message) {
-        const messageType = resolver.findMessage(field.map.value.message.typeName);
-        (0, assert_js_1.assert)(messageType, `message "${field.map.value.message.typeName}" for ${field.toString()} not found`);
-        return Object.assign(Object.assign({}, base), { V: {
-                kind: "message",
-                T: messageType,
-            } });
-    }
-    if (field.map.value.enum) {
-        const enumType = resolver.findEnum(field.map.value.enum.typeName);
-        (0, assert_js_1.assert)(enumType, `enum "${field.map.value.enum.typeName}" for ${field.toString()} not found`);
-        return Object.assign(Object.assign({}, base), { V: {
-                kind: "enum",
-                T: enumType,
-            } });
-    }
-    return Object.assign(Object.assign({}, base), { V: {
-            kind: "scalar",
-            T: field.map.value.scalarType,
-        } });
-}
-function makeScalarFieldInfo(field) {
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "scalar",
-        T: field.scalarType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined, T: field.scalarType });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function makeMessageFieldInfo(field, resolver) {
-    const messageType = resolver.findMessage(field.message.typeName);
-    (0, assert_js_1.assert)(messageType, `message "${field.message.typeName}" for ${field.toString()} not found`);
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "message",
-        T: messageType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function makeEnumFieldInfo(field, resolver) {
-    const enumType = resolver.findEnum(field.enum.typeName);
-    (0, assert_js_1.assert)(enumType, `message "${field.enum.typeName}" for ${field.toString()} not found`);
-    const base = {
-        no: field.number,
-        name: field.name,
-        kind: "enum",
-        T: enumType,
-    };
-    if (field.repeated) {
-        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
-    }
-    if (field.oneof) {
-        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
-    }
-    if (field.optional) {
-        return Object.assign(Object.assign({}, base), { opt: true });
-    }
-    return base;
-}
-function parseDefaultValue(field) {
-    const d = field.proto.defaultValue;
-    if (d === undefined) {
-        return undefined;
-    }
-    if (field.enum) {
-        const enumValue = field.enum.values.find((v) => v.name === d);
-        (0, assert_js_1.assert)(enumValue, `cannot parse ${field.toString()} default value: ${d}`);
-        return enumValue.number;
-    }
-    if (field.scalarType) {
-        switch (field.scalarType) {
-            case field_js_1.ScalarType.STRING:
-                return d;
-            case field_js_1.ScalarType.BYTES: {
-                const u = unescapeBytesDefaultValue(d);
-                if (u === false) {
-                    throw new Error(`cannot parse ${field.toString()} default value: ${d}`);
-                }
-                return u;
-            }
-            case field_js_1.ScalarType.INT64:
-            case field_js_1.ScalarType.SFIXED64:
-            case field_js_1.ScalarType.SINT64:
-                return proto_int64_js_1.protoInt64.parse(d);
-            case field_js_1.ScalarType.UINT64:
-            case field_js_1.ScalarType.FIXED64:
-                return proto_int64_js_1.protoInt64.uParse(d);
-            case field_js_1.ScalarType.DOUBLE:
-            case field_js_1.ScalarType.FLOAT:
-                switch (d) {
-                    case "inf":
-                        return Number.POSITIVE_INFINITY;
-                    case "-inf":
-                        return Number.NEGATIVE_INFINITY;
-                    case "nan":
-                        return Number.NaN;
-                    default:
-                        return parseFloat(d);
-                }
-            case field_js_1.ScalarType.BOOL:
-                return Boolean(d);
-            case field_js_1.ScalarType.INT32:
-            case field_js_1.ScalarType.UINT32:
-            case field_js_1.ScalarType.SINT32:
-            case field_js_1.ScalarType.FIXED32:
-            case field_js_1.ScalarType.SFIXED32:
-                return parseInt(d, 10);
-        }
-    }
-    return undefined;
-}
-// unescapeBytesDefaultValue parses a text-encoded default value (proto2) of a
-// BYTES field.
-function unescapeBytesDefaultValue(str) {
-    const b = [];
-    const input = {
-        tail: str,
-        c: "",
-        next() {
-            if (this.tail.length == 0) {
-                return false;
-            }
-            this.c = this.tail[0];
-            this.tail = this.tail.substring(1);
-            return true;
-        },
-        take(n) {
-            if (this.tail.length >= n) {
-                const r = this.tail.substring(0, n);
-                this.tail = this.tail.substring(n);
-                return r;
-            }
-            return false;
-        },
-    };
-    while (input.next()) {
-        switch (input.c) {
-            case "\\":
-                if (input.next()) {
-                    switch (input.c) {
-                        case "\\":
-                            b.push(input.c.charCodeAt(0));
-                            break;
-                        case "b":
-                            b.push(0x08);
-                            break;
-                        case "f":
-                            b.push(0x0c);
-                            break;
-                        case "n":
-                            b.push(0x0a);
-                            break;
-                        case "r":
-                            b.push(0x0d);
-                            break;
-                        case "t":
-                            b.push(0x09);
-                            break;
-                        case "v":
-                            b.push(0x0b);
-                            break;
-                        case "0":
-                        case "1":
-                        case "2":
-                        case "3":
-                        case "4":
-                        case "5":
-                        case "6":
-                        case "7": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 8);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "x": {
-                            const s = input.c;
-                            const t = input.take(2);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            b.push(n);
-                            break;
-                        }
-                        case "u": {
-                            const s = input.c;
-                            const t = input.take(4);
-                            if (t === false) {
-                                return false;
-                            }
-                            const n = parseInt(s + t, 16);
-                            if (isNaN(n)) {
-                                return false;
-                            }
-                            const chunk = new Uint8Array(4);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, n, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
-                            break;
-                        }
-                        case "U": {
-                            const s = input.c;
-                            const t = input.take(8);
-                            if (t === false) {
-                                return false;
-                            }
-                            const tc = proto_int64_js_1.protoInt64.uEnc(s + t);
-                            const chunk = new Uint8Array(8);
-                            const view = new DataView(chunk.buffer);
-                            view.setInt32(0, tc.lo, true);
-                            view.setInt32(4, tc.hi, true);
-                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
-                            break;
-                        }
-                    }
-                }
-                break;
-            default:
-                b.push(input.c.charCodeAt(0));
-        }
-    }
-    return new Uint8Array(b);
-}