zipstream

type CDFileHeader struct {
	Signature              uint32
	VersionCreated         uint16
	VersionNeeded          uint16
	GeneralPurposeBitFlag  uint16
	CompressionMethod      uint16
	LastModifiedTime       uint16
	LastModifiedDate       uint16
	Crc32                  uint32
	CompressedSize         uint32
	UncompressedSize       uint32
	FilenameLength         uint16
	ExtraFieldLength       uint16
	FileCommentLength      uint16
	DiskNumberStart        uint16
	InternalFileAttributes uint16
	ExternalFileAttributes uint32
	LocalHeaderOffset      uint32
}

type CentralDirectory struct {
	Entries []FileEntry // File entries in the archive
	Offset  uint64      // Offset where central directory starts
	Size    uint64      // Size of central directory
	// MaxNonZip64Value is the largest value written into a 32-bit field
	// before the entry switches to ZIP64. Zero means maxNonZip64Value.
	// Lowering it is a test seam: it exercises the ZIP64 path without
	// materializing a multi-gigabyte archive.
	MaxNonZip64Value uint64
}

type Config struct {
	Zip64         Zip64Mode
	MaxSegments   int
	EnableLogging bool
	// Now returns the current time for header/metadata timestamps.
	// Defaults to time.Now; tests inject a pinned clock for
	// deterministic ZIP output.
	Now func() time.Time
	// MaxNonZip64Value is the largest size or offset written into a 32-bit
	// zip field before the archive switches to ZIP64. Zero means
	// maxNonZip64Value (2 GiB - 1). See WithMaxNonZip64Value.
	MaxNonZip64Value uint64
}

type EndOfCDRecord struct {
	Signature               uint32
	DiskNumber              uint16
	StartDiskNumber         uint16
	NumberOfCDRecordEntries uint16
	TotalCDRecordEntries    uint16
	SizeOfCentralDirectory  uint32
	CentralDirectoryOffset  uint32
	CommentLength           uint16
}

type Error struct {
	Op   string // Operation that failed
	Type string // Writer type: "sequential", "streaming", "segment"
	Err  error  // Underlying error

	// Mutated reports whether the writer had already changed its own state
	// when the operation failed. False means the writer is byte-for-byte as it
	// was before the call and the caller may retry; true means the partial
	// change is not rolled back and a retry compounds it rather than
	// recovering from it.
	//
	// Only Finalize sets it. WriteSegment validates everything before it
	// mutates anything, so every error it returns is Mutated false.
	//
	// An implementation that wraps a zipstream writer must not pass the
	// delegate's error through unchanged if it performed mutations of its own:
	// the flag describes the whole operation, not one layer of it.
	Mutated bool
}

type FileEntry struct {
	Name           string    // Filename in the archive
	Offset         uint64    // Offset of local file header in archive
	Size           uint64    // Uncompressed size
	CompressedSize uint64    // Compressed size (same as Size for no compression)
	CRC32          uint32    // CRC32 checksum of uncompressed data
	ModTime        time.Time // Last modification time
	IsStreaming    bool      // Whether this uses data descriptor pattern
}

type LocalFileHeader struct {
	Signature             uint32
	Version               uint16
	GeneralPurposeBitFlag uint16
	CompressionMethod     uint16
	LastModifiedTime      uint16
	LastModifiedDate      uint16
	Crc32                 uint32
	CompressedSize        uint32
	UncompressedSize      uint32
	FilenameLength        uint16
	ExtraFieldLength      uint16
}

type Option func(*Config)

type Reader struct {
	// contains filtered or unexported fields
}

type SegmentEntry struct {
	Index   int       // Segment index (0-based)
	Size    uint64    // Size of stored segment bytes (no compression)
	CRC32   uint32    // CRC32 of stored segment bytes
	Written time.Time // When this segment was written
}

type SegmentMetadata struct {
	ExpectedCount int                   // Total number of expected segments (unused when Order set)
	Segments      map[int]*SegmentEntry // Map of segments by index
	TotalSize     uint64                // Cumulative size of all segments

	TotalCRC32 uint32 // Final CRC32 when all segments are processed
	// Order, when set, defines the exact logical order of segments for
	// completeness checks and CRC computation. Indices may be sparse.
	Order []int
	// contains filtered or unexported fields
}

type SegmentWriter interface {
	Writer
	WriteSegment(ctx context.Context, index int, size uint64, crc32 uint32) ([]byte, error)
	// Finalize writes the trailer (data descriptor, manifest, central
	// directory) for the segments recorded so far. Segment 0 must be among
	// them: it carries the payload local file header that every recorded
	// offset is measured from. Finalize returns ErrNoSegmentZero when index 0
	// was never written or was cleaned up, and ErrSegmentMissing when no
	// segments remain at all -- none were written, or every one was cleaned
	// up. Gaps between the remaining indices are accepted; order is inferred
	// by sorting whichever indices are present.
	Finalize(ctx context.Context, manifest []byte) ([]byte, error)
	// CleanupSegment drops a segment index, rolling back both its presence
	// marker and the payload size it contributed. A cleaned-up index becomes
	// indistinguishable from one that was never written: it falls out of the
	// order Finalize infers, exactly as a gap in the write set would, and the
	// caller must leave its bytes out of the assembled archive. Index 0 is the
	// exception -- Finalize rejects its absence with ErrNoSegmentZero.
	// Cleaning up an index that was never written is a no-op.
	CleanupSegment(index int) error
}

type TDFReader struct {
	// contains filtered or unexported fields
}

type TDFReaderOptions func(*TDFReader)

type Writer interface {
	io.Closer
}

type Zip32DataDescriptor struct {
	Signature        uint32
	Crc32            uint32
	CompressedSize   uint32
	UncompressedSize uint32
}

type Zip64DataDescriptor struct {
	Signature        uint32
	Crc32            uint32
	CompressedSize   uint64
	UncompressedSize uint64
}

type Zip64EndOfCDRecord struct {
	Signature                          uint32
	RecordSize                         uint64
	VersionMadeBy                      uint16
	VersionToExtract                   uint16
	DiskNumber                         uint32
	StartDiskNumber                    uint32
	NumberOfCDRecordEntries            uint64
	TotalCDRecordEntries               uint64
	CentralDirectorySize               uint64
	StartingDiskCentralDirectoryOffset uint64
}

type Zip64EndOfCDRecordLocator struct {
	Signature         uint32
	CDStartDiskNumber uint32
	CDOffset          uint64
	NumberOfDisks     uint32
}

type Zip64ExtendedInfoExtraField struct {
	Signature             uint16
	Size                  uint16
	OriginalSize          uint64
	CompressedSize        uint64
	LocalFileHeaderOffset uint64
}

type Zip64ExtendedLocalInfoExtraField struct {
	Signature      uint16
	Size           uint16
	OriginalSize   uint64
	CompressedSize uint64
}

type Zip64Mode int