node build fixed

seanime-2.9.10/internal/util/limited_read_seeker.go

@@ -0,0 +1,110 @@
+package util
+
+import (
+	"errors"
+	"io"
+)
+
+// Common errors that might occur during operations
+var (
+	ErrInvalidOffset = errors.New("invalid offset: negative or beyond limit")
+	ErrInvalidWhence = errors.New("invalid whence value")
+	ErrReadLimit     = errors.New("read would exceed limit")
+)
+
+// LimitedReadSeeker wraps an io.ReadSeeker and limits the number of bytes
+// that can be read from it.
+type LimitedReadSeeker struct {
+	rs      io.ReadSeeker // The underlying ReadSeeker
+	offset  int64         // Current read position relative to start
+	limit   int64         // Maximum number of bytes that can be read
+	basePos int64         // Original position in the underlying ReadSeeker
+}
+
+// NewLimitedReadSeeker creates a new LimitedReadSeeker from the provided
+// io.ReadSeeker, starting at the current position and with the given limit.
+// The limit parameter specifies the maximum number of bytes that can be
+// read from the underlying ReadSeeker.
+func NewLimitedReadSeeker(rs io.ReadSeeker, limit int64) (*LimitedReadSeeker, error) {
+	if limit < 0 {
+		return nil, errors.New("negative limit")
+	}
+
+	// Get the current position
+	pos, err := rs.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LimitedReadSeeker{
+		rs:      rs,
+		offset:  0,
+		limit:   limit,
+		basePos: pos,
+	}, nil
+}
+
+// Read implements the io.Reader interface.
+func (lrs *LimitedReadSeeker) Read(p []byte) (n int, err error) {
+	if lrs.offset >= lrs.limit {
+		return 0, io.EOF
+	}
+
+	// Calculate how many bytes we can read
+	maxToRead := lrs.limit - lrs.offset
+	if int64(len(p)) > maxToRead {
+		p = p[:maxToRead]
+	}
+
+	n, err = lrs.rs.Read(p)
+	lrs.offset += int64(n)
+	return
+}
+
+// Seek implements the io.Seeker interface.
+func (lrs *LimitedReadSeeker) Seek(offset int64, whence int) (int64, error) {
+	var absoluteOffset int64
+
+	// Calculate the absolute offset based on whence
+	switch whence {
+	case io.SeekStart:
+		absoluteOffset = offset
+	case io.SeekCurrent:
+		absoluteOffset = lrs.offset + offset
+	case io.SeekEnd:
+		absoluteOffset = lrs.limit + offset
+	default:
+		return 0, ErrInvalidWhence
+	}
+
+	// Check if the offset is valid
+	if absoluteOffset < 0 || absoluteOffset > lrs.limit {
+		return 0, ErrInvalidOffset
+	}
+
+	// Seek in the underlying ReadSeeker
+	_, err := lrs.rs.Seek(lrs.basePos+absoluteOffset, io.SeekStart)
+	if err != nil {
+		return 0, err
+	}
+
+	// Update our offset
+	lrs.offset = absoluteOffset
+	return absoluteOffset, nil
+}
+
+// Size returns the limit of this LimitedReadSeeker.
+func (lrs *LimitedReadSeeker) Size() int64 {
+	return lrs.limit
+}
+
+// Remaining returns the number of bytes that can still be read.
+func (lrs *LimitedReadSeeker) Remaining() int64 {
+	return lrs.limit - lrs.offset
+}
+
+// Reset resets the read position to the beginning of the limited section.
+func (lrs *LimitedReadSeeker) Reset() error {
+	_, err := lrs.Seek(0, io.SeekStart)
+	return err
+}