#zip

#Features

• Read and write ZIP archives
• Bounded reads and fail-before-growth bounded writes
• DEFLATE compression support
• GZIP compression/decompression
• CRC32 checksum calculation

#Types

#Archive

///|
pub struct Archive {
  entries : Array[Entry]
}

#Entry

///|
pub struct Entry {
  name : String // File path within archive
  data : Bytes // Uncompressed file content
  compression : Compression
  data_descriptor : Bool
}

#Compression

///|
pub enum Compression {
  Store // No compression
  Deflate // DEFLATE algorithm
}

#Usage

#Creating Archives

///|
test "create archive" {
  let archive = @zip.Archive::new()

  // Add uncompressed file
  archive.add("hello.txt", b"Hello, World!")

  // Add compressed file
  archive.add("data.txt", b"Large content here...", compression=Deflate)

  // List entries
  debug_inspect(
    archive.entries().map(entry => entry.name()),
    content="[\"hello.txt\", \"data.txt\"]",
  )

  // Get file content
  inspect(archive.get("hello.txt") == Some(b"Hello, World!"), content="true")
}

#Reading Archives

///|
test "read archive" {
  // Create an archive
  let archive = @zip.Archive::new()
  archive.add("file1.txt", b"Content 1")
  archive.add("file2.txt", b"Content 2")

  // Write to bytes
  let bytes = @zip.write(archive)

  // Read back
  let loaded = @zip.read(bytes)
  debug_inspect(
    loaded.entries().map(entry => entry.name()),
    content="[\"file1.txt\", \"file2.txt\"]",
  )
  inspect(loaded.get("file1.txt") == Some(b"Content 1"), content="true")
}

#GZIP Compression

///|
test "gzip" {
  let data : Bytes = b"Hello, World! This is some test data to compress."

  // Compress
  let compressed = @zip.gzip(data)

  // Decompress
  let decompressed = @zip.gunzip(compressed)
  inspect(
    decompressed,
    content="b\"Hello, World! This is some test data to compress.\"",
  )
}

#Iterating Entries

///|
test "iterate entries" {
  let archive = @zip.Archive::new()
  archive.add("a.txt", b"A")
  archive.add("b.txt", b"B")
  archive.add("c.txt", b"C")

  // Iterate over entries
  for entry in archive.entries() {
    println("File: \{entry.name()}, Size: \{entry.data().length()}")
  }
}

#API Reference

#Archive Methods

#Functions

#Error Handling

///|
pub suberror ZipError {
  OutOfBounds(offset~ : Int)
  InvalidSignature(expected~ : Int, actual~ : Int, offset~ : Int)
  MissingEndOfCentral
  UnsupportedFeature(msg~ : String)
  UnsupportedCompression(method_id~ : Int)
  InvalidUtf8(offset~ : Int)
  OutputLimitExceeded(limit~ : Int)
  ResourceLimitExceeded(kind~ : String, limit~ : Int, actual~ : Int)
}

///|
test "error handling" {
  // Invalid ZIP data
  try @zip.read(b"not a zip file") catch {
    _ => ()
  } noraise {
    _ => fail("expected read to raise")
  }
}