modern-tar 0.4.2 → 0.5.1

package/README.md

@@ -205,8 +205,11 @@ import { pipeline } from 'node:stream/promises';
 const sources: TarSource[] = [
   { type: 'file', source: './package.json', target: 'project/package.json' },
   { type: 'directory', source: './src', target: 'project/src' },
+  
   { type: 'content', content: 'Hello World!', target: 'project/hello.txt' },
-  { type: 'content', content: '#!/bin/bash\necho "Executable"', target: 'bin/script.sh', mode: 0o755 }
+  { type: 'content', content: '#!/bin/bash\necho "Executable"', target: 'bin/script.sh', mode: 0o755 },
+  { type: 'stream', content: createReadStream('./large-file.bin'), target: 'project/data.bin', size: 1048576 },
+  { type: 'stream', content: fetch('/api/data').then(r => r.body!), target: 'project/remote.json', size: 2048 }
 ];
 
 const archiveStream = packTar(sources);

package/dist/fs/index.d.ts

@@ -1,4 +1,4 @@
-import { TarEntryData, TarHeader, UnpackOptions } from "../types-D-xPQp4Z.js";
+import { TarEntryData, TarHeader, UnpackOptions } from "../types-Dc3p5B3s.js";
 import { Readable, Writable } from "node:stream";
 import { Stats } from "node:fs";
 
@@ -50,34 +50,51 @@ interface UnpackOptionsFS extends UnpackOptions {
    */
   concurrency?: number;
 }
+/** Base interface containing common metadata properties for all source types. */
+interface BaseSource {
+  /** Destination path for the entry inside the tar archive. */
+  target: string;
+  /** Optional modification time. Overrides filesystem values or defaults to current time. */
+  mtime?: Date;
+  /** Optional user ID. Overrides filesystem values or defaults to 0. */
+  uid?: number;
+  /** Optional group ID. Overrides filesystem values or defaults to 0. */
+  gid?: number;
+  /** Optional user name. */
+  uname?: string;
+  /** Optional group name. */
+  gname?: string;
+  /** Optional Unix file permissions for the entry (e.g., 0o644, 0o755). */
+  mode?: number;
+}
 /** Describes a file on the local filesystem to be added to the archive. */
-interface FileSource {
+interface FileSource extends BaseSource {
   type: "file";
   /** Path to the source file on the local filesystem. */
   source: string;
-  /** Destination path for the file inside the tar archive. */
-  target: string;
 }
 /** Describes a directory on the local filesystem to be added to the archive. */
-interface DirectorySource {
+interface DirectorySource extends BaseSource {
   type: "directory";
   /** Path to the source directory on the local filesystem. */
   source: string;
-  /** Destination path for the directory inside the tar archive. */
-  target: string;
 }
-/** Describes raw content to be added to the archive. Supports all TarEntryData types including strings, buffers, streams, blobs, and null. */
-interface ContentSource {
+/** Describes raw, buffered content to be added to the archive. */
+interface ContentSource extends BaseSource {
   type: "content";
-  /** Raw content to add. Supports string, Uint8Array, ArrayBuffer, ReadableStream, Blob, or null. */
+  /** Raw content to add. Supports string, Uint8Array, ArrayBuffer, Blob, or null. */
   content: TarEntryData;
-  /** Destination path for the content inside the tar archive. */
-  target: string;
-  /** Optional Unix file permissions for the entry (e.g., 0o644). */
-  mode?: number;
+}
+/** Describes a stream of content to be added to the archive. */
+interface StreamSource extends BaseSource {
+  type: "stream";
+  /** A Readable or ReadableStream. */
+  content: Readable | ReadableStream;
+  /** The total size of the stream's content in bytes. This is required for streams. */
+  size: number;
 }
 /** A union of all possible source types for creating a tar archive. */
-type TarSource = FileSource | DirectorySource | ContentSource;
+type TarSource = FileSource | DirectorySource | ContentSource | StreamSource;
 //#endregion
 //#region src/fs/pack.d.ts
 /**

package/dist/fs/index.js

@@ -1,4 +1,4 @@
-import { createTarPacker, createTarUnpacker, normalizeBody, transformHeader } from "../unpacker-DBTDVhe4.js";
+import { createTarPacker, createTarUnpacker, normalizeBody, transformHeader } from "../unpacker-yB6Ahxxk.js";
 import * as fs from "node:fs/promises";
 import { cpus } from "node:os";
 import * as path from "node:path";
@@ -46,7 +46,16 @@ function packTar(sources, options = {}) {
 				packer.add(result.header);
 				if (result.body) if (result.body instanceof Uint8Array) {
 					if (result.body.length > 0) packer.write(result.body);
-				} else {
+				} else if (result.body instanceof Readable || result.body instanceof ReadableStream) try {
+					for await (const chunk of result.body) {
+						if (stream.destroyed) break;
+						packer.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk));
+					}
+				} catch (error) {
+					stream.destroy(error);
+					return;
+				}
+				else {
 					const { handle, size } = result.body;
 					try {
 						let bytesLeft = size;
@@ -87,32 +96,44 @@ function packTar(sources, options = {}) {
 			let jobResult = null;
 			const target = job.target.replace(/\\/g, "/");
 			try {
-				if (job.type === "content") {
-					const data = await normalizeBody(job.content);
+				if (job.type === "content" || job.type === "stream") {
+					let body$1;
+					let size;
+					if (job.type === "stream") {
+						if (typeof job.size !== "number" || job.size <= 0) throw new Error("StreamSource requires a positive size property.");
+						size = job.size;
+						body$1 = job.content;
+					} else {
+						const content = await normalizeBody(job.content);
+						size = content.length;
+						body$1 = content;
+					}
 					const stat$1 = {
-						size: data.length,
+						size,
 						isFile: () => true,
 						isDirectory: () => false,
 						isSymbolicLink: () => false,
 						mode: job.mode ?? 420,
-						mtime: /* @__PURE__ */ new Date(),
-						uid: process.getuid?.() ?? 0,
-						gid: process.getgid?.() ?? 0
+						mtime: job.mtime ?? /* @__PURE__ */ new Date(),
+						uid: job.uid ?? 0,
+						gid: job.gid ?? 0
 					};
 					if (filter && !filter(target, stat$1)) return;
 					let header$1 = {
 						name: target,
 						type: "file",
-						size: stat$1.size,
+						size,
 						mode: stat$1.mode,
 						mtime: stat$1.mtime,
 						uid: stat$1.uid,
-						gid: stat$1.gid
+						gid: stat$1.gid,
+						uname: job.uname,
+						gname: job.gname
 					};
 					if (map) header$1 = map(header$1);
 					jobResult = {
 						header: header$1,
-						body: data
+						body: body$1
 					};
 					return;
 				}
@@ -128,10 +149,12 @@ function packTar(sources, options = {}) {
 				let header = {
 					name: target,
 					size: 0,
-					mode: Number(stat.mode),
-					mtime: stat.mtime,
-					uid: Number(stat.uid),
-					gid: Number(stat.gid),
+					mode: job.mode ?? Number(stat.mode),
+					mtime: job.mtime ?? stat.mtime,
+					uid: job.uid ?? Number(stat.uid),
+					gid: job.gid ?? Number(stat.gid),
+					uname: job.uname,
+					gname: job.gname,
 					type: "file"
 				};
 				let body;

package/dist/{types-D-xPQp4Z.d.ts → types-Dc3p5B3s.d.ts}

@@ -46,31 +46,7 @@ interface TarHeader {
 /**
  * Union type for entry body data that can be packed into a tar archive.
  */
-type TarEntryData = string | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | Blob | null | undefined;
-/**
- * Represents a complete entry to be packed into a tar archive.
- *
- * Combines header metadata with optional body data. Used as input to {@link packTar}
- * and the controller returned by {@link createTarPacker}.
- */
-interface TarEntry {
-  header: TarHeader;
-  body?: TarEntryData;
-}
-/**
- * Represents an entry parsed from a tar archive stream.
- */
-interface ParsedTarEntry {
-  header: TarHeader;
-  body: ReadableStream<Uint8Array>;
-}
-/**
- * Represents an extracted entry with fully buffered content.
- */
-interface ParsedTarEntryWithData {
-  header: TarHeader;
-  data: Uint8Array;
-}
+type TarEntryData = string | Uint8Array | ArrayBuffer | Blob | null | undefined;
 /**
  * Configuration options for creating a tar decoder stream.
  */
@@ -105,4 +81,4 @@ interface UnpackOptions extends DecoderOptions {
   streamTimeout?: number;
 }
 //#endregion
-export { DecoderOptions, ParsedTarEntry, ParsedTarEntryWithData, TarEntry, TarEntryData, TarHeader, UnpackOptions };
+export { DecoderOptions, TarEntryData, TarHeader, UnpackOptions };

package/dist/{unpacker-DBTDVhe4.js → unpacker-yB6Ahxxk.js}

@@ -93,8 +93,10 @@ function readOctal(view, offset, size) {
 function readNumeric(view, offset, size) {
 	if (view[offset] & 128) {
 		let result = 0;
-		for (let i = 0; i < size; i++) result = result << 8 | view[offset + i];
-		return result & ~(128 << (size - 1) * 8);
+		result = view[offset] & 127;
+		for (let i = 1; i < size; i++) result = result * 256 + view[offset + i];
+		if (!Number.isSafeInteger(result)) throw new Error("TAR number too large");
+		return result;
 	}
 	return readOctal(view, offset, size);
 }
@@ -126,7 +128,6 @@ async function normalizeBody(body) {
 	if (typeof body === "string") return encoder.encode(body);
 	if (body instanceof ArrayBuffer) return new Uint8Array(body);
 	if (body instanceof Blob) return new Uint8Array(await body.arrayBuffer());
-	if (body instanceof ReadableStream) return streamToBuffer(body);
 	throw new TypeError("Unsupported content type for entry body.");
 }
 
@@ -253,6 +254,16 @@ function parseUstarHeader(block, strict) {
 	if (magic === "ustar") header.prefix = readString(block, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE);
 	return header;
 }
+const PAX_MAPPING = {
+	path: ["name", (v) => v],
+	linkpath: ["linkname", (v) => v],
+	size: ["size", (v) => parseInt(v, 10)],
+	mtime: ["mtime", parseFloat],
+	uid: ["uid", (v) => parseInt(v, 10)],
+	gid: ["gid", (v) => parseInt(v, 10)],
+	uname: ["uname", (v) => v],
+	gname: ["gname", (v) => v]
+};
 function parsePax(buffer) {
 	const decoder$1 = new TextDecoder("utf-8");
 	const overrides = {};
@@ -267,31 +278,11 @@ function parsePax(buffer) {
 		const [key, value] = decoder$1.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
 		if (key && value !== void 0) {
 			pax[key] = value;
-			switch (key) {
-				case "path":
-					overrides.name = value;
-					break;
-				case "linkpath":
-					overrides.linkname = value;
-					break;
-				case "size":
-					overrides.size = parseInt(value, 10);
-					break;
-				case "mtime":
-					overrides.mtime = parseFloat(value);
-					break;
-				case "uid":
-					overrides.uid = parseInt(value, 10);
-					break;
-				case "gid":
-					overrides.gid = parseInt(value, 10);
-					break;
-				case "uname":
-					overrides.uname = value;
-					break;
-				case "gname":
-					overrides.gname = value;
-					break;
+			const mapping = PAX_MAPPING[key];
+			if (mapping) {
+				const [targetKey, parser] = mapping;
+				const parsedValue = parser(value);
+				if (typeof parsedValue === "string" || !Number.isNaN(parsedValue)) overrides[targetKey] = parsedValue;
 			}
 		}
 		offset = recordEnd;

package/dist/web/index.d.ts

@@ -1,4 +1,4 @@
-import { DecoderOptions, ParsedTarEntry, ParsedTarEntryWithData, TarEntry, TarEntryData, TarHeader, UnpackOptions } from "../types-D-xPQp4Z.js";
+import { DecoderOptions, TarEntryData, TarHeader, UnpackOptions } from "../types-Dc3p5B3s.js";
 
 //#region src/web/compression.d.ts
 
@@ -72,6 +72,32 @@ declare function createGzipEncoder(): ReadableWritablePair<Uint8Array, Uint8Arra
  */
 declare function createGzipDecoder(): ReadableWritablePair<Uint8Array, Uint8Array>;
 //#endregion
+//#region src/web/types.d.ts
+/**
+ * Represents a complete entry to be packed into a tar archive.
+ *
+ * Combines header metadata with optional body data. Used as input to {@link packTar}
+ * and the controller returned by {@link createTarPacker}.
+ */
+interface TarEntry {
+  header: TarHeader;
+  body?: TarEntryData | ReadableStream<Uint8Array>;
+}
+/**
+ * Represents an entry parsed from a tar archive stream.
+ */
+interface ParsedTarEntry {
+  header: TarHeader;
+  body: ReadableStream<Uint8Array>;
+}
+/**
+ * Represents an extracted entry with fully buffered content.
+ */
+interface ParsedTarEntryWithData {
+  header: TarHeader;
+  data: Uint8Array;
+}
+//#endregion
 //#region src/web/helpers.d.ts
 /**
  * Packs an array of tar entries into a single `Uint8Array` buffer.

package/dist/web/index.js

@@ -1,4 +1,4 @@
-import { createTarPacker as createTarPacker$1, createTarUnpacker, normalizeBody, streamToBuffer, transformHeader } from "../unpacker-DBTDVhe4.js";
+import { createTarPacker as createTarPacker$1, createTarUnpacker, normalizeBody, streamToBuffer, transformHeader } from "../unpacker-yB6Ahxxk.js";
 
 //#region src/web/compression.ts
 function createGzipEncoder() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "modern-tar",
-	"version": "0.4.2",
+	"version": "0.5.1",
 	"description": "Zero dependency streaming tar parser and writer for JavaScript.",
 	"author": "Ayuhito <hello@ayuhito.com>",
 	"license": "MIT",