refactor(archive): various cleanups

archive/_common.ts

@@ -71,7 +71,7 @@ struct posix_header {           // byte offset
 };
 */
 
-export const ustarStructure = [
+export const USTAR_STRUCTURE = [
   {
     field: "fileName",
     length: 100,
@@ -138,7 +138,7 @@ export const ustarStructure = [
   },
 ] as const;
 
-export type UstarFields = (typeof ustarStructure)[number]["field"];
+export type UstarFields = (typeof USTAR_STRUCTURE)[number]["field"];
 
 export async function readBlock(
   reader: Reader,

archive/tar.ts

@@ -33,7 +33,7 @@ import {
   type TarInfo,
   type TarMeta,
   type TarOptions,
-  ustarStructure,
+  USTAR_STRUCTURE,
 } from "./_common.ts";
 import type { Reader } from "../io/types.ts";
 import { MultiReader } from "../io/multi_reader.ts";
@@ -43,7 +43,7 @@ import { HEADER_LENGTH } from "./_common.ts";
 
 export type { TarInfo, TarMeta, TarOptions };
 
-const USTAR_MAGIC_HEADER = "ustar\u000000";
+const USTAR_MAGIC_HEADER = "ustar\u000000" as const;
 
 /**
  * Simple file reader
@@ -67,31 +67,31 @@ class FileReader implements Reader {
 }
 
 /**
- * Initialize Uint8Array of the specified length filled with 0
- * @param length
+ * Pads a number with leading zeros to a specified number of bytes.
+ *
+ * @param num The number to pad.
+ * @param bytes The number of bytes to pad the number to.
+ * @returns The padded number as a string.
  */
-function clean(length: number): Uint8Array {
-  const buffer = new Uint8Array(length);
-  return buffer;
-}
-
-function pad(num: number, bytes: number, base = 8): string {
-  const numString = num.toString(base);
-  return "000000000000".slice(numString.length + 12 - bytes) + numString;
+function pad(num: number, bytes: number): string {
+  return num.toString(8).padStart(bytes, "0");
 }
 
 /**
- * Create header for a file in a tar archive
+ * Formats the header data for a tar file entry.
+ *
+ * @param data The data object containing the values for the tar header fields.
+ * @returns The formatted header data as a Uint8Array.
  */
 function formatHeader(data: TarData): Uint8Array {
   const encoder = new TextEncoder();
-  const buffer = clean(HEADER_LENGTH);
+  const buffer = new Uint8Array(HEADER_LENGTH);
   let offset = 0;
-  ustarStructure.forEach(function (value) {
-    const entry = encoder.encode(data[value.field as keyof TarData] || "");
+  for (const { field, length } of USTAR_STRUCTURE) {
+    const entry = encoder.encode(data[field as keyof TarData] || "");
     buffer.set(entry, offset);
-    offset += value.length; // space it out with nulls
-  });
+    offset += length;
+  }
   return buffer;
 }
 
@@ -324,7 +324,7 @@ export class Tar {
       assert(tarData.fileSize !== undefined, "fileSize must be set");
       readers.push(
         new Buffer(
-          clean(
+          new Uint8Array(
             HEADER_LENGTH -
               (parseInt(tarData.fileSize, 8) % HEADER_LENGTH || HEADER_LENGTH),
           ),
@@ -333,7 +333,7 @@ export class Tar {
     });
 
     // append 2 empty records
-    readers.push(new Buffer(clean(HEADER_LENGTH * 2)));
+    readers.push(new Buffer(new Uint8Array(HEADER_LENGTH * 2)));
     return new MultiReader(readers);
   }
 }

archive/untar.ts

@@ -34,8 +34,8 @@ import {
   HEADER_LENGTH,
   readBlock,
   type TarMeta,
+  USTAR_STRUCTURE,
   type UstarFields,
-  ustarStructure,
 } from "./_common.ts";
 import { readAll } from "../io/read_all.ts";
 import type { Reader } from "../io/types.ts";
@@ -57,13 +57,15 @@ export type TarHeader = {
 const initialChecksum = 8 * 32;
 
 /**
- * Remove the trailing null codes
- * @param buffer
+ * Trims a Uint8Array by removing any trailing zero bytes.
+ *
+ * @param buffer The Uint8Array to trim.
+ * @returns A new Uint8Array with trailing zero bytes removed, or the original
+ * buffer if no trailing zero bytes are found.
  */
 function trim(buffer: Uint8Array): Uint8Array {
-  const index = buffer.findIndex((v): boolean => v === 0);
-  if (index < 0) return buffer;
-  return buffer.subarray(0, index);
+  const index = buffer.indexOf(0);
+  return index === -1 ? buffer : buffer.subarray(0, index);
 }
 
 /**
@@ -73,7 +75,7 @@ function trim(buffer: Uint8Array): Uint8Array {
 function parseHeader(buffer: Uint8Array): TarHeader {
   const data = {} as TarHeader;
   let offset = 0;
-  ustarStructure.forEach(function (value) {
+  USTAR_STRUCTURE.forEach(function (value) {
     const arr = buffer.subarray(offset, offset + value.length);
     data[value.field] = arr;
     offset += value.length;
@@ -262,22 +264,20 @@ export class Untar {
     if (fileNamePrefix.byteLength > 0) {
       meta.fileName = decoder.decode(fileNamePrefix) + "/" + meta.fileName;
     }
-    (
-      ["fileMode", "mtime", "uid", "gid"] as ["fileMode", "mtime", "uid", "gid"]
-    ).forEach((key) => {
-      const arr = trim(header[key]);
-      if (arr.byteLength > 0) {
-        meta[key] = parseInt(decoder.decode(arr), 8);
-      }
-    });
-    (["owner", "group", "type"] as ["owner", "group", "type"]).forEach(
-      (key) => {
+    (["fileMode", "mtime", "uid", "gid"] as const)
+      .forEach((key) => {
+        const arr = trim(header[key]);
+        if (arr.byteLength > 0) {
+          meta[key] = parseInt(decoder.decode(arr), 8);
+        }
+      });
+    (["owner", "group", "type"] as const)
+      .forEach((key) => {
         const arr = trim(header[key]);
         if (arr.byteLength > 0) {
           meta[key] = decoder.decode(arr);
         }
-      },
-    );
+      });
 
     meta.fileSize = parseInt(decoder.decode(header.fileSize), 8);
     meta.type = FileTypes[parseInt(meta.type!)] ?? meta.type;