feat(base32): add noPadding option

Signed-off-by: Chen Su <ghosind@gmail.com>

Author: ghosind

src/base32.ts

@@ -25,6 +25,12 @@ export interface Base32Options {
    */
   encoder?: string;
 
+  /**
+   * Disable padding character when encoding the data. Default false. This option is equivalent
+   * to setting `padChar` to empty string, and has higher priority than `padChar`.
+   */
+  noPadding?: boolean;
+
   /**
    * Padding character for padding when the encoded string in bytes is not a number to a multiple
    * of 8, or set it to empty string to disable padding. The padding character must not be newline
@@ -39,10 +45,16 @@ export class Base32Encoding {
    */
   private encoder: string;
 
+  /**
+   * Disable padding character when encoding the data. Default false. This option is equivalent
+   * to setting `padChar` to empty string, and has higher priority than `padChar`.
+   */
+  private noPadding?: boolean;
+
   /**
    * The default padding character.
    */
-  private padChar: string;
+  private padChar?: string;
 
   /**
    * Creates a Base32 encoding instance with the optional encoder alphabets and padding character
@@ -57,16 +69,20 @@ export class Base32Encoding {
    * @param options Optional settings for Base32 encoding.
    */
   constructor(options?: Base32Options) {
-    let padChar: string | undefined;
-    if (options?.padChar !== undefined) {
-      padChar = checkPadChar(options.padChar);
+    this.noPadding = !!options?.noPadding;
+
+    if (!this.noPadding) {
+      let padChar: string | undefined;
+      if (options?.padChar !== undefined) {
+        padChar = checkPadChar(options.padChar);
+      }
+      this.padChar = padChar !== undefined ? padChar : '=';
     }
-    this.padChar = padChar !== undefined ? padChar : '=';
 
     this.encoder = checkEncoder(
       options?.encoder ? options.encoder : Base32StdEncoder,
-      this.padChar,
       ENCODER_LENGTH,
+      this.padChar,
     );
   }
 
@@ -206,7 +222,9 @@ export class Base32Encoding {
     let padChar;
     let encoder;
 
-    if (!options || options.padChar === undefined || checkPadChar(options.padChar) === undefined) {
+    if (this.noPadding || !!options?.noPadding) {
+      padChar = '';
+    } else if (!options || options.padChar === undefined || checkPadChar(options.padChar) === undefined) {
       padChar = this.padChar;
     } else {
       padChar = options.padChar;
@@ -218,11 +236,11 @@ export class Base32Encoding {
       encoder = options.encoder;
     }
 
-    encoder = checkEncoder(encoder, padChar, 32);
+    encoder = checkEncoder(encoder, ENCODER_LENGTH, padChar);
 
     return {
       encoder,
-      padChar,
+      padChar: padChar!,
     };
   }
 }

src/utils.ts

@@ -4,14 +4,14 @@
  * `'\n'`) or the padding character.
  *
  * @param encoder The encoding alphabets for BaseXX encoding.
- * @param padChar The padding character.
  * @param base The base number.
+ * @param padChar The padding character.
  * @returns The valid encoder alphabets.
  * @throws The length in bytes of encoder alphabets is not equals to the base number.
  * @throws The encoder alphabets contains the padding character.
  * @throws The encoder alphabets contains the newline character ('\r' or '\n').
  */
-export const checkEncoder = (encoder: string, padChar: string, base: number): string => {
+export const checkEncoder = (encoder: string, base: number, padChar?: string): string => {
   if (encoder?.length !== base || new TextEncoder().encode(encoder).length !== base) {
     throw new Error(`encoding alphabet is not ${base}-bytes.`);
   }

test/base32.spec.ts

@@ -27,6 +27,20 @@ describe('Test base32 encode', () => {
   });
 
   it('Test base32 encode with standard encoder and no padding character', () => {
+    const encoder = new Base32Encoding({
+      noPadding: true,
+    });
+
+    assert.equal(encoder.encode(''), '');
+    assert.equal(encoder.encode('f'), 'MY');
+    assert.equal(encoder.encode('fo'), 'MZXQ');
+    assert.equal(encoder.encode('foo'), 'MZXW6');
+    assert.equal(encoder.encode('foob'), 'MZXW6YQ');
+    assert.equal(encoder.encode('fooba'), 'MZXW6YTB');
+    assert.equal(encoder.encode('foobar'), 'MZXW6YTBOI');
+  });
+
+  it('Test base32 encode with standard encoder and empty padding character', () => {
     const encoder = new Base32Encoding({
       padChar: '',
     });
@@ -165,7 +179,16 @@ describe('Test base32 decode', () => {
     assert.equal(decoder.decode('CO======', options), 'f');
     assert.equal(decoder.decode('CPNG====', options), 'fo');
 
+    options.noPadding = true;
+    assert.equal(decoder.decode('CPNMU', options), 'foo');
+    assert.equal(decoder.decode('CPNMUOG', options), 'foob');
+
+    // set padding character but noPadding is true, so padChar is ignored.
     options.padChar = '+';
+    assert.equal(decoder.decode('CPNMU', options), 'foo');
+    assert.equal(decoder.decode('CPNMUOG', options), 'foob');
+
+    options.noPadding = false;
     assert.equal(decoder.decode('CPNMU+++', options), 'foo');
     assert.equal(decoder.decode('CPNMUOG+', options), 'foob');
 

test/utils.spec.ts

@@ -6,14 +6,16 @@ import { checkEncoder, checkPadChar, decodeBytes } from '../src/utils';
 
 describe('Test check encoder', () => {
   it('Test check encoder', () => {
-    assert.doesNotThrow(() => checkEncoder(Base32StdEncoder, '=', 32));
+    assert.doesNotThrow(() => checkEncoder(Base32StdEncoder, 32));
+    assert.doesNotThrow(() => checkEncoder(Base32StdEncoder, 32, ''));
+    assert.doesNotThrow(() => checkEncoder(Base32StdEncoder, 32, '='));
     // @ts-ignore
-    assert.throws(() => checkEncoder(undefined, '=', 32));
-    assert.throws(() => checkEncoder(`${Base32StdEncoder},.`, '=', 32));
-    assert.throws(() => checkEncoder('å∫ç∂´ƒ©˙ˆ∆˚¬µ˜øπœ®ß†¨√∑≈¥234567', '=', 32));
-    assert.throws(() => checkEncoder(Base32StdEncoder, 'A', 32));
-    assert.throws(() => checkEncoder('ABCDEFGHIJKLMNOPQRSTUVWXYZ23456\n', '=', 32));
-    assert.throws(() => checkEncoder('ABCDEFGHIJKLMNOPQRSTUVWXYZ23456\r', '=', 32));
+    assert.throws(() => checkEncoder(undefined, 32, '='));
+    assert.throws(() => checkEncoder(`${Base32StdEncoder},.`, 32, '='));
+    assert.throws(() => checkEncoder('å∫ç∂´ƒ©˙ˆ∆˚¬µ˜øπœ®ß†¨√∑≈¥234567', 32, '='));
+    assert.throws(() => checkEncoder(Base32StdEncoder, 32, 'A'));
+    assert.throws(() => checkEncoder('ABCDEFGHIJKLMNOPQRSTUVWXYZ23456\n', 32, '='));
+    assert.throws(() => checkEncoder('ABCDEFGHIJKLMNOPQRSTUVWXYZ23456\r', 32, '='));
   });
 });