apache-iggy 0.5.0-edge.1

package/dist/src/wire/message/partitioning.utils.js

@@ -0,0 +1,77 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { uint32ToBuf, uint64ToBuf } from '../number.utils.js';
+export const PartitionKind = {
+    Balanced: 1,
+    PartitionId: 2,
+    MessageKey: 3
+};
+const Balanced = {
+    kind: PartitionKind.Balanced,
+    value: null
+};
+const PartitionId = (id) => ({
+    kind: PartitionKind.PartitionId,
+    value: id
+});
+const MessageKey = (key) => ({
+    kind: PartitionKind.MessageKey,
+    value: key
+});
+// Helper
+export const Partitioning = {
+    Balanced,
+    PartitionId,
+    MessageKey
+};
+export const serializeMessageKey = (v) => {
+    if (v instanceof Buffer)
+        return v;
+    if ('string' === typeof v)
+        return Buffer.from(v);
+    if ('number' === typeof v)
+        return uint32ToBuf(v);
+    if ('bigint' === typeof v)
+        return uint64ToBuf(v);
+    throw new Error(`cannot serialize messageKey ${v}, ${typeof v}`);
+};
+export const serializePartitioningValue = (part) => {
+    const { kind, value } = part;
+    switch (kind) {
+        case PartitionKind.Balanced: return Buffer.alloc(0);
+        case PartitionKind.PartitionId: return uint32ToBuf(value);
+        case PartitionKind.MessageKey: return serializeMessageKey(value);
+    }
+};
+export const default_partionning = {
+    kind: PartitionKind.Balanced,
+    value: null
+};
+export const serializePartitioning = (p) => {
+    const part = p || default_partionning;
+    const b = Buffer.alloc(2);
+    const bValue = serializePartitioningValue(part);
+    b.writeUint8(part.kind);
+    b.writeUint8(bValue.length, 1);
+    return Buffer.concat([
+        b,
+        bValue
+    ]);
+};
+//# sourceMappingURL=partitioning.utils.js.map

package/dist/src/wire/message/poll-messages.command.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 type { Id } from '../identifier.utils.js';
+import type { CommandResponse } from '../../client/client.type.js';
+import type { Consumer } from '../offset/offset.utils.js';
+import { type PollingStrategy, type PollMessagesResponse } from './poll.utils.js';
+export type PollMessages = {
+    streamId: Id;
+    topicId: Id;
+    consumer: Consumer;
+    partitionId: number;
+    pollingStrategy: PollingStrategy;
+    count: number;
+    autocommit: boolean;
+};
+export declare const POLL_MESSAGES: {
+    code: number;
+    serialize: ({ streamId, topicId, consumer, partitionId, pollingStrategy, count, autocommit }: PollMessages) => Buffer<ArrayBuffer>;
+    deserialize: (r: CommandResponse) => {
+        partitionId: number;
+        currentOffset: bigint;
+        count: number;
+        messages: import("./poll.utils.js").Message[];
+    };
+};
+export declare const pollMessages: (getClient: import("../../client/client.type.js").ClientProvider) => (arg: PollMessages) => Promise<PollMessagesResponse>;
+//# sourceMappingURL=poll-messages.command.d.ts.map

package/dist/src/wire/message/poll-messages.command.js

@@ -0,0 +1,32 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { wrapCommand } from '../command.utils.js';
+import { COMMAND_CODE } from '../command.code.js';
+import { serializePollMessages, deserializePollMessages } from './poll.utils.js';
+export const POLL_MESSAGES = {
+    code: COMMAND_CODE.PollMessages,
+    serialize: ({ streamId, topicId, consumer, partitionId, pollingStrategy, count, autocommit }) => {
+        return serializePollMessages(streamId, topicId, consumer, partitionId, pollingStrategy, count, autocommit);
+    },
+    deserialize: (r) => {
+        return deserializePollMessages(r.data);
+    }
+};
+export const pollMessages = wrapCommand(POLL_MESSAGES);
+//# sourceMappingURL=poll-messages.command.js.map

package/dist/src/wire/message/poll.utils.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { type Id } from '../identifier.utils.js';
+import { type ValueOf } from '../../type.utils.js';
+import { type Consumer } from '../offset/offset.utils.js';
+import { type HeadersMap } from './header.utils.js';
+import { Transform } from 'node:stream';
+import { IggyMessageHeader } from './iggy-header.utils.js';
+export declare const PollingStrategyKind: {
+    readonly Offset: 1;
+    readonly Timestamp: 2;
+    readonly First: 3;
+    readonly Last: 4;
+    readonly Next: 5;
+};
+export type PollingStrategyKind = typeof PollingStrategyKind;
+export type PollingStrategyKindId = keyof PollingStrategyKind;
+export type PollingStrategyKindValue = ValueOf<PollingStrategyKind>;
+export type OffsetPollingStrategy = {
+    kind: PollingStrategyKind['Offset'];
+    value: bigint;
+};
+export type TimestampPollingStrategy = {
+    kind: PollingStrategyKind['Timestamp'];
+    value: bigint;
+};
+export type FirstPollingStrategy = {
+    kind: PollingStrategyKind['First'];
+    value: 0n;
+};
+export type LastPollingStrategy = {
+    kind: PollingStrategyKind['Last'];
+    value: 0n;
+};
+export type NextPollingStrategy = {
+    kind: PollingStrategyKind['Next'];
+    value: 0n;
+};
+export type PollingStrategy = OffsetPollingStrategy | TimestampPollingStrategy | FirstPollingStrategy | LastPollingStrategy | NextPollingStrategy;
+export declare const PollingStrategy: {
+    Next: NextPollingStrategy;
+    First: FirstPollingStrategy;
+    Last: LastPollingStrategy;
+    Offset: (n: bigint) => OffsetPollingStrategy;
+    Timestamp: (n: bigint) => TimestampPollingStrategy;
+};
+export declare const serializePollMessages: (streamId: Id, topicId: Id, consumer: Consumer, partitionId: number, pollingStrategy: PollingStrategy, count?: number, autocommit?: boolean) => Buffer<ArrayBuffer>;
+export declare const MessageState: {
+    Available: number;
+    Unavailable: number;
+    Poisoned: number;
+    MarkedForDeletion: number;
+};
+type MessageState = typeof MessageState;
+type MessageStateId = keyof MessageState;
+export declare const mapMessageState: (k: number) => MessageStateId;
+export type Message = {
+    headers: IggyMessageHeader;
+    payload: Buffer;
+    userHeaders: HeadersMap;
+};
+export type PollMessagesResponse = {
+    partitionId: number;
+    currentOffset: bigint;
+    count: number;
+    messages: Message[];
+};
+export declare const deserializeMessages: (b: Buffer) => Message[];
+export declare const deserializePollMessages: (r: Buffer, pos?: number) => {
+    partitionId: number;
+    currentOffset: bigint;
+    count: number;
+    messages: Message[];
+};
+export declare const deserializePollMessagesTransform: () => Transform;
+export {};
+//# sourceMappingURL=poll.utils.d.ts.map

package/dist/src/wire/message/poll.utils.js

@@ -0,0 +1,135 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { reverseRecord } from '../../type.utils.js';
+import { serializeGetOffset } from '../offset/offset.utils.js';
+import { deserializeHeaders } from './header.utils.js';
+import { Transform } from 'node:stream';
+import { deserializeIggyMessageHeaders, IGGY_MESSAGE_HEADER_SIZE } from './iggy-header.utils.js';
+export const PollingStrategyKind = {
+    Offset: 1,
+    Timestamp: 2,
+    First: 3,
+    Last: 4,
+    Next: 5
+};
+const Next = {
+    kind: PollingStrategyKind.Next,
+    value: 0n
+};
+const First = {
+    kind: PollingStrategyKind.First,
+    value: 0n
+};
+const Last = {
+    kind: PollingStrategyKind.Last,
+    value: 0n
+};
+const Offset = (n) => ({
+    kind: PollingStrategyKind.Offset,
+    value: n
+});
+const Timestamp = (n) => ({
+    kind: PollingStrategyKind.Timestamp,
+    value: n
+});
+// helper
+export const PollingStrategy = {
+    Next,
+    First,
+    Last,
+    Offset,
+    Timestamp
+};
+export const serializePollMessages = (streamId, topicId, consumer, partitionId, // default to 1
+pollingStrategy, // default to OffsetPollingStrategy
+count = 10, autocommit = false) => {
+    const b = Buffer.allocUnsafe(14);
+    b.writeUInt8(pollingStrategy.kind, 0);
+    b.writeBigUInt64LE(pollingStrategy.value, 1);
+    b.writeUInt32LE(count, 9);
+    b.writeUInt8(!!autocommit ? 1 : 0, 13);
+    return Buffer.concat([
+        serializeGetOffset(streamId, topicId, consumer, partitionId),
+        b
+    ]);
+};
+export const MessageState = {
+    Available: 1,
+    Unavailable: 10,
+    Poisoned: 20,
+    MarkedForDeletion: 30
+};
+const ReverseMessageState = reverseRecord(MessageState);
+export const mapMessageState = (k) => {
+    if (!ReverseMessageState[k])
+        throw new Error(`unknow message state: ${k}`);
+    return ReverseMessageState[k];
+};
+export const deserializeMessages = (b) => {
+    const messages = [];
+    let pos = 0;
+    const len = b.length;
+    while (pos < len) {
+        if (pos + IGGY_MESSAGE_HEADER_SIZE > len)
+            break;
+        const bHead = b.subarray(pos, pos + IGGY_MESSAGE_HEADER_SIZE);
+        const headers = deserializeIggyMessageHeaders(bHead);
+        pos += IGGY_MESSAGE_HEADER_SIZE;
+        const plEnd = pos + headers.payloadLength;
+        if (plEnd > len)
+            break;
+        const payload = b.subarray(pos, plEnd);
+        pos += headers.payloadLength;
+        let userHeaders = {};
+        if (headers.userHeadersLength > 0 && plEnd + headers.userHeadersLength <= len) {
+            userHeaders = deserializeHeaders(b.subarray(plEnd, plEnd + headers.userHeadersLength));
+            pos += headers.userHeadersLength;
+        }
+        messages.push({
+            headers,
+            payload,
+            userHeaders
+        });
+    }
+    return messages;
+};
+export const deserializePollMessages = (r, pos = 0) => {
+    const partitionId = r.readUInt32LE(pos);
+    const currentOffset = r.readBigUInt64LE(pos + 4);
+    const count = r.readUInt32LE(pos + 12);
+    const messages = deserializeMessages(r.subarray(16));
+    return {
+        partitionId,
+        currentOffset,
+        count,
+        messages
+    };
+};
+export const deserializePollMessagesTransform = () => new Transform({
+    objectMode: true,
+    transform(chunk, encoding, cb) {
+        try {
+            return cb(null, deserializePollMessages(chunk));
+        }
+        catch (err) {
+            cb(new Error('deserializePollMessage::transform error', { cause: err }), null);
+        }
+    }
+});
+//# sourceMappingURL=poll.utils.js.map

package/dist/src/wire/message/send-messages.command.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { type Id } from '../identifier.utils.js';
+import { type CreateMessage } from './message.utils.js';
+import type { Partitioning } from './partitioning.utils.js';
+export type SendMessages = {
+    streamId: Id;
+    topicId: Id;
+    messages: CreateMessage[];
+    partition?: Partitioning;
+};
+export declare const SEND_MESSAGES: {
+    code: number;
+    serialize: ({ streamId, topicId, messages, partition }: SendMessages) => Buffer<ArrayBuffer>;
+    deserialize: (r: import("../../index.js").CommandResponse) => boolean;
+};
+export declare const sendMessages: (getClient: import("../../index.js").ClientProvider) => (arg: SendMessages) => Promise<boolean>;
+//# sourceMappingURL=send-messages.command.d.ts.map

package/dist/src/wire/message/send-messages.command.js

@@ -0,0 +1,31 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { serializeSendMessages } from './message.utils.js';
+import { deserializeVoidResponse } from '../../client/client.utils.js';
+import { wrapCommand } from '../command.utils.js';
+import { COMMAND_CODE } from '../command.code.js';
+export const SEND_MESSAGES = {
+    code: COMMAND_CODE.SendMessages,
+    serialize: ({ streamId, topicId, messages, partition }) => {
+        return serializeSendMessages(streamId, topicId, messages, partition);
+    },
+    deserialize: deserializeVoidResponse
+};
+export const sendMessages = wrapCommand(SEND_MESSAGES);
+//# sourceMappingURL=send-messages.command.js.map

package/dist/src/wire/message/send-messages.command.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 {};
+//# sourceMappingURL=send-messages.command.test.d.ts.map

package/dist/src/wire/message/send-messages.command.test.js

@@ -0,0 +1,88 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { uuidv7, uuidv4 } from 'uuidv7';
+import { SEND_MESSAGES } from './send-messages.command.js';
+import { HeaderValue } from './header.utils.js';
+describe('SendMessages', () => {
+    describe('serialize', () => {
+        const t1 = {
+            streamId: 911,
+            topicId: 213,
+            messages: [
+                { payload: 'a' },
+                { id: 0, payload: 'b' },
+                { id: 123, payload: 'X' },
+                { id: 0n, payload: 'c' },
+                { id: 1236234534554n, payload: 'X' },
+                { id: uuidv4(), payload: 'd' },
+                { id: uuidv7(), payload: 'e' },
+            ],
+        };
+        it('serialize SendMessages into a buffer', () => {
+            assert.deepEqual(SEND_MESSAGES.serialize(t1).length, 533);
+        });
+        it('serialize all kinds of messageId', () => {
+            assert.doesNotThrow(() => SEND_MESSAGES.serialize(t1));
+        });
+        it('does not throw on number message id', () => {
+            const t = { ...t1, messages: [{ id: 42, payload: 'm' }] };
+            assert.doesNotThrow(() => SEND_MESSAGES.serialize(t));
+        });
+        it('does not throw on bigint message id', () => {
+            const t = { ...t1, messages: [{ id: 123n, payload: 'm' }] };
+            assert.doesNotThrow(() => SEND_MESSAGES.serialize(t));
+        });
+        it('does not throw on uuid message id', () => {
+            const t = { ...t1, messages: [{ id: uuidv4(), payload: 'uuid' }] };
+            assert.doesNotThrow(() => SEND_MESSAGES.serialize(t));
+        });
+        it('throw on invalid string message id', () => {
+            const t = { ...t1, messages: [{ id: 'foo', payload: 'm' }] };
+            assert.throws(() => SEND_MESSAGES.serialize(t));
+        });
+        it('throw on invalid number message id', () => {
+            const t = { ...t1, messages: [{ id: -12, payload: 'n' }] };
+            assert.throws(() => SEND_MESSAGES.serialize(t));
+        });
+        it('throw on invalid bigint message id', () => {
+            const t = { ...t1, messages: [{ id: -12n, payload: 'bn' }] };
+            assert.throws(() => SEND_MESSAGES.serialize(t));
+        });
+        it('serialize message with headers', () => {
+            const t = {
+                streamId: 911,
+                topicId: 213,
+                messages: [
+                    { payload: 'm', headers: { p: HeaderValue.Bool(true) } },
+                    { payload: 'q', headers: { 'v-aze': HeaderValue.Uint8(128) } },
+                    { payload: 'x', headers: { q: HeaderValue.Double(1 / 3) } },
+                    { payload: 's', headers: { x: HeaderValue.Uint32(123) } },
+                    { payload: 'r', headers: { y: HeaderValue.Uint64(42n) } },
+                    { payload: 'g', headers: { y: HeaderValue.Float(42.3) } },
+                    { payload: 'c', headers: { ID: HeaderValue.String(uuidv7()) } },
+                    { payload: 'l', headers: { val: HeaderValue.Raw(Buffer.from(uuidv4())) } }
+                ]
+            };
+            assert.doesNotThrow(() => SEND_MESSAGES.serialize(t));
+        });
+    });
+});
+//# sourceMappingURL=send-messages.command.test.js.map

package/dist/src/wire/number.utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 declare const boolToBuf: (v: boolean) => Buffer<ArrayBuffer>;
+export declare const int8ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const int16ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const int32ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const int64ToBuf: (v: bigint) => Buffer<ArrayBuffer>;
+export declare const uint8ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const uint16ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const uint32ToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const uint64ToBuf: (v: bigint) => Buffer<ArrayBuffer>;
+export declare const floatToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare const doubleToBuf: (v: number) => Buffer<ArrayBuffer>;
+export declare function u128ToBuf(num: bigint, width?: number): Buffer;
+export declare function u128LEBufToBigint(b: Buffer): bigint;
+//# sourceMappingURL=number.utils.d.ts.map

package/dist/src/wire/number.utils.js

@@ -0,0 +1,85 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 const boolToBuf = (v) => {
+    const b = Buffer.allocUnsafe(1);
+    b.writeUInt8(!v ? 0 : 1);
+    return b;
+};
+export const int8ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(1);
+    b.writeInt8(v);
+    return b;
+};
+export const int16ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(2);
+    b.writeInt16LE(v);
+    return b;
+};
+export const int32ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(4);
+    b.writeInt32LE(v);
+    return b;
+};
+export const int64ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(8);
+    b.writeBigInt64LE(v);
+    return b;
+};
+export const uint8ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(1);
+    b.writeUInt8(v);
+    return b;
+};
+export const uint16ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(2);
+    b.writeUInt16LE(v);
+    return b;
+};
+export const uint32ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(4);
+    b.writeUInt32LE(v);
+    return b;
+};
+export const uint64ToBuf = (v) => {
+    const b = Buffer.allocUnsafe(8);
+    b.writeBigUInt64LE(v);
+    return b;
+};
+export const floatToBuf = (v) => {
+    const b = Buffer.allocUnsafe(4);
+    b.writeFloatLE(v);
+    return b;
+};
+export const doubleToBuf = (v) => {
+    const b = Buffer.allocUnsafe(8);
+    b.writeDoubleLE(v);
+    return b;
+};
+// bigint => u128 LE
+export function u128ToBuf(num, width = 16) {
+    const hex = num.toString(16);
+    const b = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
+    return b.reverse();
+}
+// u128 LE => Bigint
+export function u128LEBufToBigint(b) {
+    const hex = b.reverse().toString('hex');
+    return hex.length === 0 ? BigInt(0) : BigInt(`0x${hex}`);
+}
+//# sourceMappingURL=number.utils.js.map