@aptre/protobuf-es-lite 0.1.0 → 0.1.2

package/dist/assert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+export declare function assert(condition: unknown, msg?: string): asserts condition;
+/**
+ * Assert a valid signed protobuf 32-bit integer.
+ */
+export declare function assertInt32(arg: unknown): asserts arg is number;
+/**
+ * Assert a valid unsigned protobuf 32-bit integer.
+ */
+export declare function assertUInt32(arg: unknown): asserts arg is number;
+/**
+ * Assert a valid protobuf float value.
+ */
+export declare function assertFloat32(arg: unknown): asserts arg is number;

package/dist/binary.d.ts

@@ -0,0 +1,28 @@
+import { BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter, ScalarType, ScalarValue, WireType } from "@bufbuild/protobuf";
+import { FieldInfo, FieldList } from "./field.js";
+export declare function readField(target: Record<string, any>, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+reader: IBinaryReader, field: FieldInfo, wireType: WireType, options: BinaryReadOptions): void;
+/**
+ * AnyMessage is an interface implemented by all messages. If you need to
+ * handle messages of unknown type, this interface provides a convenient
+ * index signature to access fields with message["fieldname"].
+ */
+type AnyMessage = {
+    [k: string]: any;
+};
+export declare function readMapEntry(field: FieldInfo & {
+    kind: "map";
+}, reader: IBinaryReader, options: BinaryReadOptions): [string | number, ScalarValue | AnyMessage];
+export declare function readScalar(reader: IBinaryReader, type: ScalarType): ScalarValue;
+export declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): Exclude<ScalarValue, bigint>;
+export declare function makeReadOptions(options?: Partial<BinaryReadOptions>): Readonly<BinaryReadOptions>;
+export declare function makeWriteOptions(options?: Partial<BinaryWriteOptions>): Readonly<BinaryWriteOptions>;
+export declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
+/**
+ * Serialize a message to binary data.
+ */
+export declare function writeMessage<T>(message: T, fields: FieldList, writer: IBinaryWriter, options: BinaryWriteOptions): void;
+export declare function writeMapEntry(writer: IBinaryWriter, options: BinaryWriteOptions, field: FieldInfo & {
+    kind: "map";
+}, key: string, value: any): void;
+export {};

package/dist/editions.d.ts

@@ -0,0 +1,6 @@
+import type { ImportSymbol, Schema } from "@bufbuild/protoplugin/ecmascript";
+import { DescFile } from "@bufbuild/protobuf";
+/**
+ * For syntax "editions", this function raises and error.
+ */
+export declare function getNonEditionRuntime(schema: Schema, file: DescFile): ImportSymbol;

package/dist/field-wrapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 = 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>(fieldWrapper: FieldWrapper<T> | undefined, value: any): T;

package/dist/field.d.ts

@@ -0,0 +1,393 @@
+import { EnumType, LongType, ScalarType } from "@bufbuild/protobuf";
+import { MessageType } from "./message.js";
+/**
+ * FieldInfo describes a field of a protobuf message for runtime reflection. We
+ * distinguish between the following kinds of fields:
+ *
+ * - "scalar": string, bool, float, int32, etc. The scalar type is "T".
+ * - "enum": The field was declared with an enum type. The enum type is "T".
+ * - "message": The field was declared with a message type. The message type is "T".
+ * - "map": The field was declared with map<K,V>. The key type is "K", the value type is "V".
+ *
+ * Every field always has the following properties:
+ *
+ * - "no": The field number of the protobuf field.
+ * - "name": The original name of the protobuf field.
+ * - "localName": The name of the field as used in generated code.
+ * - "jsonName": The name for JSON serialization / deserialization.
+ * - "opt": Whether the field is optional.
+ * - "req": Whether the field is required (a legacy proto2 feature).
+ * - "repeated": Whether the field is repeated.
+ * - "packed": Whether the repeated field is packed.
+ *
+ * Additionally, fields may have the following properties:
+ *
+ * - "oneof": If the field is member of a oneof group.
+ * - "default": Only proto2: An explicit default value.
+ * - "delimited": Only proto2: Use the tag-delimited group encoding.
+ */
+export type FieldInfo = fiRules<fiScalar> | fiRules<fiEnum> | fiRules<fiMessage> | fiRules<fiMap>;
+/**
+ * Provides convenient access to field information of a message type.
+ */
+export declare class FieldList {
+    private readonly _fields;
+    private readonly _normalizer;
+    private all?;
+    private numbersAsc?;
+    private jsonNames?;
+    private numbers?;
+    private members?;
+    constructor(fields: FieldListSource, normalizer: (p: FieldListSource) => FieldInfo[]);
+    /**
+     * Find field information by field name or json_name.
+     */
+    findJsonName(jsonName: string): FieldInfo | undefined;
+    /**
+     * Find field information by proto field number.
+     */
+    find(fieldNo: number): FieldInfo | undefined;
+    /**
+     * Return field information in the order they appear in the source.
+     */
+    list(): readonly FieldInfo[];
+    /**
+     * Return field information ordered by field number ascending.
+     */
+    byNumber(): readonly FieldInfo[];
+    /**
+     * In order of appearance in the source, list fields and
+     * oneof groups.
+     */
+    byMember(): readonly (FieldInfo | OneofInfo)[];
+}
+/**
+ * Version of `FieldInfo` that allows the following properties
+ * to be omitted:
+ *
+ * - "localName", "jsonName": can be omitted if equal to lowerCamelCase(name)
+ * - "opt": Can be omitted if false.
+ * - "repeated": Can be omitted if false.
+ * - "packed": Can be omitted if equal to the standard packing of the field.
+ */
+export type PartialFieldInfo = fiPartialRules<fiScalar> | fiPartialRules<fiEnum> | fiPartialRules<fiMessage> | fiPartialRules<fiMap>;
+export type FieldListSource = readonly PartialFieldInfo[] | readonly FieldInfo[] | (() => readonly PartialFieldInfo[]) | (() => readonly FieldInfo[]);
+export declare function newFieldList(fields: FieldListSource, packedByDefault: boolean): FieldList;
+export declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Returns true if the field is set.
+ */
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+export declare const fieldJsonName: typeof protoCamelCase;
+/**
+ * Returns the name of a field in generated code.
+ */
+export declare function localFieldName(protoName: string, inOneof: boolean): string;
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+export declare const safeObjectProperty: (name: string) => string;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+export declare function localOneofName(protoName: string): string;
+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;
+}
+/**
+ * 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[];
+/**
+ * Provides convenient access to field information of a oneof.
+ */
+export interface 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 delimited?: undefined;
+    readonly fields: readonly FieldInfo[];
+    /**
+     * Return field information by local name.
+     */
+    findField(localName: string): FieldInfo | undefined;
+}
+interface fiShared {
+    /**
+     * The field number of the .proto field.
+     */
+    readonly no: number;
+    /**
+     * The original name of the .proto field.
+     */
+    readonly name: string;
+    /**
+     * The name of the field as used in generated code.
+     */
+    readonly localName: string;
+    /**
+     * The name for JSON serialization / deserialization.
+     */
+    readonly jsonName: string;
+    /**
+     * The `oneof` group, if this field belongs to one.
+     */
+    readonly oneof?: OneofInfo | undefined;
+}
+interface fiScalar extends fiShared {
+    readonly kind: "scalar";
+    /**
+     * Scalar type of the field.
+     */
+    readonly T: ScalarType;
+    /**
+     * JavaScript representation of 64 bit integral types (int64, uint64,
+     * sint64, fixed64, sfixed64).
+     *
+     * By default, this is LongType.BIGINT. Generated code will use the BigInt
+     * primitive.
+     *
+     * With LongType.STRING, generated code will use the String primitive instead.
+     * This can be specified per field with the option `[jstype = JS_STRING]`:
+     *
+     * ```protobuf
+     * uint64 field_a = 1; // BigInt
+     * uint64 field_b = 2 [jstype = JS_NORMAL]; // BigInt
+     * uint64 field_b = 2 [jstype = JS_NUMBER]; // BigInt
+     * uint64 field_b = 2 [jstype = JS_STRING]; // String
+     * ```
+     *
+     * This property is ignored for other scalar types.
+     */
+    readonly L: LongType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed?
+     * BYTES and STRING can never be packed, since they are length-delimited.
+     * Other types can be packed with the field option "packed".
+     * For proto3, fields are packed by default.
+     */
+    readonly packed: boolean;
+    /**
+     * Is the field optional?
+     */
+    readonly opt: boolean;
+    /**
+     * Is the field required? A legacy proto2 feature.
+     */
+    readonly req: boolean;
+    /**
+     * Only proto2: An explicit default value.
+     */
+    readonly default: number | boolean | string | bigint | Uint8Array | undefined;
+    /**
+     * Serialize this message with the delimited format, also known as group
+     * encoding, as opposed to the standard length prefix.
+     *
+     * Only valid for message fields.
+     */
+    readonly delimited?: undefined;
+}
+interface fiMessage extends fiShared {
+    readonly kind: "message";
+    /**
+     * Message handler for the field.
+     */
+    readonly T: MessageType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed? Never true for messages.
+     */
+    readonly packed: false;
+    /**
+     * Is the field required? A legacy proto2 feature.
+     */
+    readonly req: boolean;
+    /**
+     * An explicit default value (only proto2). Never set for messages.
+     */
+    readonly default: undefined;
+    /**
+     * Serialize this message with the delimited format, also known as group
+     * encoding, as opposed to the standard length prefix.
+     *
+     * Only valid for message fields.
+     */
+    readonly delimited?: boolean;
+}
+interface fiEnum extends fiShared {
+    readonly kind: "enum";
+    /**
+     * Enum type information for the field.
+     */
+    readonly T: EnumType;
+    /**
+     * Is the field repeated?
+     */
+    readonly repeated: boolean;
+    /**
+     * Is this repeated field packed?
+     * Repeated enums can be packed with the field option "packed".
+     * For proto3, they are packed by default.
+     */
+    readonly packed: boolean;
+    /**
+     * Is the field optional?
+     */
+    readonly opt: boolean;
+    /**
+     * Is the field required? A legacy proto2 feature.
+     */
+    readonly req: boolean;
+    /**
+     * Only proto2: An explicit default value.
+     */
+    readonly default: number | undefined;
+    /**
+     * Serialize this message with the delimited format, also known as group
+     * encoding, as opposed to the standard length prefix.
+     *
+     * Only valid for message fields.
+     */
+    readonly delimited?: undefined;
+}
+interface fiMap extends fiShared {
+    readonly kind: "map";
+    /**
+     * Map key type.
+     *
+     * The key_type can be any integral or string type
+     * (so, any scalar type except for floating point
+     * types and bytes)
+     */
+    readonly K: Exclude<ScalarType, ScalarType.FLOAT | ScalarType.DOUBLE | ScalarType.BYTES>;
+    /**
+     * Map value type. Can be scalar, enum, or message.
+     */
+    readonly V: {
+        readonly kind: "scalar";
+        readonly T: ScalarType;
+    } | {
+        readonly kind: "enum";
+        readonly T: EnumType;
+    } | {
+        readonly kind: "message";
+        readonly T: MessageType;
+    };
+    /**
+     * Is the field repeated? Never true for maps.
+     */
+    readonly repeated: false;
+    /**
+     * Is this repeated field packed? Never true for maps.
+     */
+    readonly packed: false;
+    /**
+     * An explicit default value (only proto2). Never set for maps.
+     */
+    readonly default: undefined;
+    /**
+     * Serialize this message with the delimited format, also known as group
+     * encoding, as opposed to the standard length prefix.
+     *
+     * Only valid for message fields.
+     */
+    readonly delimited?: undefined;
+}
+type fiRules<T> = Omit<T, "oneof" | "repeat" | "repeated" | "packed" | "opt" | "req"> & ({
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: false;
+    readonly req: boolean;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: true;
+    readonly req: false;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: boolean;
+    readonly packed: boolean;
+    readonly opt: false;
+    readonly req: boolean;
+    readonly oneof: undefined;
+} | {
+    readonly repeated: false;
+    readonly packed: false;
+    readonly opt: false;
+    readonly req: false;
+    readonly oneof: OneofInfo;
+});
+type fiPartialRules<T extends fiScalar | fiMap | fiEnum | fiMessage> = Omit<T, "jsonName" | "localName" | "oneof" | "repeat" | "repeated" | "packed" | "opt" | "req" | "default" | "L" | "delimited"> & ({
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt?: false;
+    readonly req?: boolean;
+    readonly oneof?: undefined;
+    default?: T["default"];
+    L?: LongType;
+    delimited?: boolean;
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt: true;
+    readonly req?: false;
+    readonly oneof?: undefined;
+    default?: T["default"];
+    L?: LongType;
+    delimited?: boolean;
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: boolean;
+    readonly packed?: boolean;
+    readonly opt?: false;
+    readonly req?: boolean;
+    readonly oneof?: undefined;
+    default?: T["default"];
+    L?: LongType;
+    delimited?: boolean;
+} | {
+    readonly jsonName?: string;
+    readonly repeated?: false;
+    readonly packed?: false;
+    readonly opt?: false;
+    readonly req?: false;
+    readonly oneof: string;
+    default?: T["default"];
+    L?: LongType;
+    delimited?: boolean;
+});
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Message, AnyMessage, PartialMessage, MessageType, compareMessages, createMessageType, } from "./message.js";
+export { newFieldList, FieldList, PartialFieldInfo, FieldInfo, OneofInfo, fieldJsonName, localFieldName, localOneofName, } from "./field.js";
+export { scalarEquals, scalarZeroValue, isScalarZeroValue } from "./scalar.js";

package/dist/is-message.d.ts

@@ -0,0 +1,6 @@
+import { FieldInfo } from "./field.js";
+import { AnyMessage, Message, PartialMessage } from "./message.js";
+/**
+ * Check whether the given partial has all fields present recursively.
+ */
+export declare function isCompleteMessage<T extends Message<T> = AnyMessage>(arg: PartialMessage<T>, fields: readonly FieldInfo[]): arg is T;

package/dist/json.d.ts

@@ -0,0 +1,10 @@
+import { JsonReadOptions, JsonValue, JsonWriteOptions, JsonWriteStringOptions } from "@bufbuild/protobuf";
+import { FieldInfo, FieldList } from "./field.js";
+export declare function makeReadOptions(options?: Partial<JsonReadOptions>): Readonly<JsonReadOptions>;
+export declare function makeWriteOptions(options?: Partial<JsonWriteStringOptions>): Readonly<JsonWriteStringOptions>;
+export declare function readMessage<T>(fields: FieldList, typeName: string, json: JsonValue, options: JsonReadOptions, message: T): T;
+export declare function writeMessage<T>(message: T, fields: FieldList, options: JsonWriteOptions): JsonValue;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField(field: FieldInfo, target: Record<string, any>): void;

package/dist/message.d.ts

@@ -0,0 +1,137 @@
+import { BinaryReadOptions, JsonReadOptions, JsonValue, MessageType as BufMessageType, BinaryWriteOptions, JsonWriteOptions, JsonWriteStringOptions } from "@bufbuild/protobuf";
+import { FieldList, FieldListSource } from "./field.js";
+/**
+ * Message is the base type of every message.
+ */
+export interface Message<T extends Message<T>> {
+}
+/**
+ * AnyMessage is an interface implemented by all messages. If you need to
+ * handle messages of unknown type, this interface provides a convenient
+ * index signature to access fields with message["fieldname"].
+ */
+export interface AnyMessage extends Message<AnyMessage> {
+    [k: string]: any;
+}
+/**
+ * PartialMessage<T> constructs a type from a message. The resulting type
+ * only contains the protobuf field members of the message, and all of them
+ * are optional.
+ *
+ * Note that the optionality of the fields is the only difference between
+ * PartialMessage and PlainMessage.
+ *
+ * PartialMessage is similar to the built-in type Partial<T>, but recursive,
+ * and respects `oneof` groups.
+ */
+export type PartialMessage<T extends Message<T>> = {
+    [P in keyof T as T[P] extends Function ? never : P]?: PartialField<T[P]>;
+};
+export type PartialField<F> = F extends (Date | Uint8Array | bigint | boolean | string | number) ? F : F extends Array<infer U> ? Array<PartialField<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<PartialField<U>> : F extends Message<infer U> ? PartialMessage<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
+    case: C;
+    value: PartialMessage<V>;
+} : F extends {
+    case: string | undefined;
+    value?: unknown;
+} ? F : F extends {
+    [key: string | number]: Message<infer U>;
+} ? {
+    [key: string | number]: PartialMessage<U>;
+} : F;
+type OneofSelectedMessage<K extends string, M extends Message<M>> = {
+    case: K;
+    value: M;
+};
+/**
+ * MessageType represents a protobuf message declaration. It provides:
+ * - a constructor that produces an instance of the message
+ * - metadata for reflection-based operations
+ * - common functionality like serialization
+ */
+export interface MessageType<T extends Message<T> = AnyMessage> extends Pick<BufMessageType, "fieldWrapper"> {
+    /**
+     * The fully qualified name of the message.
+     */
+    readonly typeName: string;
+    /**
+     * Field metadata.
+     */
+    readonly fields: FieldList;
+    /**
+     * Create a new instance of this message with zero values for fields.
+     */
+    create(partial?: PartialMessage<T>): T;
+    /**
+     * Create a deep copy.
+     */
+    clone(a: T | undefined | null): T | undefined | null;
+    /**
+     * Parse from binary data, merging fields.
+     *
+     * Repeated fields are appended. Map entries are added, overwriting
+     * existing keys.
+     *
+     * If a message field is already present, it will be merged with the
+     * new data.
+     */
+    fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): T;
+    /**
+     * Parse a message from a JSON value.
+     */
+    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Parse a message from a JSON string.
+     */
+    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
+    /**
+     * Returns true if the given arguments have equal field values, recursively.
+     * Will also return true if both messages are `undefined` or `null`.
+     */
+    equals(a: T | undefined | null, b: T | undefined | null): boolean;
+    /**
+     * Serialize the message to binary data.
+     */
+    toBinary(a: T, options?: Partial<BinaryWriteOptions>): Uint8Array;
+    /**
+     * Serialize the message to a JSON value, a JavaScript value that can be
+     * passed to JSON.stringify().
+     */
+    toJson(a: T, options?: Partial<JsonWriteOptions>): JsonValue;
+    /**
+     * Serialize the message to a JSON string.
+     */
+    toJsonString(a: T, options?: Partial<JsonWriteStringOptions>): string;
+}
+export interface MessageTypeParams<T extends Message<T>> extends Pick<MessageType<T>, "typeName" | "fieldWrapper"> {
+    /**
+     * Fields contains the list of message fields.
+     */
+    fields: FieldListSource;
+    /**
+     * `packedByDefault` specifies whether fields that do not specify `packed`
+     * should be packed (proto3) or unpacked (proto2).
+     */
+    packedByDefault: boolean;
+    /**
+     * `delimitedMessageEncoding` specifies whether fields are encoded without
+     * delimited fields (proto3) or with (proto2 legacy).
+     */
+    delimitedMessageEncoding?: boolean;
+    /**
+     * Serialize the message to a JSON value, a JavaScript value that can be
+     * passed to JSON.stringify().
+     *
+     * When passed as MessageTypeParams this will override the default serializer behavior.
+     */
+    toJson?: MessageType<T>["toJson"];
+}
+export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
+export declare function cloneMessage<T extends Message<T>>(message: T, fields: FieldList): T;
+/**
+ * createMessageType creates a new message type.
+ *
+ * The argument `packedByDefault` specifies whether fields that do not specify
+ * `packed` should be packed (proto3) or unpacked (proto2).
+ */
+export declare function createMessageType<T extends Message<T>>(params: MessageTypeParams<T>): MessageType<T>;
+export {};

package/dist/partial.d.ts

@@ -0,0 +1,3 @@
+import { FieldList } from "./field.js";
+import { Message, PartialMessage } from "./message.js";
+export declare function applyPartialMessage<T extends Message<T>>(source: PartialMessage<T> | undefined, target: T, fields: FieldList): void;

package/dist/protoc-gen-es-lite-plugin.d.ts

@@ -0,0 +1 @@
+export declare const protocGenEsLite: import("@bufbuild/protoplugin").Plugin;

package/dist/scalar.d.ts

@@ -0,0 +1,17 @@
+import { LongType, ScalarType, ScalarValue } from "@bufbuild/protobuf";
+/**
+ * Returns true if both scalar values are equal.
+ */
+export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
+/**
+ * Returns the zero value for the given scalar type.
+ */
+export declare function scalarZeroValue<T extends ScalarType, L extends LongType>(type: T, longType: L): ScalarValue<T, L>;
+/**
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;

package/dist/typescript.d.ts

@@ -0,0 +1,5 @@
+import type { DescExtension, DescField } from "@bufbuild/protobuf";
+import type { GeneratedFile, Printable, Schema } from "@bufbuild/protoplugin/ecmascript";
+export declare function generateTs(schema: Schema): void;
+export declare function generateFieldInfo(f: GeneratedFile, field: DescField | DescExtension): void;
+export declare function getFieldInfoLiteral(field: DescField | DescExtension): Printable;

package/dist/typescript.js

@@ -86,7 +86,6 @@ function generateMessage(schema, f, message) {
     f.print("    ],");
     f.print("    packedByDefault: ", message.file.proto.syntax === "proto3", ",");
     f.print("  },");
-    f.print("  true,");
     f.print(");");
     f.print();
     for (const nestedEnum of message.nestedEnums) {

package/dist/unknown.d.ts

@@ -0,0 +1,8 @@
+import { WireType } from "@bufbuild/protobuf";
+export declare const unknownFieldsSymbol: unique symbol;
+export declare function listUnknownFields(message: any): ReadonlyArray<{
+    no: number;
+    wireType: WireType;
+    data: Uint8Array;
+}>;
+export declare function handleUnknownField(message: any, no: number, wireType: WireType, data: Uint8Array): void;

package/dist/util.d.ts

@@ -0,0 +1,23 @@
+import { DescExtension, DescField } from "@bufbuild/protobuf";
+import type { Printable } from "@bufbuild/protoplugin/ecmascript";
+export declare function getFieldTypeInfo(field: DescField | DescExtension): {
+    typing: Printable;
+    optional: boolean;
+    typingInferrableFromZeroValue: boolean;
+};
+/**
+ * Return a printable expression for the default value of a field.
+ * Only applicable for singular scalar and enum fields.
+ */
+export declare function getFieldDefaultValueExpression(field: DescField | DescExtension, enumAs?: "enum_value_as_is" | "enum_value_as_integer" | "enum_value_as_cast_integer"): Printable | undefined;
+/**
+ * Return a printable expression for the zero value of a field.
+ *
+ * Returns either:
+ * - empty array literal for repeated fields
+ * - empty object literal for maps
+ * - undefined for message fields
+ * - an enums first value
+ * - scalar zero value
+ */
+export declare function getFieldZeroValueExpression(field: DescField | DescExtension, enumAs?: "enum_value_as_is" | "enum_value_as_integer" | "enum_value_as_cast_integer"): Printable | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aptre/protobuf-es-lite",
   "description": "Lightweight Protobuf codegen for TypeScript and JavaScript.",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "Apache-2.0",
   "repository": {
     "url": "git+ssh://git@github.com/aperturerobotics/protobuf-es-lite.git"
@@ -21,6 +21,7 @@
     "protoc-gen-es-lite": "bin/protoc-gen-es-lite"
   },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",

package/tsconfig.base.json

@@ -18,6 +18,7 @@
     "moduleResolution": "Node16",
     "module": "Node16",
     "verbatimModuleSyntax": true,
-    "skipLibCheck": false
+    "skipLibCheck": false,
+    "declaration": true
   }
 }