@aptre/protobuf-es-lite 0.2.6 → 0.2.8

package/.ignore

@@ -2,3 +2,4 @@ node_modules/
 *.pb.go
 *.pb.ts
 go.sum
+dist/

package/README.md

@@ -9,9 +9,9 @@
 
 protobuf-es-lite is a TypeScript and JavaScript protobuf implementation.
 
-It uses [@bufbuild/protoplugin] to implement **protoc-gen-es-lite** which generates js and/or ts code.
+It uses [protoplugin] to implement **protoc-gen-es-lite** which generates js and/or ts code.
 
-[@bufbuild/protoplugin]: https://github.com/bufbuild/protobuf-es/tree/main/packages/protoplugin
+[protoplugin]: ./src/protoplugin
 
 See [protobuf-es] for information about protoplugin.
 
@@ -48,11 +48,16 @@ const myMessageBin = new MyMessage(myMessage).toBinary()
 declaration object containing the marshal and unmarshal functions. This allows
 using interfaces and plain messages everywhere and does not need classes.
 
+[ts-proto]: https://github.com/stephenh/ts-proto
+
 This fork generates the ts-proto style with the protoc-gen-es tools:
 
 ```typescript
+// Create a partial MyMessage with just one field sets.
 const myMessage: MyMessage = {body: "Hello world"}
-const myCompleteMessage: CompleteMessage<MyMessage> = MyMessage.create(myMessage)
+// Creates a version of MyMessage filled with zeros.
+const myCompleteMessage: MyMessage = MyMessage.create(myMessage)
+// Convert MyMessage to binary.
 const myMessageBin = MyMessage.toBinary(myCompleteMessage)
 ```
 
@@ -61,21 +66,18 @@ const myMessageBin = MyMessage.toBinary(myCompleteMessage)
 ## Installation
 
 `protoc-gen-es` generates base types - messages and enumerations - from your
-Protocol Buffer schema. The generated code requires the runtime library
-[@bufbuild/protobuf].
-
-[@bufbuild/protobuf]: https://www.npmjs.com/package/@bufbuild/protobuf
+Protocol Buffer schema.
 
 To install the plugin and the runtime library, run:
 
 ```shell
-npm install --save-dev @aptre/protoc-gen-es-lite
-npm install @bufbuild/protobuf
+npm install @aptre/protoc-gen-es-lite
 ```
 
 We use peer dependencies to ensure that code generator and runtime library are
 compatible with each other. Note that npm installs them automatically, but yarn
 and pnpm do not.
+
 ## Generating code
 
 ### With buf
@@ -91,10 +93,10 @@ Add a new configuration file `buf.gen.yaml`:
 # For details, see https://docs.buf.build/configuration/v1/buf-gen-yaml
 version: v1
 plugins:
-  # This will invoke protoc-gen-es and write output to src/gen
-  - plugin: es
+  # This will invoke protoc-gen-es-lite and write output to src/gen
+  - plugin: es-lite
     out: src/gen
-    opt: 
+    opt:
       # Add more plugin options here
       - target=ts
 ```
@@ -106,16 +108,15 @@ npx buf generate
 ```
 
 Note that `buf` can generate from various [inputs](https://docs.buf.build/reference/inputs),
-not just local protobuf files. 
-
+not just local protobuf files.
 
 ### With protoc
 
 ```bash
 PATH=$PATH:$(pwd)/node_modules/.bin \
   protoc -I . \
-  --es_out src/gen \
-  --es_opt target=ts \
+  --es-lite_out src/gen \
+  --es-lite_opt target=ts \
   a.proto b.proto c.proto
 ```
 
@@ -126,7 +127,7 @@ Since yarn v2 and above does not use a `node_modules` directory, you need to
 change the variable a bit:
 
 ```bash
-PATH=$(dirname $(yarn bin protoc-gen-es)):$PATH
+PATH=$(dirname $(yarn bin protoc-gen-es-lite)):$PATH
 ```
 
 ## Plugin options
@@ -137,9 +138,9 @@ This option controls whether the plugin generates JavaScript, TypeScript,
 or TypeScript declaration files.
 
 Possible values:
-- `target=js` - generates a `_pb.js` file for every `.proto` input file.
-- `target=ts` - generates a `_pb.ts` file for every `.proto` input file.
-- `target=dts` - generates a `_pb.d.ts` file for every `.proto` input file.
+- `target=js` - generates a `.pb.js` file for every `.proto` input file.
+- `target=ts` - generates a `.pb.ts` file for every `.proto` input file.
+- `target=dts` - generates a `.pb.d.ts` file for every `.proto` input file.
 
 Multiple values can be given by separating them with `+`, for example
 `target=js+dts`.
@@ -151,7 +152,7 @@ bundler configurations. If you prefer to generate TypeScript, use `target=ts`.
 ### `import_extension=.js`
 
 By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
-(and all other plugins based on [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin))
+(and all other plugins based on [@aptre/protobuf-es-lite/protoplugin](https://www.npmjs.com/package/@aptre/protobuf-es-lite/protoplugin))
 uses a `.js` file extensions in import paths, even in TypeScript files.
 
 This is unintuitive, but necessary for [ECMAScript modules in Node.js](https://www.typescriptlang.org/docs/handbook/esm-node.html).
@@ -165,7 +166,7 @@ in import paths with the given value. For example, set
 ### `js_import_style`
 
 By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
-(and all other plugins based on [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin))
+(and all other plugins based on [@aptre/protobuf-es-lite/protoplugin](https://www.npmjs.com/package/@aptre/protobuf-es-lite/protoplugin))
 generate ECMAScript `import` and `export` statements. For use cases where 
 CommonJS is difficult to avoid, this option can be used to generate CommonJS 
 `require()` calls.
@@ -178,7 +179,7 @@ Possible values:
 ### `keep_empty_files=true`
 
 By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
-(and all other plugins based on [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin))
+(and all other plugins based on [@aptre/protobuf-es-lite/protoplugin](https://www.npmjs.com/package/@aptre/protobuf-es-lite/protoplugin))
 omit empty files from the plugin output. This option disables pruning of
 empty files, to allow for smooth interoperation with Bazel and similar
 tooling that requires all output files to be declared ahead of time.
@@ -187,7 +188,7 @@ Unless you use Bazel, it is very unlikely that you need this option.
 ### `ts_nocheck=false`
 
 By default, [protoc-gen-es](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
-(and all other plugins based on [@bufbuild/protoplugin](https://www.npmjs.com/package/@bufbuild/protoplugin))
+(and all other plugins based on [@aptre/protobuf-es-lite/protoplugin](https://www.npmjs.com/package/@aptre/protobuf-es-lite/protoplugin))
 generate an annotation at the top of each file: `// @ts-nocheck`.
 
 We generate the annotation to support a wide range of compiler configurations and

package/bin/protoc-gen-es-lite

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const {runNodeJs} = require("@bufbuild/protoplugin");
-const {protocGenEsLite} = require("../dist/protoc-gen-es-lite-plugin.js");
+const {runNodeJs} = require("../dist/protoplugin");
+const {protocGenEsLite} = require("../dist/prototc-gen-es-lite/protoc-gen-es-lite-plugin.js");
 
-runNodeJs(protocGenEsLite);
+runNodeJs(protocGenEsLite);

package/dist/binary-encoding.d.ts

@@ -0,0 +1,420 @@
+/**
+ * Protobuf binary format wire types.
+ *
+ * A wire type provides just enough information to find the length of the
+ * following value.
+ *
+ * See https://developers.google.com/protocol-buffers/docs/encoding#structure
+ */
+export declare enum WireType {
+    /**
+     * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
+     */
+    Varint = 0,
+    /**
+     * Used for fixed64, sfixed64, double.
+     * Always 8 bytes with little-endian byte order.
+     */
+    Bit64 = 1,
+    /**
+     * Used for string, bytes, embedded messages, packed repeated fields
+     *
+     * Only repeated numeric types (types which use the varint, 32-bit,
+     * or 64-bit wire types) can be packed. In proto3, such fields are
+     * packed by default.
+     */
+    LengthDelimited = 2,
+    /**
+     * Start of a tag-delimited aggregate, such as a proto2 group, or a message
+     * in editions with message_encoding = DELIMITED.
+     */
+    StartGroup = 3,
+    /**
+     * End of a tag-delimited aggregate.
+     */
+    EndGroup = 4,
+    /**
+     * Used for fixed32, sfixed32, float.
+     * Always 4 bytes with little-endian byte order.
+     */
+    Bit32 = 5
+}
+type TextEncoderLike = {
+    encode(input?: string): Uint8Array;
+};
+type TextDecoderLike = {
+    decode(input?: Uint8Array): string;
+};
+export interface IBinaryReader {
+    /**
+     * Current position.
+     */
+    readonly pos: number;
+    /**
+     * Number of bytes available in this reader.
+     */
+    readonly len: number;
+    /**
+     * Reads a tag - field number and wire type.
+     */
+    tag(): [number, WireType];
+    /**
+     * Skip one element on the wire and return the skipped data.
+     */
+    skip(wireType: WireType): Uint8Array;
+    /**
+     * Read a `uint32` field, an unsigned 32 bit varint.
+     */
+    uint32(): number;
+    /**
+     * Read a `int32` field, a signed 32 bit varint.
+     */
+    int32(): number;
+    /**
+     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(): number;
+    /**
+     * Read a `int64` field, a signed 64-bit varint.
+     */
+    int64(): bigint | string;
+    /**
+     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(): bigint | string;
+    /**
+     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(): bigint | string;
+    /**
+     * Read a `uint64` field, an unsigned 64-bit varint.
+     */
+    uint64(): bigint | string;
+    /**
+     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(): bigint | string;
+    /**
+     * Read a `bool` field, a variant.
+     */
+    bool(): boolean;
+    /**
+     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(): number;
+    /**
+     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(): number;
+    /**
+     * Read a `float` field, 32-bit floating point number.
+     */
+    float(): number;
+    /**
+     * Read a `double` field, a 64-bit floating point number.
+     */
+    double(): number;
+    /**
+     * Read a `bytes` field, length-delimited arbitrary data.
+     */
+    bytes(): Uint8Array;
+    /**
+     * Read a `string` field, length-delimited data converted to UTF-8 text.
+     */
+    string(): string;
+}
+export interface IBinaryWriter {
+    /**
+     * Return all bytes written and reset this writer.
+     */
+    finish(): Uint8Array;
+    /**
+     * Start a new fork for length-delimited data like a message
+     * or a packed repeated field.
+     *
+     * Must be joined later with `join()`.
+     */
+    fork(): IBinaryWriter;
+    /**
+     * Join the last fork. Write its length and bytes, then
+     * return to the previous state.
+     */
+    join(): IBinaryWriter;
+    /**
+     * Writes a tag (field number and wire type).
+     *
+     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`
+     *
+     * Generated code should compute the tag ahead of time and call `uint32()`.
+     */
+    tag(fieldNo: number, type: WireType): IBinaryWriter;
+    /**
+     * Write a chunk of raw bytes.
+     */
+    raw(chunk: Uint8Array): IBinaryWriter;
+    /**
+     * Write a `uint32` value, an unsigned 32 bit varint.
+     */
+    uint32(value: number): IBinaryWriter;
+    /**
+     * Write a `int32` value, a signed 32 bit varint.
+     */
+    int32(value: number): IBinaryWriter;
+    /**
+     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(value: number): IBinaryWriter;
+    /**
+     * Write a `int64` value, a signed 64-bit varint.
+     */
+    int64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `uint64` value, an unsigned 64-bit varint.
+     */
+    uint64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `bool` value, a variant.
+     */
+    bool(value: boolean): IBinaryWriter;
+    /**
+     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(value: number): IBinaryWriter;
+    /**
+     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(value: number): IBinaryWriter;
+    /**
+     * Write a `float` value, 32-bit floating point number.
+     */
+    float(value: number): IBinaryWriter;
+    /**
+     * Write a `double` value, a 64-bit floating point number.
+     */
+    double(value: number): IBinaryWriter;
+    /**
+     * Write a `bytes` value, length-delimited arbitrary data.
+     */
+    bytes(value: Uint8Array): IBinaryWriter;
+    /**
+     * Write a `string` value, length-delimited data converted to UTF-8 text.
+     */
+    string(value: string): IBinaryWriter;
+}
+export declare class BinaryWriter implements IBinaryWriter {
+    /**
+     * We cannot allocate a buffer for the entire output
+     * because we don't know it's size.
+     *
+     * So we collect smaller chunks of known size and
+     * concat them later.
+     *
+     * Use `raw()` to push data to this array. It will flush
+     * `buf` first.
+     */
+    private chunks;
+    /**
+     * A growing buffer for byte values. If you don't know
+     * the size of the data you are writing, push to this
+     * array.
+     */
+    protected buf: number[];
+    /**
+     * Previous fork states.
+     */
+    private stack;
+    /**
+     * Text encoder instance to convert UTF-8 to bytes.
+     */
+    private readonly textEncoder;
+    constructor(textEncoder?: TextEncoderLike);
+    /**
+     * Return all bytes written and reset this writer.
+     */
+    finish(): Uint8Array;
+    /**
+     * Start a new fork for length-delimited data like a message
+     * or a packed repeated field.
+     *
+     * Must be joined later with `join()`.
+     */
+    fork(): IBinaryWriter;
+    /**
+     * Join the last fork. Write its length and bytes, then
+     * return to the previous state.
+     */
+    join(): IBinaryWriter;
+    /**
+     * Writes a tag (field number and wire type).
+     *
+     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
+     *
+     * Generated code should compute the tag ahead of time and call `uint32()`.
+     */
+    tag(fieldNo: number, type: WireType): IBinaryWriter;
+    /**
+     * Write a chunk of raw bytes.
+     */
+    raw(chunk: Uint8Array): IBinaryWriter;
+    /**
+     * Write a `uint32` value, an unsigned 32 bit varint.
+     */
+    uint32(value: number): IBinaryWriter;
+    /**
+     * Write a `int32` value, a signed 32 bit varint.
+     */
+    int32(value: number): IBinaryWriter;
+    /**
+     * Write a `bool` value, a variant.
+     */
+    bool(value: boolean): IBinaryWriter;
+    /**
+     * Write a `bytes` value, length-delimited arbitrary data.
+     */
+    bytes(value: Uint8Array): IBinaryWriter;
+    /**
+     * Write a `string` value, length-delimited data converted to UTF-8 text.
+     */
+    string(value: string): IBinaryWriter;
+    /**
+     * Write a `float` value, 32-bit floating point number.
+     */
+    float(value: number): IBinaryWriter;
+    /**
+     * Write a `double` value, a 64-bit floating point number.
+     */
+    double(value: number): IBinaryWriter;
+    /**
+     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(value: number): IBinaryWriter;
+    /**
+     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(value: number): IBinaryWriter;
+    /**
+     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(value: number): IBinaryWriter;
+    /**
+     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `int64` value, a signed 64-bit varint.
+     */
+    int64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(value: string | number | bigint): IBinaryWriter;
+    /**
+     * Write a `uint64` value, an unsigned 64-bit varint.
+     */
+    uint64(value: string | number | bigint): IBinaryWriter;
+}
+export declare class BinaryReader implements IBinaryReader {
+    /**
+     * Current position.
+     */
+    pos: number;
+    /**
+     * Number of bytes available in this reader.
+     */
+    readonly len: number;
+    private readonly buf;
+    private readonly view;
+    private readonly textDecoder;
+    constructor(buf: Uint8Array, textDecoder?: TextDecoderLike);
+    /**
+     * Reads a tag - field number and wire type.
+     */
+    tag(): [number, WireType];
+    /**
+     * Skip one element on the wire and return the skipped data.
+     * Supports WireType.StartGroup since v2.0.0-alpha.23.
+     */
+    skip(wireType: WireType): Uint8Array;
+    protected varint64: () => [number, number];
+    /**
+     * Throws error if position in byte array is out of range.
+     */
+    protected assertBounds(): void;
+    /**
+     * Read a `uint32` field, an unsigned 32 bit varint.
+     */
+    uint32: () => number;
+    /**
+     * Read a `int32` field, a signed 32 bit varint.
+     */
+    int32(): number;
+    /**
+     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
+     */
+    sint32(): number;
+    /**
+     * Read a `int64` field, a signed 64-bit varint.
+     */
+    int64(): bigint | string;
+    /**
+     * Read a `uint64` field, an unsigned 64-bit varint.
+     */
+    uint64(): bigint | string;
+    /**
+     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
+     */
+    sint64(): bigint | string;
+    /**
+     * Read a `bool` field, a variant.
+     */
+    bool(): boolean;
+    /**
+     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
+     */
+    fixed32(): number;
+    /**
+     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
+     */
+    sfixed32(): number;
+    /**
+     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
+     */
+    fixed64(): bigint | string;
+    /**
+     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
+     */
+    sfixed64(): bigint | string;
+    /**
+     * Read a `float` field, 32-bit floating point number.
+     */
+    float(): number;
+    /**
+     * Read a `double` field, a 64-bit floating point number.
+     */
+    double(): number;
+    /**
+     * Read a `bytes` field, length-delimited arbitrary data.
+     */
+    bytes(): Uint8Array;
+    /**
+     * Read a `string` field, length-delimited data converted to UTF-8 text.
+     */
+    string(): string;
+}
+export {};