Remove the toString method, and let GeneratedFile.jsDoc() return a Printable.

This brings the JSDocBlock printable in line with others.

And provide utilities for Timestamp, such as timestampNow()

Add `toBinary` and `fromBinary` functions to serialize to and from
protobuf encoded bytes. Added compatibility tests with v1 for now.

Ignore in prettier. Move Node10 module resolution fallbacks to correct path.

This annotation informs bundlers that the succeeding function call is free of side effects. This means the symbol can be removed from the module during tree-shaking if it is unused.

See #470

The annotation is not terribly effective yet, since all generated descriptors depend on the file descriptor, but it's still worthwhile.

This adds two new types to the reflect API: ReflectList and ReflectMap. The API now always returns messages as ReflectMessage, list fields as ReflectList, and map fields as ReflectMap. Note that accessing an unset message fields returns a ReflectMessage with a new zero-message.

The methods ReflectMessage.addListItem and ReflectMessage.setMapEntry are kept for now. We can decide whether it's worth to keep them for the hot path when we take a look at performance.

This also updates create() to fully support the "init" argument.

The IEEE standard requires that NaN != NaN. It's questionable whether that should also be the case when comparing two protobuf fields,

The message descriptor contains cyclic references and methods, causing issues with Jest, RSC serialization, structured clone, and others.

By removing the property, messages are no longer self-describing, and functions that need schema information require the user to path both the message descriptor and the message.

Most importantly, tests for serializing map fields.

Fixes a bug in fromBinary, where map keys were converted to strings, which are the correct representation in a message, but not for a ReflectMap. This bug was most likely introduced in 7054ed7, which limited the conversion to a smaller set of acceptable types.

In case of a test failure, we'll see the diff instead of Jest crashing.
See jestjs/jest#11617 (comment)

There don't appear to be any adverse effects of enabling the option. Test failures when strictly comparing message classes are still reported correctly.

In order to reduce the number of main exports, move types that are rarely needed by end-users to a new subpath "wire".

- BinaryWriter and BinaryReader have been moved, and their interfaces discarded.

- Users can bring their own Text encoding API via wire/configureTextEncoding() now instead of the serialization options readerFactory / writerFactory.

- protoBase64 has been split into the functions base64Decode and base64Encode, with the latter allowing to encode with padding, without padding, or URL-safe.

The exports protoDelimited and protoBase64 are also candidates for moving to wire, but are not moved by this commit.

Move reflect/wkt.ts to wkt/wrappers.ts to keep WKT-specific code in one place. This does not move the code for custom JSON representation of WKTs.

Same as #767

fileDesc() from codegenv1/hydrate.ts restored redundant json names incorrectly, leading DescField.jsonName to be an empty string instead of undefined.

We have to ignore $typeName and $unknown, not $desc and $typename.

FIXED32 is an unsigned, fixed-length 32-bit integer.

Add `fromJson` and `mergeFromJson` and their string variants. Missing
extension support, will a be added in a follow up.

We used to have a protoDouble export to avoid possibly clashing with a generated symbol.

Turns out we can simplify this more, use globalThis - it's a reserved identifier by safeIdentifier() - and remove a file from codegenv1.

eslint is a bit over the top here.

This will avoid a circular reference when we switch to hydrate embedded descriptors with v2.

Remove the options for FeatureSetDefaults from createDescFileSet(), createDescriptorSet(), and @bufbuild/protoplugin.

Going forward, feature resolution will happen internally in createDescFileSet(), and not be exposed. This will avoid several bootstrapping issues and simplify the code overall. Feature resolution with own features can still be implemented as an external function if needed, but at this point, this does not seem to be a crucial feature.

When we hydrate embedded descriptors, we cannot use binary serialization. This changes does not completely remove serialization yet, since feature-set defaults are still embedded as binary in the source, but it changes resolution to no longer use serialization for feature inheritance.

To avoid import cycles, we generate enumerations we need in desc-set.ts instead of importing.

So that it can be re-used later.

The property is populated from edition features / defaults.

The property was only relevant to generate optimized FieldInfo in v1, which is now implemented with a separate function.

The property was a union with `undefined` to generate optimized FieldInfo in v1, which is now implemented with a separate function.

In preparation for switching desc-set.ts to use v2 proto messages, add a facility to embed a FileDescriptorProto message for google/protobuf/descriptor.proto as a plain object.

Before proto2 fields were switched to use the prototype chain, we used assertions to narrow down optional types. This is no longer necessary.

- Copy coverage for v1 to v2
- Consolidate some tests
- Avoid generated code where possible

We have to make use of the helper.

To avoid import cycles, we add a local copy of enumerations generated from descriptor.proto at several places.

Going forward, Desc* types will stop exposing generated enumerations, so that this workaround will no longer be necessary.

With this change, V2 messages do not rely on the V1 runtime anymore.

Note that this commit does not pass tests, since tests, the protoplugin package, and our code generator all still expect V1 messages with createDescSet() and related types.

The V1 function createDescriptorSet() is patched to still accept V1 descriptor protos, since it is most widely used, also with the old code generator.

Note that this commit does not pass tests, since our plugin and test packages still need to be updated.

The V1 function createSchema() is patched to still accept V1 descriptor protos, since it is most widely used, also with the old code generator.

Special case google/protobuf/descriptor.proto to embed it as a plain object when bootstrapping.

Note that this commit does not pass tests, since tests and other packages still need to be updated.

Note that this commit does not pass tests, since more tests and other packages still need to be updated.

Note that this commit does not pass tests, since other packages still need to be updated.

The target `test-protoplugin-example` runs in CI, but not in `make test`.

This commit should pass CI. V2 is now (mostly) independant of V1.

Porting #777

Porting #778

This ports name-clash tests from V1, applying them to V2. It fixes a bug in function tsEnum, and adds additional tests.

This will let us remove V1 protoplugin.

There are two expected changes in generated code:
- We use `globalThis` to reference NaN and Infinity instead of the `protoDouble` export.
- We no longer generate the `@ts-nocheck` annotation by default.

This commit will not pass tests because we still have references to V1. Committing separately for better commit history.

This commit completes the previous one, replacing @bufbuild/protoplugin/next with @bufbuild/protoplugin in the project.

This is not a complete port, and only covers TS generated code.

This was necessary to resolve features: We need as much of the DescField|DescExtension available when we resolve features, and the previous implementation patched the field's "kind" and other properties, making the logic fragile.

The plan is to make feature resolution internal, remove getFeatures(), and expose relevant features as properties.

The plan is to make feature resolution internal. This optimized function resolveFeature for this use case. The function resolves from a descriptor proto message and a Desc* parent now, so that we can resolve features for a descriptor we have not wrapped yet.

Tells whether to encode a message delimited (a.k.a. proto2 group encoding) or length-prefixed.

Note that we're most likely not supporting feature message_encoding = DELIMITED correctly for map fields, and have to revisit.