@seriousme/opifex 1.11.2 → 2.0.3

package/mqttPacket/pubblishAcks.ts

@@ -1,44 +1,45 @@
-import type {
-  CodecOpts,
-  PacketId,
-  ProtocolLevelNoV5,
-  TPacketType,
-} from "./types.ts";
+import type { CodecOpts, PacketId, TPacketType } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import { ReasonCode, type TReasonCode } from "./ReasonCode.ts";
 import type { PubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Decoder, DecoderError } from "./decoder.ts";
 import { Encoder } from "./encoder.ts";
 
-export type AckPacketV4<T> = {
-  type: TPacketType;
+export type AckPacketV4<T extends TPacketType> = {
+  type: T;
   protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
 };
 
-export type AckPacketV5<T> = {
-  type: TPacketType;
+export type AckPacketV5<T extends TPacketType> = {
+  type: T;
   protocolLevel: 5;
   id: PacketId;
   reasonCode?: TReasonCode;
   properties?: PubackProperties;
 };
+
 /**
  * all 4 ack packets are identical except for packet type and flags of Pubrel
  */
-export type AckPacket<T> = AckPacketV4<T> | AckPacketV5<T>;
+export type AckPacket<T extends TPacketType> = AckPacketV4<T> | AckPacketV5<T>;
+
 /**
  * PubackPacket is sent to indicate publish complete (QoS 1)
  */
 export type PubackPacket = AckPacket<typeof PacketType.puback>;
+
 /**
  * Pubrec is sent to indicate publish received (QoS 2)
  */
 export type PubrecPacket = AckPacket<typeof PacketType.pubrec>;
+
 /**
  * Pubrel is sent to indicate publish release (QoS 2)
  */
 export type PubrelPacket = AckPacket<typeof PacketType.pubrel>;
+
 /**
  * Pubcomp is sent to indicate publish complete (QoS 2)
  */
@@ -50,74 +51,64 @@ export type AnyAckPacket =
   | PubrelPacket
   | PubcompPacket;
 
-export const anyAck: {
-  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): AnyAckPacket;
-} = {
-  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
-    const flags = packet.type === PacketType.pubrel ? 2 : 0;
-    const encoder = new Encoder(packet.type);
-    encoder.setInt16(packet.id);
-    if (packet.protocolLevel === 5) {
-      const reasonCode = packet.reasonCode || ReasonCode.success;
-      // if remaining length is less than 1 the value of 0x00 (success) is used.
-      if (
-        reasonCode === ReasonCode.success &&
-        Object.keys(packet.properties || {}).length === 0
-      ) {
-        return encoder.done(flags);
-      }
-      encoder.setReasonCode(reasonCode);
-      encoder.setProperties(
-        packet.properties || {},
-        packet.type,
-        codecOpts.maxOutgoingPacketSize,
-      );
+export function encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
+  const flags = packet.type === PacketType.pubrel ? 2 : 0;
+  const encoder = new Encoder(packet.type);
+  encoder.setInt16(packet.id);
+  if (packet.protocolLevel === 5) {
+    const reasonCode = packet.reasonCode || ReasonCode.success;
+    // if remaining length is less than 1 the value of 0x00 (success) is used.
+    if (
+      reasonCode === ReasonCode.success &&
+      Object.keys(packet.properties || {}).length === 0
+    ) {
+      return encoder.done(flags);
     }
-    return encoder.done(flags);
-  },
+    encoder.setReasonCode(reasonCode);
+    encoder.setProperties(
+      packet.properties || {},
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): AnyAckPacket {
-    const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
-    if (flags !== expectedFlags) {
-      throw new DecoderError("Invalid flags");
-    }
-    const decoder = new Decoder(packetType, buffer);
-    const id = decoder.getInt16();
-    if (codecOpts.protocolLevel !== 5) {
-      decoder.done();
-      return {
-        type: packetType,
-        protocolLevel: codecOpts.protocolLevel,
-        id,
-      };
-    }
-    if (decoder.atEnd()) {
-      return {
-        type: packetType,
-        protocolLevel: 5,
-        id,
-        reasonCode: 0,
-      };
-    }
-    const reasonCode = decoder.getReasonCode();
-    const properties = decoder.getProperties(packetType);
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: TPacketType,
+): AnyAckPacket {
+  const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
+  if (flags !== expectedFlags) {
+    throw new DecoderError("Invalid flags");
+  }
+  const decoder = new Decoder(packetType, buffer);
+  const id = decoder.getInt16();
+  if (codecOpts.protocolLevel !== 5) {
+    decoder.done();
     return {
-      type: packetType,
+      type: packetType as AnyAckPacket["type"],
+      protocolLevel: codecOpts.protocolLevel,
+      id,
+    } as AnyAckPacket;
+  }
+  if (decoder.atEnd()) {
+    return {
+      type: packetType as AnyAckPacket["type"],
       protocolLevel: 5,
       id,
-      reasonCode,
-      properties,
-    };
-  },
-};
+      reasonCode: 0,
+    } as AnyAckPacket;
+  }
+  const reasonCode = decoder.getReasonCode();
+  const properties = decoder.getProperties(packetType);
+  return {
+    type: packetType as AnyAckPacket["type"],
+    protocolLevel: 5,
+    id,
+    reasonCode,
+    properties,
+  } as AnyAckPacket;
+}

package/mqttPacket/publish.ts

@@ -2,11 +2,11 @@ import type {
   CodecOpts,
   Dup,
   Payload,
-  ProtocolLevelNoV5,
   QoS,
   Topic,
   TPacketType,
 } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { PublishProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
@@ -22,108 +22,89 @@ export type PublishPacketV4 = {
   protocolLevel: ProtocolLevelNoV5;
   topic: Topic;
   payload: Payload;
-  dup?: Dup;
-  retain?: boolean;
-  qos?: QoS;
-  id?: number;
+  dup?: Dup | undefined;
+  retain?: boolean | undefined;
+  qos?: QoS | undefined;
+  id?: number | undefined;
 };
 export type PublishPacketV5 = {
   type: TPacketType;
   protocolLevel: 5;
   topic: Topic;
   payload: Payload;
-  dup?: Dup;
-  retain?: boolean;
-  qos?: QoS;
-  id?: number;
-  properties?: PublishProperties;
+  dup?: Dup | undefined;
+  retain?: boolean | undefined;
+  qos?: QoS | undefined;
+  id?: number | undefined;
+  properties?: PublishProperties | undefined;
 };
-
+/** Publish packet (v4|v5). */
 export type PublishPacket = PublishPacketV4 | PublishPacketV5;
 
-export const publish: {
-  encode(packet: PublishPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): PublishPacket;
-} = {
-  encode(packet: PublishPacket, codecOpts: CodecOpts): Uint8Array {
-    const qos = packet.qos || 0;
+export function encode(
+  packet: PublishPacket,
+  codecOpts: CodecOpts,
+): Uint8Array {
+  const qos = packet.qos || 0;
 
-    const flags = (packet.dup ? BitMask.bit3 : 0) +
-      (qos & 2 ? BitMask.bit2 : 0) +
-      (qos & 1 ? BitMask.bit1 : 0) +
-      (packet.retain ? BitMask.bit0 : 0);
+  const flags = (packet.dup ? BitMask.bit3 : 0) +
+    (qos & 2 ? BitMask.bit2 : 0) +
+    (qos & 1 ? BitMask.bit1 : 0) +
+    (packet.retain ? BitMask.bit0 : 0);
 
-    const encoder = new Encoder(packet.type);
-    encoder.setTopic(packet.topic);
+  const encoder = new Encoder(packet.type);
+  encoder.setUtf8String(packet.topic);
 
-    if (qos === 1 || qos === 2) {
-      if (typeof packet.id !== "number" || packet.id < 1) {
-        throw new EncoderError("when qos is 1 or 2, packet must have id");
-      }
-      encoder.setInt16(packet.id);
+  if (qos === 1 || qos === 2) {
+    if (typeof packet.id !== "number" || packet.id < 1) {
+      throw new EncoderError("when qos is 1 or 2, packet must have id");
     }
+    encoder.setInt16(packet.id);
+  }
 
-    if (packet.protocolLevel === 5) {
-      encoder.setProperties(
-        packet.properties || {},
-        PacketType.publish,
-        codecOpts.maxOutgoingPacketSize,
-      );
-    }
-    encoder.setRemainder(packet.payload);
-    return encoder.done(flags);
-  },
+  if (packet.protocolLevel === 5) {
+    encoder.setProperties(
+      packet.properties || {},
+      PacketType.publish,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  encoder.setRemainder(packet.payload);
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): PublishPacket {
-    const dup = booleanFlag(flags, BitMask.bit3);
-    const qos = (flags & 6) >> 1;
-    const retain = booleanFlag(flags, BitMask.bit0);
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: TPacketType,
+): PublishPacket {
+  const dup = booleanFlag(flags, BitMask.bit3);
+  const qos = (flags & 6) >> 1;
+  const retain = booleanFlag(flags, BitMask.bit0);
 
-    if (qos !== 0 && qos !== 1 && qos !== 2) {
-      throw new DecoderError("Invalid qos");
-    }
+  if (qos !== 0 && qos !== 1 && qos !== 2) {
+    throw new DecoderError("Invalid qos");
+  }
 
-    if (dup && qos === 0) {
-      throw new DecoderError("Invalid qos for possible duplicate");
-    }
+  if (dup && qos === 0) {
+    throw new DecoderError("Invalid qos for possible duplicate");
+  }
 
-    const decoder = new Decoder(packetType, buffer);
-    const topic = decoder.getTopic();
+  const decoder = new Decoder(packetType, buffer);
+  const topic = decoder.getUTF8String();
 
-    let id = undefined;
-    if (qos > 0) {
-      id = decoder.getInt16();
-    }
-    if (codecOpts.protocolLevel === 5) {
-      const properties = decoder.getProperties(PacketType.publish);
-      const payload = decoder.getRemainder();
-      return {
-        type: PacketType.publish,
-        protocolLevel: 5,
-        properties,
-        topic,
-        payload,
-        dup,
-        retain,
-        qos,
-        id,
-      };
-    }
-    // no decoder.done() required because of getRemainder
+  let id = undefined;
+  if (qos > 0) {
+    id = decoder.getInt16();
+  }
+  if (codecOpts.protocolLevel === 5) {
+    const properties = decoder.getProperties(PacketType.publish);
     const payload = decoder.getRemainder();
     return {
       type: PacketType.publish,
-      protocolLevel: codecOpts.protocolLevel,
+      protocolLevel: 5,
+      properties,
       topic,
       payload,
       dup,
@@ -131,5 +112,17 @@ export const publish: {
       qos,
       id,
     };
-  },
-};
+  }
+  // no decoder.done() required because of getRemainder
+  const payload = decoder.getRemainder();
+  return {
+    type: PacketType.publish,
+    protocolLevel: codecOpts.protocolLevel,
+    topic,
+    payload,
+    dup,
+    retain,
+    qos,
+    id,
+  };
+}

package/mqttPacket/suback.ts

@@ -1,11 +1,11 @@
 import type {
   CodecOpts,
   PacketId,
-  ProtocolLevelNoV5,
   ReturnCodes,
   TPacketType,
   TReasonCode,
 } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { SubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Encoder } from "./encoder.ts";
@@ -33,68 +33,58 @@ export type SubackPacketV5 = {
  */
 export type SubackPacket = SubackPacketV4 | SubackPacketV5;
 
-export const suback: {
-  encode(packet: SubackPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): SubackPacket;
-} = {
-  encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
-    const flags = 0;
-    const encoder = new Encoder(packet.type);
-    encoder.setInt16(packet.id);
-    if (packet.protocolLevel !== 5) {
-      for (const code of packet.returnCodes) {
-        if (!validReturnCodes.includes(code)) {
-          throw new Error("Invalid return code");
-        }
+export function encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
+  const flags = 0;
+  const encoder = new Encoder(packet.type);
+  encoder.setInt16(packet.id);
+  if (packet.protocolLevel !== 5) {
+    for (const code of packet.returnCodes) {
+      if (!validReturnCodes.includes(code)) {
+        throw new Error("Invalid return code");
       }
-      encoder.setRemainder(packet.returnCodes);
-      return encoder.done(flags);
-    }
-    encoder.setProperties(
-      packet.properties || {},
-      packet.type,
-      codecOpts.maxOutgoingPacketSize,
-    );
-    for (const code of packet.reasonCodes) {
-      encoder.setReasonCode(code);
     }
+    encoder.setRemainder(packet.returnCodes);
     return encoder.done(flags);
-  },
+  }
+  encoder.setProperties(
+    packet.properties || {},
+    packet.type,
+    codecOpts.maxOutgoingPacketSize,
+  );
+  for (const code of packet.reasonCodes) {
+    encoder.setReasonCode(code);
+  }
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    _flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): SubackPacket {
-    const packet = {} as SubackPacket;
-    const decoder = new Decoder(packetType, buffer);
-    packet.type = PacketType.suback;
-    packet.id = decoder.getInt16();
-    packet.protocolLevel = codecOpts.protocolLevel;
+export function decode(
+  buffer: Uint8Array,
+  _flags: number,
+  codecOpts: CodecOpts,
+  packetType: TPacketType,
+): SubackPacket {
+  const packet = {} as SubackPacket;
+  const decoder = new Decoder(packetType, buffer);
+  packet.type = PacketType.suback;
+  packet.id = decoder.getInt16();
+  packet.protocolLevel = codecOpts.protocolLevel;
 
-    if (packet.protocolLevel !== 5) {
-      const payload = decoder.getRemainder();
-      packet.returnCodes = [];
-      for (const code of payload) {
-        if (!validReturnCodes.includes(code)) {
-          throw new DecoderError("Invalid return code");
-        }
-        packet.returnCodes.push(code);
+  if (packet.protocolLevel !== 5) {
+    const payload = decoder.getRemainder();
+    packet.returnCodes = [];
+    for (const code of payload) {
+      if (!validReturnCodes.includes(code)) {
+        throw new DecoderError("Invalid return code");
       }
-      return packet;
-    }
-    packet.properties = decoder.getProperties(PacketType.suback);
-    packet.reasonCodes = [];
-    while (!decoder.atEnd()) {
-      const code = decoder.getReasonCode();
-      packet.reasonCodes.push(code);
+      packet.returnCodes.push(code);
     }
     return packet;
-  },
-};
+  }
+  packet.properties = decoder.getProperties(PacketType.suback);
+  packet.reasonCodes = [];
+  while (!decoder.atEnd()) {
+    const code = decoder.getReasonCode();
+    packet.reasonCodes.push(code);
+  }
+  return packet;
+}