v0.0.495

README.md

@@ -8,7 +8,7 @@ This should not have any heavy dependencies (gin, mongo, etc) and add missing ba
 Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 
 
-### Packages:
+## Packages:
 
 | Name        | Maintainer | Description                                                                                                   |
 |-------------|------------|---------------------------------------------------------------------------------------------------------------|
@@ -21,7 +21,7 @@ Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 | reflectext  | Mike       | Utility for golang reflection                                                                                 |
 | fsext       | Mike       | Utility for filesytem access                                                                                  |
 |             |            |                                                                                                               |
-| mongoext    | Mike       | Utility/Helper functions for mongodb                                                                          |
+| mongoext    | Mike       | Utility/Helper functions for mongodb (kinda abandoned)                                                        |
 | cursortoken | Mike       | MongoDB cursortoken implementation                                                                            |
 | pagination  | Mike       | Pagination implementation                                                                                     |
 |             |            |                                                                                                               |
@@ -42,4 +42,69 @@ Potentially needs `export GOPRIVATE="gogs.mikescher.com"`
 | wmo         | Mike       | Mongo Wrapper, wraps mongodb with a better interface                                                          |
 |             |            |                                                                                                               |
 | scn         | Mike       | SimpleCloudNotifier                                                                                           |
-|             |            |                                                                                                               |
+|             |            |                                                                                                               |
+
+
+
+## Usage:
+
+### exerr
+
+ - see **mongoext/builder.go** for full info
+
+Short summary:
+ - An better error package with metadata, listener, api-output and error-traces
+ - Initialize with `exerr.Init()`
+ - *Never* return `err` direct, always use exerr.Wrap(err, "...") - add metadata where applicable
+ - at the end either Print(), Fatal() or Output() your error (print = stdout, fatal = panic, output = json API response)
+ - You can add listeners with exerr.RegisterListener(), and save the full errors to a db or smth
+
+### wmo
+
+ - A typed wrapper around the official mongo-go-driver
+ - Use `wmo.W[...](...)` to wrap the collections and type-ify them
+ - The new collections have all the usual methods, but types
+ - Also they have List() and Paginate() methods for paginated listings (witehr with a cursortoken or page/limit)
+ - Register additional hooks with `WithDecodeFunc`, `WithUnmarshalHook`, `WithMarshalHook`, `WithModifyingPipeline`, `WithModifyingPipelineFunc`
+ - List(), Paginate(), etc support filter interfaces
+   - Rule(s) of thumb: 
+     - filter the results in the filter interface
+     - sort the results in the sort function of the filter interface
+     - add joins ($lookup's) in the `WithModifyingPipelineFunc`/`WithModifyingPipeline`
+
+#### ginext
+
+ - A wrapper around gin-gonic/gin
+ - create the gin engine with `ginext.NewEngine`
+ - Add routes with `engine.Routes()...`
+   - `.Use(..)` adds a middleware
+   - `.Group(..)` adds a group
+   - `.Get().Handle(..)` adds a handler
+ - Handler return values (in contract to ginext) - values implement the `ginext.HTTPResponse` interface
+ - Every handler starts with something like:
+```go 
+func (handler Handler) CommunityMetricsValues(pctx ginext.PreContext) ginext.HTTPResponse {
+    type communityURI struct {
+        Version     string             `uri:"version"`
+        CommunityID models.CommunityID `uri:"cid"`
+    }
+    type body struct {
+        UserID  models.UserID  `json:"userID"`
+        EventID models.EventID `json:"eventID"`
+    }
+
+    var u uri
+    var b body
+    ctx, gctx, httpErr := pctx.URI(&u).Body(&b).Start() // can have more unmarshaller, like header, form, etc
+    if httpErr != nil {
+    	return *httpErr
+    }
+    defer ctx.Cancel()
+
+    // do stuff
+}
+```
+
+#### sq
+
+ - TODO (like mongoext for sqlite/sql databases)

cursortoken/token.go

@@ -3,8 +3,8 @@ package cursortoken
 import (
 	"encoding/base32"
 	"encoding/json"
-	"errors"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
 	"strings"
 	"time"
 )
@@ -127,7 +127,7 @@ func Decode(tok string) (CursorToken, error) {
 	}
 
 	if !strings.HasPrefix(tok, "tok_") {
-		return CursorToken{}, errors.New("could not decode token, missing prefix")
+		return CursorToken{}, exerr.New(exerr.TypeCursorTokenDecode, "could not decode token, missing prefix").Str("token", tok).Build()
 	}
 
 	body, err := base32.StdEncoding.DecodeString(tok[len("tok_"):])
@@ -138,7 +138,7 @@ func Decode(tok string) (CursorToken, error) {
 	var tokenDeserialize cursorTokenSerialize
 	err = json.Unmarshal(body, &tokenDeserialize)
 	if err != nil {
-		return CursorToken{}, err
+		return CursorToken{}, exerr.Wrap(err, "failed to deserialize token").Str("token", tok).Build()
 	}
 
 	token := CursorToken{Mode: CTMNormal}

exerr/builder.go

@@ -30,6 +30,10 @@ import (
 // If possible add metadata to the error (eg the id that was not found, ...), the methods are the same as in zerolog
 //     return nil, exerror.Wrap(err, "do something failed").Str("someid", id).Int("count", in.Count).Build()
 //
+// You can also add extra-data to an error with Extra(..)
+// in contrast to metadata is extradata always printed in the resulting error and is more intended for additional (programmatically readable) data in addition to the errortype
+// (metadata is more internal debug info/help)
+//
 // You can change the errortype with `.User()` and `.System()` (User-errors are 400 and System-errors 500)
 // You can also manually set the statuscode with `.WithStatuscode(http.NotFound)`
 // You can set the type with `WithType(..)`
@@ -76,12 +80,14 @@ func Wrap(err error, msg string) *Builder {
 		return &Builder{errorData: newExErr(CatSystem, TypeInternal, msg)} // prevent NPE if we call Wrap with err==nil
 	}
 
+	v := FromError(err)
+
 	if !pkgconfig.RecursiveErrors {
-		v := FromError(err)
 		v.Message = msg
 		return &Builder{wrappedErr: err, errorData: v}
+	} else {
+		return &Builder{wrappedErr: err, errorData: wrapExErr(v, msg, CatWrap, 1)}
 	}
-	return &Builder{wrappedErr: err, errorData: wrapExErr(FromError(err), msg, CatWrap, 1)}
 }
 
 // ----------------------------------------------------------------------------
@@ -368,29 +374,6 @@ func (b *Builder) CtxData(method Method, ctx context.Context) *Builder {
 	return b
 }
 
-func formatHeader(header map[string][]string) string {
-	ml := 1
-	for k, _ := range header {
-		if len(k) > ml {
-			ml = len(k)
-		}
-	}
-	r := ""
-	for k, v := range header {
-		if r != "" {
-			r += "\n"
-		}
-		for _, hval := range v {
-			value := hval
-			value = strings.ReplaceAll(value, "\n", "\\n")
-			value = strings.ReplaceAll(value, "\r", "\\r")
-			value = strings.ReplaceAll(value, "\t", "\\t")
-			r += langext.StrPadRight(k, " ", ml) + " := " + value
-		}
-	}
-	return r
-}
-
 func extractHeader(header map[string][]string) []string {
 	r := make([]string, 0, len(header))
 	for k, v := range header {
@@ -407,6 +390,16 @@ func extractHeader(header map[string][]string) []string {
 
 // ----------------------------------------------------------------------------
 
+// Extra adds additional data to the error
+// this is not like the other metadata (like Id(), Str(), etc)
+// this data is public and will be printed/outputted
+func (b *Builder) Extra(key string, val any) *Builder {
+	b.errorData.Extra[key] = val
+	return b
+}
+
+// ----------------------------------------------------------------------------
+
 // Build creates a new error, ready to pass up the stack
 // If the errors is not SevWarn or SevInfo it gets also logged (in short form, without stacktrace) onto stdout
 // Can be gloablly configured with ZeroLogErrTraces and ZeroLogAllTraces
@@ -468,6 +461,10 @@ func (b *Builder) Print(ctxs ...context.Context) {
 		b.errorData.Log(pkgconfig.ZeroLogger.Error())
 	} else if b.errorData.Severity == SevWarn {
 		b.errorData.ShortLog(pkgconfig.ZeroLogger.Warn())
+	} else if b.errorData.Severity == SevInfo {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Info())
+	} else {
+		b.errorData.ShortLog(pkgconfig.ZeroLogger.Debug())
 	}
 
 	b.errorData.CallListener(MethodPrint)

exerr/constructor.go

@@ -31,6 +31,7 @@ func FromError(err error) *ExErr {
 		Caller:         "",
 		OriginalError:  nil,
 		Meta:           getForeignMeta(err),
+		Extra:          make(map[string]any),
 	}
 }
 
@@ -48,6 +49,7 @@ func newExErr(cat ErrorCategory, errtype ErrorType, msg string) *ExErr {
 		Caller:         callername(2),
 		OriginalError:  nil,
 		Meta:           make(map[string]MetaValue),
+		Extra:          make(map[string]any),
 	}
 }
 
@@ -65,6 +67,7 @@ func wrapExErr(e *ExErr, msg string, cat ErrorCategory, stacktraceskip int) *ExE
 		Caller:         callername(1 + stacktraceskip),
 		OriginalError:  e,
 		Meta:           make(map[string]MetaValue),
+		Extra:          langext.CopyMap(langext.ForceMap(e.Extra)),
 	}
 }
 

exerr/dataType.go

@@ -23,6 +23,7 @@ var (
 	TypeInternal       = NewType("INTERNAL_ERROR", langext.Ptr(500))
 	TypePanic          = NewType("PANIC", langext.Ptr(500))
 	TypeNotImplemented = NewType("NOT_IMPLEMENTED", langext.Ptr(500))
+	TypeAssert         = NewType("ASSERT", langext.Ptr(500))
 
 	TypeMongoQuery        = NewType("MONGO_QUERY", langext.Ptr(500))
 	TypeCursorTokenDecode = NewType("CURSOR_TOKEN_DECODE", langext.Ptr(500))

exerr/exerr.go

@@ -1,6 +1,7 @@
 package exerr
 
 import (
+	"fmt"
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
@@ -26,7 +27,8 @@ type ExErr struct {
 
 	OriginalError *ExErr `json:"originalError"`
 
-	Meta MetaMap `json:"meta"`
+	Extra map[string]any `json:"extra"`
+	Meta  MetaMap        `json:"meta"`
 }
 
 func (ee *ExErr) Error() string {
@@ -81,6 +83,23 @@ func (ee *ExErr) Log(evt *zerolog.Event) {
 }
 
 func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
+
+	// [LogPrintShort]
+	//
+	// - Only print message and type
+	// - Used e.g. for logging to the console when Build is called
+	// - also used in Print() if level == Warn/Info
+	//
+	// [LogPrintOverview]
+	//
+	// - print message, extra and errortrace
+	//
+	// [LogPrintFull]
+	//
+	// - print full error, with meta and extra, and trace, etc
+	// - Used in Output() and Print()
+	//
+
 	if lvl == LogPrintShort {
 
 		msg := ee.Message
@@ -101,6 +120,10 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 
 		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
 
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
 		indent := ""
 		for curr := ee; curr != nil; curr = curr.OriginalError {
 			indent += "  "
@@ -122,6 +145,10 @@ func (ee *ExErr) FormatLog(lvl LogPrintLevel) string {
 
 		str := "[" + ee.RecursiveType().Key + "] <" + ee.UniqueID + "> " + strings.ReplaceAll(ee.RecursiveMessage(), "\n", " ") + "\n"
 
+		for exk, exv := range ee.Extra {
+			str += fmt.Sprintf(" # [[[ %s ==> %v ]]]\n", exk, exv)
+		}
+
 		indent := ""
 		for curr := ee; curr != nil; curr = curr.OriginalError {
 			indent += "  "
@@ -328,6 +355,14 @@ func (ee *ExErr) GetMetaTime(key string) (time.Time, bool) {
 	return time.Time{}, false
 }
 
+func (ee *ExErr) GetExtra(key string) (any, bool) {
+	if v, ok := ee.Extra[key]; ok {
+		return v, true
+	}
+
+	return nil, false
+}
+
 // contains test if the supplied error is contained in this error (anywhere in the chain)
 func (ee *ExErr) contains(original *ExErr) (*ExErr, bool) {
 	if original == nil {

exerr/gin.go

@@ -90,6 +90,20 @@ func (ee *ExErr) ToAPIJson(applyExtendListener bool, includeWrappedErrors bool,
 		apiOutput["__data"] = ee.toJson(0, applyExtendListener, includeMetaFields)
 	}
 
+	for exkey, exval := range ee.Extra {
+
+		// ensure we do not override existing values
+		for {
+			if _, ok := apiOutput[exkey]; ok {
+				exkey = "_" + exkey
+			} else {
+				break
+			}
+		}
+
+		apiOutput[exkey] = exval
+	}
+
 	if applyExtendListener {
 		pkgconfig.ExtendGinOutput(ee, apiOutput)
 	}

ginext/cors.go

@@ -3,13 +3,17 @@ package ginext
 import (
 	"github.com/gin-gonic/gin"
 	"net/http"
+	"strings"
 )
 
-func CorsMiddleware() gin.HandlerFunc {
+func CorsMiddleware(allowheader []string, exposeheader []string) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
 		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
-		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", strings.Join(allowheader, ", "))
+		if len(exposeheader) > 0 {
+			c.Writer.Header().Set("Access-Control-Expose-Headers", strings.Join(exposeheader, ", "))
+		}
 		c.Writer.Header().Set("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE, COUNT")
 
 		if c.Request.Method == "OPTIONS" {

ginext/engine.go

@@ -21,12 +21,16 @@ type GinWrapper struct {
 
 	opt                   Options
 	allowCors             bool
+	corsAllowHeader       []string
+	corsExposeHeader      []string
 	ginDebug              bool
 	bufferBody            bool
 	requestTimeout        time.Duration
 	listenerBeforeRequest []func(g *gin.Context)
 	listenerAfterRequest  []func(g *gin.Context, resp HTTPResponse)
 
+	buildRequestBindError func(g *gin.Context, fieldtype string, err error) HTTPResponse
+
 	routeSpecs []ginRouteSpec
 }
 
@@ -38,15 +42,18 @@ type ginRouteSpec struct {
 }
 
 type Options struct {
-	AllowCors                *bool                                     // Add cors handler to allow all CORS requests on the default http methods
+	AllowCors                *bool                                                          // Add cors handler to allow all CORS requests on the default http methods
-	GinDebug                 *bool                                     // Set gin.debug to true (adds more logs)
+	CorsAllowHeader          *[]string                                                      // override the default values of Access-Control-Allow-Headers (AllowCors must be true)
-	SuppressGinLogs          *bool                                     // Suppress our custom gin logs (even if GinDebug == true)
+	CorsExposeHeader         *[]string                                                      // return Access-Control-Expose-Headers (AllowCors must be true)
-	BufferBody               *bool                                     // Buffers the input body stream, this way the ginext error handler can later include the whole request body
+	GinDebug                 *bool                                                          // Set gin.debug to true (adds more logs)
-	Timeout                  *time.Duration                            // The default handler timeout
+	SuppressGinLogs          *bool                                                          // Suppress our custom gin logs (even if GinDebug == true)
-	ListenerBeforeRequest    []func(g *gin.Context)                    // Register listener that are called before the handler method
+	BufferBody               *bool                                                          // Buffers the input body stream, this way the ginext error handler can later include the whole request body
-	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse) // Register listener that are called after the handler method
+	Timeout                  *time.Duration                                                 // The default handler timeout
-	DebugTrimHandlerPrefixes []string                                  // Trim these prefixes from the handler names in the debug print
+	ListenerBeforeRequest    []func(g *gin.Context)                                         // Register listener that are called before the handler method
-	DebugReplaceHandlerNames map[string]string                         // Replace handler names in debug output
+	ListenerAfterRequest     []func(g *gin.Context, resp HTTPResponse)                      // Register listener that are called after the handler method
+	DebugTrimHandlerPrefixes []string                                                       // Trim these prefixes from the handler names in the debug print
+	DebugReplaceHandlerNames map[string]string                                              // Replace handler names in debug output
+	BuildRequestBindError    func(g *gin.Context, fieldtype string, err error) HTTPResponse // Override function which generates the HTTPResponse errors that are returned by the preContext..Start() methids
 }
 
 // NewEngine creates a new (wrapped) ginEngine
@@ -72,18 +79,21 @@ func NewEngine(opt Options) *GinWrapper {
 		opt:                   opt,
 		suppressGinLogs:       langext.Coalesce(opt.SuppressGinLogs, false),
 		allowCors:             langext.Coalesce(opt.AllowCors, false),
+		corsAllowHeader:       langext.Coalesce(opt.CorsAllowHeader, []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization", "accept", "origin", "Cache-Control", "X-Requested-With"}),
+		corsExposeHeader:      langext.Coalesce(opt.CorsExposeHeader, []string{}),
 		ginDebug:              ginDebug,
 		bufferBody:            langext.Coalesce(opt.BufferBody, false),
 		requestTimeout:        langext.Coalesce(opt.Timeout, 24*time.Hour),
 		listenerBeforeRequest: opt.ListenerBeforeRequest,
 		listenerAfterRequest:  opt.ListenerAfterRequest,
+		buildRequestBindError: langext.Conditional(opt.BuildRequestBindError == nil, defaultBuildRequestBindError, opt.BuildRequestBindError),
 	}
 
 	engine.RedirectFixedPath = false
 	engine.RedirectTrailingSlash = false
 
 	if wrapper.allowCors {
-		engine.Use(CorsMiddleware())
+		engine.Use(CorsMiddleware(wrapper.corsAllowHeader, wrapper.corsExposeHeader))
 	}
 
 	if ginDebug && !wrapper.suppressGinLogs {
@@ -218,3 +228,11 @@ func (w *GinWrapper) ServeHTTP(req *http.Request) *httptest.ResponseRecorder {
 func (w *GinWrapper) ForwardRequest(writer http.ResponseWriter, req *http.Request) {
 	w.engine.ServeHTTP(writer, req)
 }
+
+func (w *GinWrapper) ListRoutes() []gin.RouteInfo {
+	return w.engine.Routes()
+}
+
+func defaultBuildRequestBindError(g *gin.Context, fieldtype string, err error) HTTPResponse {
+	return Error(err)
+}

ginext/jsonFilter.go

@@ -0,0 +1,9 @@
+package ginext
+
+import "github.com/gin-gonic/gin"
+
+var jsonFilterKey = "goext.jsonfilter"
+
+func SetJSONFilter(g *gin.Context, filter string) {
+	g.Set(jsonFilterKey, filter)
+}

ginext/preContext.go

@@ -15,16 +15,17 @@ import (
 )
 
 type PreContext struct {
-	ginCtx         *gin.Context
+	ginCtx                 *gin.Context
-	wrapper        *GinWrapper
+	wrapper                *GinWrapper
-	uri            any
+	uri                    any
-	query          any
+	query                  any
-	body           any
+	body                   any
-	rawbody        *[]byte
+	rawbody                *[]byte
-	form           any
+	form                   any
-	header         any
+	header                 any
-	timeout        *time.Duration
+	timeout                *time.Duration
-	persistantData *preContextData // must be a ptr, so that we can get the values back in out Wrap func
+	persistantData         *preContextData // must be a ptr, so that we can get the values back in out Wrap func
+	ignoreWrongContentType bool
 }
 
 type preContextData struct {
@@ -71,6 +72,11 @@ func (pctx *PreContext) WithSession(sessionObj SessionObject) *PreContext {
 	return pctx
 }
 
+func (pctx *PreContext) IgnoreWrongContentType() *PreContext {
+	pctx.ignoreWrongContentType = true
+	return pctx
+}
+
 func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 	if pctx.uri != nil {
 		if err := pctx.ginCtx.ShouldBindUri(pctx.uri); err != nil {
@@ -78,7 +84,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailURI).
 				Str("struct_type", fmt.Sprintf("%T", pctx.uri)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "URI", err))
 		}
 	}
 
@@ -88,7 +94,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailQuery).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "QUERY", err))
 		}
 	}
 
@@ -99,13 +105,15 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailJSON).
 					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
 			}
 		} else {
-			err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
+			if !pctx.ignoreWrongContentType {
-				Str("struct_type", fmt.Sprintf("%T", pctx.body)).
+				err := exerr.New(exerr.TypeBindFailJSON, "missing JSON body").
-				Build()
+					Str("struct_type", fmt.Sprintf("%T", pctx.body)).
-			return nil, nil, langext.Ptr(Error(err))
+					Build()
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "JSON", err))
+			}
 		}
 	}
 
@@ -113,14 +121,14 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		if brc, ok := pctx.ginCtx.Request.Body.(dataext.BufferedReadCloser); ok {
 			v, err := brc.BufferedAll()
 			if err != nil {
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = v
 		} else {
 			buf := &bytes.Buffer{}
 			_, err := io.Copy(buf, pctx.ginCtx.Request.Body)
 			if err != nil {
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "BODY", err))
 			}
 			*pctx.rawbody = buf.Bytes()
 		}
@@ -133,7 +141,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else if pctx.ginCtx.ContentType() == "application/x-www-form-urlencoded" {
 			if err := pctx.ginCtx.ShouldBindWith(pctx.form, binding.Form); err != nil {
@@ -141,13 +149,15 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 					WithType(exerr.TypeBindFailFormData).
 					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
 					Build()
-				return nil, nil, langext.Ptr(Error(err))
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
 			}
 		} else {
-			err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
+			if !pctx.ignoreWrongContentType {
-				Str("struct_type", fmt.Sprintf("%T", pctx.form)).
+				err := exerr.New(exerr.TypeBindFailFormData, "missing form body").
-				Build()
+					Str("struct_type", fmt.Sprintf("%T", pctx.form)).
-			return nil, nil, langext.Ptr(Error(err))
+					Build()
+				return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "FORM", err))
+			}
 		}
 	}
 
@@ -157,7 +167,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 				WithType(exerr.TypeBindFailHeader).
 				Str("struct_type", fmt.Sprintf("%T", pctx.query)).
 				Build()
-			return nil, nil, langext.Ptr(Error(err))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "HEADER", err))
 		}
 	}
 
@@ -169,7 +179,7 @@ func (pctx PreContext) Start() (*AppContext, *gin.Context, *HTTPResponse) {
 		err := pctx.persistantData.sessionObj.Init(pctx.ginCtx, actx)
 		if err != nil {
 			actx.Cancel()
-			return nil, nil, langext.Ptr(Error(exerr.Wrap(err, "Failed to init session").Build()))
+			return nil, nil, langext.Ptr(pctx.wrapper.buildRequestBindError(pctx.ginCtx, "INIT", err))
 		}
 	}
 

ginext/response.go

@@ -36,6 +36,12 @@ type InspectableHTTPResponse interface {
 	Headers() []string
 }
 
+type HTTPErrorResponse interface {
+	HTTPResponse
+
+	Error() error
+}
+
 func NotImplemented() HTTPResponse {
 	return Error(exerr.New(exerr.TypeNotImplemented, "").Build())
 }

ginext/responseJson.go

@@ -15,7 +15,7 @@ type jsonHTTPResponse struct {
 
 func (j jsonHTTPResponse) jsonRenderer(g *gin.Context) json.GoJsonRender {
 	var f *string
-	if jsonfilter := g.GetString("goext.jsonfilter"); jsonfilter != "" {
+	if jsonfilter := g.GetString(jsonFilterKey); jsonfilter != "" {
 		f = &jsonfilter
 	}
 	return json.GoJsonRender{Data: j.data, NilSafeSlices: true, NilSafeMaps: true, Filter: f}

ginext/responseJsonAPI.go

@@ -13,6 +13,10 @@ type jsonAPIErrResponse struct {
 	cookies []cookieval
 }
 
+func (j jsonAPIErrResponse) Error() error {
+	return j.err
+}
+
 func (j jsonAPIErrResponse) Write(g *gin.Context) {
 	for _, v := range j.headers {
 		g.Header(v.Key, v.Val)

ginext/routes.go

@@ -57,7 +57,7 @@ func (w *GinRoutesWrapper) Use(middleware ...gin.HandlerFunc) *GinRoutesWrapper
 }
 
 func (w *GinRoutesWrapper) WithJSONFilter(filter string) *GinRoutesWrapper {
-	return w.Use(func(g *gin.Context) { g.Set("goext.jsonfilter", filter) })
+	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
 }
 
 func (w *GinRoutesWrapper) GET(relativePath string) *GinRouteBuilder {
@@ -112,7 +112,7 @@ func (w *GinRouteBuilder) Use(middleware ...gin.HandlerFunc) *GinRouteBuilder {
 }
 
 func (w *GinRouteBuilder) WithJSONFilter(filter string) *GinRouteBuilder {
-	return w.Use(func(g *gin.Context) { g.Set("goext.jsonfilter", filter) })
+	return w.Use(func(g *gin.Context) { g.Set(jsonFilterKey, filter) })
 }
 
 func (w *GinRouteBuilder) Handle(handler WHandlerFunc) {

go.mod

@@ -8,27 +8,27 @@ require (
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/rs/xid v1.5.0
 	github.com/rs/zerolog v1.33.0
-	go.mongodb.org/mongo-driver v1.15.1
+	go.mongodb.org/mongo-driver v1.16.0
-	golang.org/x/crypto v0.24.0
+	golang.org/x/crypto v0.26.0
-	golang.org/x/sys v0.21.0
+	golang.org/x/sys v0.23.0
-	golang.org/x/term v0.21.0
+	golang.org/x/term v0.23.0
 )
 
 require (
 	github.com/disintegration/imaging v1.6.2
 	github.com/jung-kurt/gofpdf v1.16.2
-	golang.org/x/sync v0.7.0
+	golang.org/x/sync v0.8.0
 )
 
 require (
-	github.com/bytedance/sonic v1.11.8 // indirect
+	github.com/bytedance/sonic v1.12.1 // indirect
-	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/bytedance/sonic/loader v0.2.0 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
 	github.com/chenzhuoyu/iasm v0.9.1 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.4 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.5 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
@@ -52,11 +52,11 @@ require (
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
-	github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
-	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/arch v0.9.0 // indirect
-	golang.org/x/image v0.17.0 // indirect
+	golang.org/x/image v0.19.0 // indirect
-	golang.org/x/net v0.26.0 // indirect
+	golang.org/x/net v0.28.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
+	golang.org/x/text v0.17.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.37.6 // indirect

go.sum

@@ -22,9 +22,17 @@ github.com/bytedance/sonic v1.11.7 h1:k/l9p1hZpNIMJSk37wL9ltkcpqLfIho1vYthi4xT2t
 github.com/bytedance/sonic v1.11.7/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
 github.com/bytedance/sonic v1.11.8 h1:Zw/j1KfiS+OYTi9lyB3bb0CFxPJVkM17k1wyDG32LRA=
 github.com/bytedance/sonic v1.11.8/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic v1.11.9 h1:LFHENlIY/SLzDWverzdOvgMztTxcfcF+cqNsz9pK5zg=
+github.com/bytedance/sonic v1.11.9/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic v1.12.0 h1:YGPgxF9xzaCNvd/ZKdQ28yRovhfMFZQjuk6fKBzZ3ls=
+github.com/bytedance/sonic v1.12.0/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
+github.com/bytedance/sonic v1.12.1 h1:jWl5Qz1fy7X1ioY74WqO0KjAMtAGQs4sYnjiEBiyX24=
+github.com/bytedance/sonic v1.12.1/go.mod h1:B8Gt/XvtZ3Fqj+iSKMypzymZxw/FVwgIGKzMzT9r/rk=
 github.com/bytedance/sonic/loader v0.1.0/go.mod h1:UmRT+IRTGKz/DAkzcEGzyVqQFJ7H9BqwBO3pm9H/+HY=
 github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/bytedance/sonic/loader v0.2.0 h1:zNprn+lsIP06C/IqCHs3gPQIvnvpKbbxyXQP1iU4kWM=
+github.com/bytedance/sonic/loader v0.2.0/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
@@ -55,6 +63,8 @@ github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uq
 github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
 github.com/gabriel-vasile/mimetype v1.4.4 h1:QjV6pZ7/XZ7ryI2KuyeEDE8wnh7fHP9YnQy+R0LnH8I=
 github.com/gabriel-vasile/mimetype v1.4.4/go.mod h1:JwLei5XPtWdGiMFB5Pjle1oEeoSeEuJfJE+TtfvdB/s=
+github.com/gabriel-vasile/mimetype v1.4.5 h1:J7wGKdGu33ocBOhGy0z653k/lFKLFDPJMG8Gql0kxn4=
+github.com/gabriel-vasile/mimetype v1.4.5/go.mod h1:ibHel+/kbxn9x2407k1izTA1S81ku1z/DlgOW2QE0M4=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
@@ -211,6 +221,8 @@ github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a h1:fZHgsYlfvtyqTosly
 github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a/go.mod h1:ul22v+Nro/R083muKhosV54bj5niojjWZvU8xrevuH4=
 github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76 h1:tBiBTKHnIjovYoLX/TPkcf+OjqqKGQrPtGT3Foz+Pgo=
 github.com/youmark/pkcs8 v0.0.0-20240424034433-3c2c7870ae76/go.mod h1:SQliXeA7Dhkt//vS29v3zpbEwoa+zb2Cn5xj5uO4K5U=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM=
+github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.mongodb.org/mongo-driver v1.13.1 h1:YIc7HTYsKndGK4RFzJ3covLz1byri52x0IoMB0Pt/vk=
 go.mongodb.org/mongo-driver v1.13.1/go.mod h1:wcDf1JBCXy2mOW0bWHwO/IOYqdca1MPCwDtFu/Z9+eo=
@@ -220,11 +232,15 @@ go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUS
 go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
 go.mongodb.org/mongo-driver v1.15.1 h1:l+RvoUOoMXFmADTLfYDm7On9dRm7p4T80/lEQM+r7HU=
 go.mongodb.org/mongo-driver v1.15.1/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
+go.mongodb.org/mongo-driver v1.16.0 h1:tpRsfBJMROVHKpdGyc1BBEzzjDUWjItxbVSZ8Ls4BQ4=
+go.mongodb.org/mongo-driver v1.16.0/go.mod h1:oB6AhJQvFQL4LEHyXi6aJzQJtBiTQHiAd83l0GdFaiw=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/arch v0.7.0 h1:pskyeJh/3AmoQ8CPE95vxHLqp1G1GfGNXTmcl9NEKTc=
 golang.org/x/arch v0.7.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
 golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/arch v0.9.0 h1:ub9TgUInamJ8mrZIGlBG6/4TqWeMszd4N8lNorbrr6k=
+golang.org/x/arch v0.9.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
@@ -245,6 +261,10 @@ golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
 golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
 golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
+golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
+golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
 golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8 h1:hVwzHzIUGRjiF7EcUjqNxk3NCfkPxbDKRdnNE1Rpg0U=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
@@ -252,6 +272,10 @@ golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
 golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
 golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
 golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
+golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
+golang.org/x/image v0.19.0 h1:D9FX4QWkLfkeqaC62SonffIIuYdOk/UE2XKUBgRIBIQ=
+golang.org/x/image v0.19.0/go.mod h1:y0zrRqlQRWQ5PXaYCOMLTW2fpsxZ8Qh9I/ohnInJEys=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -272,12 +296,18 @@ golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
 golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
 golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE=
+golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
 golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -301,6 +331,10 @@ golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
 golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM=
+golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
@@ -315,6 +349,10 @@ golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
 golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
+golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=
+golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU=
+golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -327,6 +365,8 @@ golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
 golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

goextVersion.go

@@ -1,5 +1,5 @@
 package goext
 
-const GoextVersion = "0.0.475"
+const GoextVersion = "0.0.495"
 
-const GoextVersionTimestamp = "2024-06-16T17:14:21+0200"
+const GoextVersionTimestamp = "2024-08-07T14:00:02+0200"

gojson/encode.go

@@ -788,7 +788,7 @@ FieldLoop:
 
 		if f.omitEmpty && isEmptyValue(fv) {
 			continue
-		} else if opts.filter != nil && len(f.jsonfilter) > 0 && !f.jsonfilter.Contains(*opts.filter) {
+		} else if opts.filter != nil && !matchesJSONFilter(f.jsonfilter, *opts.filter) {
 			continue
 		}
 		e.WriteByte(next)
@@ -808,6 +808,26 @@ FieldLoop:
 	}
 }
 
+func matchesJSONFilter(filter jsonfilter, value string) bool {
+	if len(filter) == 0 {
+		return true
+	}
+
+	if len(filter) == 1 && filter[0] == "-" {
+		return false
+	}
+
+	if filter.Contains(value) {
+		return true
+	}
+
+	if filter.Contains("*") {
+		return true
+	}
+
+	return false
+}
+
 func newStructEncoder(t reflect.Type, tagkey string) encoderFunc {
 	se := structEncoder{fields: cachedTypeFields(t, tagkey)}
 	return se.encode

imageext/image.go

@@ -169,7 +169,7 @@ func EncodeImage(img image.Image, compression ImageCompresson) (bytes.Buffer, st
 	}
 }
 
-func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fillColor color.Color) (image.Image, error) {
+func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fillColor color.Color) (image.Image, PercentageRectangle, error) {
 
 	iw := img.Bounds().Size().X
 	ih := img.Bounds().Size().Y
@@ -214,12 +214,12 @@ func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fil
 		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
 		draw.Draw(newImg, newImg.Bounds(), img, image.Pt(0, 0), draw.Over)
 
-		return newImg, nil
+		return newImg, PercentageRectangle{0, 0, 1, 1}, nil
 	}
 
 	if fit == ImageFitContainCenter || fit == ImageFitContainTopLeft || fit == ImageFitContainTopRight || fit == ImageFitContainBottomLeft || fit == ImageFitContainBottomRight {
 
-		// image-fit:cover fills the target-bounding-box with the image, there is potentially empty-space, it potentially cuts parts of the image away
+		// image-fit:contain fills the target-bounding-box with the image, there is potentially empty-space, it potentially cuts parts of the image away
 
 		// we use the bigger (!) value of facW and facH,
 		// because the image is made to fit the bounding-box, the bigger factor (= the dimension the image is stretched less) is relevant
@@ -266,7 +266,7 @@ func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fil
 		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
 		draw.Draw(newImg, destBounds, img, image.Pt(0, 0), draw.Over)
 
-		return newImg, nil
+		return newImg, calcRelativeRect(destBounds, newImg.Bounds()), nil
 	}
 
 	if fit == ImageFitStretch {
@@ -293,10 +293,10 @@ func ObjectFitImage(img image.Image, bbw float64, bbh float64, fit ImageFit, fil
 		draw.Draw(newImg, newImg.Bounds(), &image.Uniform{C: fillColor}, image.Pt(0, 0), draw.Src)
 		draw.Draw(newImg, newImg.Bounds(), img, image.Pt(0, 0), draw.Over)
 
-		return newImg, nil
+		return newImg, PercentageRectangle{0, 0, 1, 1}, nil
 	}
 
-	return nil, exerr.New(exerr.TypeInternal, fmt.Sprintf("unknown image-fit: '%s'", fit)).Build()
+	return nil, PercentageRectangle{}, exerr.New(exerr.TypeInternal, fmt.Sprintf("unknown image-fit: '%s'", fit)).Build()
 }
 
 func VerifyAndDecodeImage(data io.Reader, mime string) (image.Image, error) {

imageext/types.go

@@ -0,0 +1,35 @@
+package imageext
+
+import "image"
+
+type Rectangle struct {
+	X float64
+	Y float64
+	W float64
+	H float64
+}
+
+type PercentageRectangle struct {
+	X float64 // [0..1]
+	Y float64 // [0..1]
+	W float64 // [0..1]
+	H float64 // [0..1]
+}
+
+func (r PercentageRectangle) Of(ref Rectangle) Rectangle {
+	return Rectangle{
+		X: ref.X + r.X*ref.W,
+		Y: ref.Y + r.Y*ref.H,
+		W: r.W * ref.W,
+		H: r.H * ref.H,
+	}
+}
+
+func calcRelativeRect(inner image.Rectangle, outer image.Rectangle) PercentageRectangle {
+	return PercentageRectangle{
+		X: float64(inner.Min.X-outer.Min.X) / float64(outer.Dx()),
+		Y: float64(inner.Min.Y-outer.Min.Y) / float64(outer.Dy()),
+		W: float64(inner.Dx()) / float64(outer.Dx()),
+		H: float64(inner.Dy()) / float64(outer.Dy()),
+	}
+}

langext/maps.go

@@ -66,7 +66,7 @@ func CopyMap[K comparable, V any](a map[K]V) map[K]V {
 
 func ForceMap[K comparable, V any](v map[K]V) map[K]V {
 	if v == nil {
-		return make(map[K]V, 0)
+		return make(map[K]V)
 	} else {
 		return v
 	}

langext/string.go

@@ -88,12 +88,15 @@ func StrRunePadRight(str string, pad string, padlen int) string {
 
 func Indent(str string, pad string) string {
 	eonl := strings.HasSuffix(str, "\n")
+	if eonl {
+		str = str[0 : len(str)-1]
+	}
 	r := ""
 	for _, v := range strings.Split(str, "\n") {
 		r += pad + v + "\n"
 	}
 
-	if eonl {
+	if !eonl {
 		r = r[0 : len(r)-1]
 	}
 
@@ -115,3 +118,21 @@ func StrRepeat(val string, count int) string {
 	}
 	return r
 }
+
+func StrWrap(val string, linelen int, seperator string) string {
+	res := ""
+
+	for iPos := 0; ; {
+		next := min(iPos+linelen, len(val))
+		res += val[iPos:next]
+
+		iPos = next
+		if iPos >= len(val) {
+			break
+		}
+
+		res += seperator
+	}
+
+	return res
+}

langext/string_test.go

@@ -0,0 +1,152 @@
+package langext
+
+import "testing"
+
+func TestStrLimitBehaviour(t *testing.T) {
+	val := "Hello, World!"
+	maxlen := 5
+	suffix := "..."
+	expected := "He..."
+	result := StrLimit(val, maxlen, suffix)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrSplitBehaviour1(t *testing.T) {
+	val := "Hello,World,,"
+	sep := ","
+	expected := []string{"Hello", "World"}
+	result := StrSplit(val, sep, false)
+	if len(result) != len(expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrSplitBehaviour2(t *testing.T) {
+	val := "Hello,World,,"
+	sep := ","
+	expected := []string{"Hello", "World", "", ""}
+	result := StrSplit(val, sep, true)
+	if len(result) != len(expected) {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrPadRightBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "Hello*****"
+	result := StrPadRight(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrPadLeftBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "*****Hello"
+	result := StrPadLeft(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRunePadLeftBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "*****Hello"
+	result := StrRunePadLeft(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRunePadRightBehaviour(t *testing.T) {
+	str := "Hello"
+	pad := "*"
+	padlen := 10
+	expected := "Hello*****"
+	result := StrRunePadRight(str, pad, padlen)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestIndentBehaviour1(t *testing.T) {
+	str := "Hello\nWorld"
+	pad := ".."
+	expected := "..Hello\n..World"
+	result := Indent(str, pad)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestIndentBehaviour2(t *testing.T) {
+	str := "Hello\nWorld\n"
+	pad := ".."
+	expected := "..Hello\n..World\n"
+	result := Indent(str, pad)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrRepeatBehaviour(t *testing.T) {
+	val := "Hello"
+	count := 3
+	expected := "HelloHelloHello"
+	result := StrRepeat(val, count)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour1(t *testing.T) {
+	val := "123456789"
+	linelen := 5
+	seperator := "\n"
+	expected := "12345\n6789"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour2(t *testing.T) {
+	val := "1234567890"
+	linelen := 5
+	seperator := "\n"
+	expected := "12345\n67890"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour3(t *testing.T) {
+	val := "****************"
+	linelen := 4
+	seperator := "\n"
+	expected := "****\n****\n****\n****"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}
+
+func TestStrWrapBehaviour4(t *testing.T) {
+	val := "*****************"
+	linelen := 4
+	seperator := "\n"
+	expected := "****\n****\n****\n****\n*"
+	result := StrWrap(val, linelen, seperator)
+	if result != expected {
+		t.Errorf("Expected %v but got %v", expected, result)
+	}
+}

mathext/statistics.go

@@ -1,6 +1,9 @@
 package mathext
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
 
 func Sum[T langext.NumberConstraint](v []T) T {
 	total := T(0)
@@ -41,3 +44,53 @@ func ArrMax[T langext.OrderedConstraint](v []T) T {
 	}
 	return r
 }
+
+func MustPercentile[T langext.NumberConstraint](rawdata []T, percentile float64) T {
+	v, err := Percentile(rawdata, percentile)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+func Percentile[T langext.NumberConstraint](rawdata []T, percentile float64) (T, error) {
+	v, err := FloatPercentile(rawdata, percentile)
+	if err != nil {
+		return T(0), err
+	}
+	return T(v), nil
+
+}
+
+func FloatPercentile[T langext.NumberConstraint](rawdata []T, percentile float64) (float64, error) {
+	if len(rawdata) == 0 {
+		return 0, exerr.New(exerr.TypeAssert, "no data to calculate percentile").Any("percentile", percentile).Build()
+	}
+
+	if percentile < 0 || percentile > 100 {
+		return 0, exerr.New(exerr.TypeAssert, "percentile out of range").Any("percentile", percentile).Build()
+	}
+
+	data := langext.ArrCopy(rawdata)
+	langext.Sort(data)
+
+	idxFloat := float64(len(data)-1) * (percentile / float64(100))
+
+	idxInt := int(idxFloat)
+
+	// exact match on index
+	if idxFloat == float64(idxInt) {
+		return float64(data[idxInt]), nil
+	}
+
+	// linear interpolation
+	v1 := data[idxInt]
+	v2 := data[idxInt+1]
+
+	weight := idxFloat - float64(idxInt)
+
+	valFloat := (float64(v1) * (1 - weight)) + (float64(v2) * weight)
+
+	return valFloat, nil
+
+}

mathext/statistics_test.go

@@ -0,0 +1,238 @@
+package mathext
+
+import (
+	"math"
+	"testing"
+)
+
+func TestSumIntsHappyPath(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	expected := 15
+	result := Sum(values)
+	if result != expected {
+		t.Errorf("Sum of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestSumFloatsHappyPath(t *testing.T) {
+	values := []float64{1.1, 2.2, 3.3}
+	expected := 6.6
+	result := Sum(values)
+	if result != expected {
+		t.Errorf("Sum of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMeanOfInts(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	expected := 3.0
+	result := Mean(values)
+	if result != expected {
+		t.Errorf("Mean of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMedianOddNumberOfElements(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	expected := 3.0
+	result := Median(values)
+	if result != expected {
+		t.Errorf("Median of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestMedianEvenNumberOfElements(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5, 6}
+	expected := 3.5
+	result := Median(values)
+	if result != expected {
+		t.Errorf("Median of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestArrMinInts(t *testing.T) {
+	values := []int{5, 3, 9, 1, 4}
+	expected := 1
+	result := ArrMin(values)
+	if result != expected {
+		t.Errorf("ArrMin of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestArrMaxInts(t *testing.T) {
+	values := []int{5, 3, 9, 1, 4}
+	expected := 9
+	result := ArrMax(values)
+	if result != expected {
+		t.Errorf("ArrMax of %v; expected %v, got %v", values, expected, result)
+	}
+}
+
+func TestPercentileValidInput(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	percentile := 50.0
+	expected := 3
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileOutOfRange(t *testing.T) {
+	values := []int{1, 2, 3, 4, 5}
+	percentile := 150.0
+	_, err := Percentile(values, percentile)
+	if err == nil {
+		t.Errorf("Expected error for percentile %v out of range, got nil", percentile)
+	}
+}
+
+func TestPercentileValueInArray(t *testing.T) {
+	values := []int{1, 3, 5, 7, 9}
+	percentile := 40.0
+	expected := 4
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileValueInArray(t *testing.T) {
+	values := []int{1, 3, 5, 7, 9}
+	percentile := 40.0
+	expected := 4.2
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileInterpolation(t *testing.T) {
+	values := []float64{1.0, 2.0, 3.0, 4.0, 5.0}
+	percentile := 25.0
+	expected := 2.0
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileSingleValue(t *testing.T) {
+	values := []int{10}
+	percentile := 50.0
+	expected := 10
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileExactlyBetweenTwoValues(t *testing.T) {
+	values := []float64{1, 2, 3, 4, 5}
+	percentile := 62.5 // Exactly between 3 and 4
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileTwoThirdsBetweenTwoValues(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 66.666666666666
+	expected := 6.666666666666667 // Since 2/3 of the way between 6 and 7 is 6.666...
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileBetweenTwoValues1(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 11.0
+	expected := 1.1
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileBetweenTwoValues2(t *testing.T) {
+	values := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	percentile := 9.0
+	expected := 0.9
+	result, err := Percentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInput(t *testing.T) {
+	values := []float64{5, 1, 4, 2, 3} // Unsorted input
+	percentile := 50.0
+	expected := 3.0
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInputLowPercentile(t *testing.T) {
+	values := []float64{10, 6, 7, 3, 2, 9, 8, 1, 4, 5} // Unsorted input
+	percentile := 10.0
+	expected := 1.9 // Expecting interpolation between 1 and 2
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestPercentileUnsortedInputHighPercentile(t *testing.T) {
+	values := []float64{10, 6, 7, 3, 2, 9, 8, 1, 4, 5} // Unsorted input
+	percentile := 90.0
+	expected := 9.1 // Expecting interpolation between 9 and 10
+	result, err := Percentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("Percentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileExactValueFromInput(t *testing.T) {
+	values := []float64{1.5, 2.5, 3.5, 4.5, 5.5}
+	percentile := 50.0 // Exact value from input array should be 3.5
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileInterpolatedValue(t *testing.T) {
+	values := []float64{1.0, 2.0, 3.0, 4.0, 5.0}
+	percentile := 87.5 // Interpolated value between 4.0 and 5.0
+	expected := 4.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileUnsortedInputExactValue(t *testing.T) {
+	values := []float64{5.5, 1.5, 4.5, 2.5, 3.5} // Unsorted input
+	percentile := 50.0
+	expected := 3.5
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || result != expected {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}
+
+func TestFloatPercentileUnsortedInputInterpolatedValue(t *testing.T) {
+	values := []float64{10.5, 6.5, 7.5, 3.5, 2.5, 9.5, 8.5, 1.5, 4.5, 5.5}
+	percentile := 80.0 // Interpolated value between 4.0 and 5.0
+	expected := 8.7
+	result, err := FloatPercentile(values, percentile)
+	if err != nil || math.Abs(result-expected) > 1e-9 {
+		t.Errorf("FloatPercentile %v of %v; expected %v, got %v, err: %v", percentile, values, expected, result, err)
+	}
+}

reflectext/structAccess.go

@@ -0,0 +1,185 @@
+package reflectext
+
+import (
+	"errors"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+var ErrAccessStructInvalidFieldType = errors.New("invalid field type")
+var ErrAccessStructFieldInPathWasNil = errors.New("a field in the path was nil")
+var ErrAccessStructInvalidArrayIndex = errors.New("invalid array index")
+var ErrAccessStructInvalidMapKey = errors.New("invalid map key")
+var ErrAccessStructArrayAccess = errors.New("trying to access array")
+var ErrAccessStructMapAccess = errors.New("trying to access map")
+var ErrAccessStructMissingField = errors.New("missing field")
+
+type AccessStructOpt struct {
+	ReturnNilOnMissingFields          bool    // return nil (instead of error) when a field in the path is missing (aka the supplied path is wrong)
+	ReturnNilOnNilPtrFields           bool    // return nil (instead of error) when a field in the path is nil
+	ReturnNilOnWrongFinalFieldType    bool    // return nil (instead of error) when the (final) field is not of the requested generic type
+	ReturnNilOnWrongIntermedFieldType bool    // return nil (instead of error) when the intermediate field has an invalid type
+	ReturnNilOnInvalidArrayIndizes    bool    // return nil (instead of error) when trying to acces an array with an invalid index (not a number or out of range)
+	ReturnNilOnMissingMapKeys         bool    // return nil (instead of error) when trying to access a map with a missing key
+	UsedTagForKeys                    *string // Use this tag for key names in the struct (instead of the StructField.Name)
+	PreventArrayAccess                bool    // do not access array indizes - throw an error instead
+	PreventMapAccess                  bool    // do not access maps - throw an error instead
+}
+
+func AccessJSONStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{UsedTagForKeys: langext.Ptr("json")})
+}
+
+func AccessStruct[TResult any](v any, path string) (TResult, error) {
+	return AccessStructByStringPath[TResult](v, path, AccessStructOpt{})
+}
+
+func AccessStructByArrayPath[TResult any](v any, path []string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), path, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func AccessStructByStringPath[TResult any](v any, path string, opts ...AccessStructOpt) (TResult, error) {
+	opt := AccessStructOpt{}
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+	arrpath := strings.Split(path, ".")
+
+	resultVal, err := accessStructByPath(reflect.ValueOf(v), arrpath, opt)
+	if err != nil {
+		return *new(TResult), err
+	}
+
+	if resultValCast, ok := resultVal.(TResult); ok {
+		return resultValCast, nil
+	} else if opt.ReturnNilOnWrongFinalFieldType {
+		return *new(TResult), nil
+	} else {
+		return *new(TResult), ErrAccessStructInvalidFieldType
+	}
+}
+
+func accessStructByPath(val reflect.Value, path []string, opt AccessStructOpt) (any, error) {
+	if len(path) == 0 {
+		return val.Interface(), nil
+	}
+
+	currPath := path[0]
+
+	if val.Kind() == reflect.Ptr {
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+		return accessStructByPath(val.Elem(), path, opt)
+	}
+
+	if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
+		if opt.PreventArrayAccess {
+			return nil, ErrAccessStructArrayAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		arrIdx, err := strconv.ParseInt(currPath, 10, 64)
+		if err != nil {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		if arrIdx < 0 || int(arrIdx) >= val.Len() {
+			if opt.ReturnNilOnInvalidArrayIndizes {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidArrayIndex
+			}
+		}
+		return accessStructByPath(val.Index(int(arrIdx)), path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Map {
+		if opt.PreventMapAccess {
+			return nil, ErrAccessStructMapAccess
+		}
+
+		if val.IsNil() {
+			if opt.ReturnNilOnNilPtrFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructFieldInPathWasNil
+			}
+		}
+
+		mapval := val.MapIndex(reflect.ValueOf(currPath))
+		if !mapval.IsValid() || mapval.IsZero() {
+			if opt.ReturnNilOnMissingMapKeys {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructInvalidMapKey
+			}
+		}
+
+		return accessStructByPath(mapval, path[1:], opt)
+	}
+
+	if val.Kind() == reflect.Struct {
+		if opt.UsedTagForKeys != nil {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Tag.Get(*opt.UsedTagForKeys) == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		} else {
+			for i := 0; i < val.NumField(); i++ {
+				if val.Type().Field(i).Name == currPath {
+					return accessStructByPath(val.Field(i), path[1:], opt)
+				}
+			}
+			if opt.ReturnNilOnMissingFields {
+				return nil, nil
+			} else {
+				return nil, ErrAccessStructMissingField
+			}
+		}
+	}
+
+	if opt.ReturnNilOnWrongIntermedFieldType {
+		return nil, nil
+	} else {
+		return nil, ErrAccessStructMissingField
+	}
+}

reflectext/structAccess_test.go

@@ -0,0 +1,259 @@
+package reflectext
+
+import "testing"
+
+type TestStruct struct {
+	Name string `json:"name"`
+	Age  int    `json:"age"`
+}
+
+func TestAccessStructByArrayPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByStringPath_HappyPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	result, err := AccessStructByStringPath[string](testStruct, "Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByStringPath_InvalidField(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByStringPath[string](testStruct, "Invalid")
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type RecursiveStruct struct {
+	Name     string
+	Sub      *RecursiveStruct
+	SubSlice []RecursiveStruct
+}
+
+func TestAccessStructByArrayPath_RecursiveStruct(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", Sub: &RecursiveStruct{Name: "Jane"}}
+	result, err := AccessStructByArrayPath[string](*testStruct.Sub, []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_RecursiveStructSlice(t *testing.T) {
+	testStruct := RecursiveStruct{Name: "John", SubSlice: []RecursiveStruct{{Name: "Jane"}}}
+	result, err := AccessStructByArrayPath[string](testStruct.SubSlice[0], []string{"Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_WrongType(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[int](testStruct, []string{"Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Name", "Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStruct struct {
+	Name string
+	Sub  *TestStruct
+}
+
+func TestAccessStructByStringPath_NestedStruct(t *testing.T) {
+	testStruct := NestedStruct{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+type DeepNestedStruct struct {
+	Name string
+	Sub  *NestedStruct
+}
+
+func TestAccessStructByStringPath_DeepNestedStruct(t *testing.T) {
+	testStruct := DeepNestedStruct{Name: "John", Sub: &NestedStruct{Name: "Jane", Sub: &TestStruct{Name: "Doe", Age: 30}}}
+	result, err := AccessStructByStringPath[string](testStruct, "Sub.Sub.Name")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Doe" {
+		t.Errorf("Expected 'Doe', got '%s'", result)
+	}
+}
+
+type MapStruct struct {
+	Name string
+	Age  int
+}
+
+type TestStructWithMap struct {
+	MapField map[string]MapStruct
+}
+
+func TestAccessStructByArrayPath_MapField(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "key", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "John" {
+		t.Errorf("Expected 'John', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidMapKey(t *testing.T) {
+	testStruct := TestStructWithMap{
+		MapField: map[string]MapStruct{
+			"key": {Name: "John", Age: 30},
+		},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"MapField", "invalid", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type ArrayStruct struct {
+	Name string
+	Arr  []TestStruct
+}
+
+func TestAccessStructByArrayPath_ArrayField(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "0", "Name"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_InvalidArrayIndex(t *testing.T) {
+	testStruct := ArrayStruct{
+		Name: "John",
+		Arr:  []TestStruct{{Name: "Jane", Age: 30}},
+	}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Arr", "1", "Name"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type FunctionStruct struct {
+	Name string
+	Func func() string
+}
+
+func TestAccessStructByArrayPath_FunctionField(t *testing.T) {
+	testStruct := FunctionStruct{Name: "John", Func: func() string { return "Hello" }}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"Func"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+func TestAccessStructByArrayPath_NonExistentPath(t *testing.T) {
+	testStruct := TestStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"NonExistent"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type NestedStructWithTag struct {
+	Name string      `json:"name"`
+	Sub  *TestStruct `json:"sub"`
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeys(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	result, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "name"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != "Jane" {
+		t.Errorf("Expected 'Jane', got '%s'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_UsedTagForKeysInvalid(t *testing.T) {
+	testStruct := NestedStructWithTag{Name: "John", Sub: &TestStruct{Name: "Jane", Age: 30}}
+	tag := "json"
+	_, err := AccessStructByArrayPath[string](testStruct, []string{"sub", "invalid"}, AccessStructOpt{UsedTagForKeys: &tag})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}
+
+type DifferentTypeStruct struct {
+	Name string
+	Age  int
+}
+
+func TestAccessStructByArrayPath_DifferentType(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	result, err := AccessStructByArrayPath[any](testStruct, []string{"Age"})
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != 30 {
+		t.Errorf("Expected '30', got '%v'", result)
+	}
+}
+
+func TestAccessStructByArrayPath_DifferentTypeInvalid(t *testing.T) {
+	testStruct := DifferentTypeStruct{Name: "John", Age: 30}
+	_, err := AccessStructByArrayPath[any](testStruct, []string{"Invalid"})
+	if err == nil {
+		t.Errorf("Expected error, got nil")
+	}
+}

timeext/diff.go

@@ -0,0 +1,13 @@
+package timeext
+
+import "time"
+
+func YearDifference(t1 time.Time, t2 time.Time, tz *time.Location) float64 {
+
+	yDelta := float64(t1.Year() - t2.Year())
+
+	processT1 := float64(t1.Sub(TimeToYearStart(t1, tz))) / float64(TimeToYearEnd(t1, tz).Sub(TimeToYearStart(t1, tz)))
+	processT2 := float64(t2.Sub(TimeToYearStart(t2, tz))) / float64(TimeToYearEnd(t2, tz).Sub(TimeToYearStart(t2, tz)))
+
+	return yDelta + (processT1 - processT2)
+}

timeext/diff_test.go

@@ -0,0 +1,83 @@
+package timeext
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+func TestYearDifferenceWithSameYearAndDay(t *testing.T) {
+	t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.0
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithOneYearApart(t *testing.T) {
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 1.0
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithDifferentMonths(t *testing.T) {
+	t1 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.4166666666666667 // Approximation of 5/12 months
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceAcrossYears(t *testing.T) {
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
+	t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, time.UTC)
+	expected := 0.5833333333333334 // Approximation of 7/12 months
+	result := YearDifference(t1, t2, time.UTC)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithTimezone(t *testing.T) {
+	tz, _ := time.LoadLocation("America/New_York")
+	t1 := time.Date(2021, 1, 1, 0, 0, 0, 0, tz)
+	t2 := time.Date(2020, 6, 1, 0, 0, 0, 0, tz)
+	expected := 0.5833333333333334 // Same as UTC but ensuring timezone is considered
+	result := YearDifference(t1, t2, tz)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithNegativeDifference(t *testing.T) {
+	t1 := time.Date(2020, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
+	t2 := time.Date(2021, 1, 1, 0, 0, 0, 0, TimezoneBerlin)
+	expected := -1.0
+	result := YearDifference(t1, t2, TimezoneBerlin)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestYearDifferenceWithNegativeDifference2(t *testing.T) {
+	t1 := time.Date(2020, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
+	t2 := time.Date(2021, 7, 1, 0, 0, 0, 0, TimezoneBerlin)
+	expected := -1.0
+	result := YearDifference(t1, t2, TimezoneBerlin)
+	if !epsilonEquals(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func epsilonEquals(a, b float64) bool {
+	epsilon := 0.01
+	return math.Abs(a-b) < epsilon
+}

timeext/time.go

@@ -65,6 +65,10 @@ func TimeToYearEnd(t time.Time, tz *time.Location) time.Time {
 	return TimeToYearStart(t, tz).AddDate(1, 0, 0).Add(-1)
 }
 
+func TimeToNextYearStart(t time.Time, tz *time.Location) time.Time {
+	return TimeToYearStart(t, tz).AddDate(1, 0, 0)
+}
+
 // IsSameDayIncludingDateBoundaries returns true if t1 and t2 are part of the same day (TZ/Berlin), the boundaries of the day are
 // inclusive, this means 2021-09-15T00:00:00 is still part of the day 2021-09-14
 func IsSameDayIncludingDateBoundaries(t1 time.Time, t2 time.Time, tz *time.Location) bool {

timeext/time_test.go

@@ -72,6 +72,13 @@ func TestIsSunday(t *testing.T) {
 	}
 }
 
+func TestIsSunday_OnSunday(t *testing.T) {
+	sunday := time.Date(2022, 5, 15, 0, 0, 0, 0, TimezoneBerlin) // A Sunday
+	if !IsSunday(sunday, TimezoneBerlin) {
+		t.Errorf("Expected true for Sunday")
+	}
+}
+
 func TestDurationFromTime(t *testing.T) {
 	expected := time.Duration(13*time.Hour + 14*time.Minute + 15*time.Second)
 	result := DurationFromTime(13, 14, 15)
@@ -156,3 +163,31 @@ func TestAddYears(t *testing.T) {
 		t.Errorf("Expected %v but got %v", expected, result)
 	}
 }
+
+func TestIsDatePartEqual_SameDateDifferentTimes(t *testing.T) {
+	tz := time.UTC
+	t1 := time.Date(2022, 5, 18, 10, 30, 0, 0, tz)
+	t2 := time.Date(2022, 5, 18, 20, 45, 0, 0, tz)
+	if !IsDatePartEqual(t1, t2, tz) {
+		t.Errorf("Expected dates to be equal")
+	}
+}
+
+func TestWithTimePart_ChangeTime(t *testing.T) {
+	base := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
+	result := WithTimePart(base, 15, 30, 45)
+	expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestCombineDateAndTime_CombineDifferentParts(t *testing.T) {
+	date := time.Date(2022, 5, 18, 0, 0, 0, 0, time.UTC)
+	timePart := time.Date(2000, 1, 1, 15, 30, 45, 0, time.UTC)
+	result := CombineDateAndTime(date, timePart)
+	expected := time.Date(2022, 5, 18, 15, 30, 45, 0, time.UTC)
+	if !result.Equal(expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}

wmo/queryAggregate.go

@@ -19,6 +19,8 @@ func (c *Coll[TData]) Aggregate(ctx context.Context, pipeline mongo.Pipeline, op
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	res, err := c.decodeAll(ctx, cursor)
 	if err != nil {
 		return nil, exerr.Wrap(err, "failed to decode values").Build()
@@ -38,6 +40,8 @@ func (c *Coll[TData]) AggregateOneOpt(ctx context.Context, pipeline mongo.Pipeli
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v, err := c.decodeSingle(ctx, cursor)
 		if err != nil {
@@ -60,6 +64,8 @@ func (c *Coll[TData]) AggregateOne(ctx context.Context, pipeline mongo.Pipeline,
 		return *new(TData), exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Any("options", opts).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v, err := c.decodeSingle(ctx, cursor)
 		if err != nil {

wmo/queryFind.go

@@ -64,6 +64,8 @@ func (c *Coll[TData]) Find(ctx context.Context, filter bson.M, opts ...*options.
 		return nil, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	res, err := c.decodeAll(ctx, cursor)
 	if err != nil {
 		return nil, exerr.Wrap(err, "failed to decode values").Build()

wmo/queryFindOne.go

@@ -80,6 +80,8 @@ func (c *Coll[TData]) findOneInternal(ctx context.Context, filter bson.M, allowN
 			return nil, exerr.Wrap(err, "mongo-aggregation [find-one] failed").Any("pipeline", pipeline).Str("collection", c.Name()).NoLog().Build()
 		}
 
+		defer func() { _ = cursor.Close(ctx) }()
+
 		if cursor.Next(ctx) {
 			v, err := c.decodeSingle(ctx, cursor)
 			if err != nil {

wmo/queryList.go

@@ -69,6 +69,8 @@ func (c *Coll[TData]) List(ctx context.Context, filter ct.Filter, pageSize *int,
 		return nil, ct.CursorToken{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	// fast branch
 	if pageSize == nil {
 		entries, err := c.decodeAll(ctx, cursor)
@@ -118,6 +120,8 @@ func (c *Coll[TData]) Count(ctx context.Context, filter ct.RawFilter) (int64, er
 		return 0, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipeline).Str("collection", c.Name()).Build()
 	}
 
+	defer func() { _ = cursor.Close(ctx) }()
+
 	if cursor.Next(ctx) {
 		v := countRes{}
 		err = cursor.Decode(&v)

wmo/queryPaginate.go

@@ -60,19 +60,27 @@ func (c *Coll[TData]) Paginate(ctx context.Context, filter pag.MongoFilter, page
 		return nil, pag.Pagination{}, exerr.Wrap(err, "failed to all-decode entities").Build()
 	}
 
-	cursorTotalCount, err := c.coll.Aggregate(ctx, pipelineTotalCount)
-	if err != nil {
-		return nil, pag.Pagination{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
-	}
-
 	var tcRes totalCountResult
-	if cursorTotalCount.Next(ctx) {
+
-		err = cursorTotalCount.Decode(&tcRes)
+	if limit == nil {
-		if err != nil {
+		// optimization, limit==nil, so we query all entities anyway, just use the array length
-			return nil, pag.Pagination{}, exerr.Wrap(err, "failed to decode mongo-aggregation $count result").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+		tcRes.Count = len(entities)
-		}
 	} else {
-		tcRes.Count = 0 // no entries in DB
+
+		cursorTotalCount, err := c.coll.Aggregate(ctx, pipelineTotalCount)
+		if err != nil {
+			return nil, pag.Pagination{}, exerr.Wrap(err, "mongo-aggregation failed").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+		}
+
+		if cursorTotalCount.Next(ctx) {
+			err = cursorTotalCount.Decode(&tcRes)
+			if err != nil {
+				return nil, pag.Pagination{}, exerr.Wrap(err, "failed to decode mongo-aggregation $count result").Any("pipeline", pipelineTotalCount).Str("collection", c.Name()).Build()
+			}
+		} else {
+			tcRes.Count = 0 // no entries in DB
+		}
+
 	}
 
 	paginationObj := pag.Pagination{

wpdf/wpdf.go

@@ -3,6 +3,7 @@ package wpdf
 import (
 	"bytes"
 	"github.com/jung-kurt/gofpdf"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 )
 
 type WPDFBuilder struct {
@@ -105,6 +106,18 @@ func (b *WPDFBuilder) SetFont(fontName PDFFontFamily, fontStyle PDFFontStyle, fo
 	b.cellHeight = b.b.PointConvert(fontSize)
 }
 
+func (b *WPDFBuilder) GetFontSize() float64 {
+	return b.fontSize
+}
+
+func (b *WPDFBuilder) GetFontFamily() PDFFontStyle {
+	return b.fontStyle
+}
+
+func (b *WPDFBuilder) GetFontStyle() float64 {
+	return b.fontSize
+}
+
 func (b *WPDFBuilder) SetCellSpacing(h float64) {
 	b.cellSpacing = h
 }
@@ -192,6 +205,40 @@ func (b *WPDFBuilder) GetWorkAreaWidth() float64 {
 	return b.GetPageWidth() - b.GetMarginLeft() - b.GetMarginRight()
 }
 
-func (b *WPDFBuilder) GetStringWidth(str string) float64 {
+func (b *WPDFBuilder) SetAutoPageBreak(auto bool, margin float64) {
+	b.b.SetAutoPageBreak(auto, margin)
+}
+
+func (b *WPDFBuilder) SetFooterFunc(fnc func()) {
+	b.b.SetFooterFunc(fnc)
+}
+
+func (b *WPDFBuilder) PageNo() int {
+	return b.b.PageNo()
+}
+
+func (b *WPDFBuilder) GetStringWidth(str string, opts ...PDFCellOpt) float64 {
+
+	var fontNameOverride *PDFFontFamily
+	var fontStyleOverride *PDFFontStyle
+	var fontSizeOverride *float64
+
+	for _, opt := range opts {
+		fontNameOverride = langext.CoalesceOpt(opt.fontNameOverride, fontNameOverride)
+		fontStyleOverride = langext.CoalesceOpt(opt.fontStyleOverride, fontStyleOverride)
+		fontSizeOverride = langext.CoalesceOpt(opt.fontSizeOverride, fontSizeOverride)
+	}
+
+	if fontNameOverride != nil || fontStyleOverride != nil || fontSizeOverride != nil {
+		oldFontName := b.fontName
+		oldFontStyle := b.fontStyle
+		oldFontSize := b.fontSize
+		newFontName := langext.Coalesce(fontNameOverride, oldFontName)
+		newFontStyle := langext.Coalesce(fontStyleOverride, oldFontStyle)
+		newFontSize := langext.Coalesce(fontSizeOverride, oldFontSize)
+		b.SetFont(newFontName, newFontStyle, newFontSize)
+		defer func() { b.SetFont(oldFontName, oldFontStyle, oldFontSize) }()
+	}
+
 	return b.b.GetStringWidth(str)
 }

wpdf/wpdfCell.go

@@ -1,6 +1,9 @@
 package wpdf
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
 
 type PDFCellOpt struct {
 	width             *float64
@@ -14,6 +17,7 @@ type PDFCellOpt struct {
 	fontNameOverride  *PDFFontFamily
 	fontStyleOverride *PDFFontStyle
 	fontSizeOverride  *float64
+	alphaOverride     *dataext.Tuple[float64, PDFBlendMode]
 	extraLn           *float64
 	x                 *float64
 	autoWidth         *bool
@@ -149,6 +153,34 @@ func (opt *PDFCellOpt) FillColorHex(c uint32) *PDFCellOpt {
 	return opt
 }
 
+func (opt *PDFCellOpt) Alpha(alpha float64, blendMode PDFBlendMode) *PDFCellOpt {
+	opt.alphaOverride = &dataext.Tuple[float64, PDFBlendMode]{V1: alpha, V2: blendMode}
+	return opt
+}
+
+func (opt *PDFCellOpt) Copy() *PDFCellOpt {
+	c := *opt
+	return &c
+}
+
+func (opt *PDFCellOpt) ToMulti() *PDFMultiCellOpt {
+	return &PDFMultiCellOpt{
+		width:             opt.width,
+		height:            opt.height,
+		border:            opt.border,
+		align:             opt.align,
+		fill:              opt.fill,
+		fontNameOverride:  opt.fontNameOverride,
+		fontStyleOverride: opt.fontStyleOverride,
+		fontSizeOverride:  opt.fontSizeOverride,
+		extraLn:           opt.extraLn,
+		x:                 opt.x,
+		textColor:         opt.textColor,
+		borderColor:       opt.borderColor,
+		fillColor:         opt.fillColor,
+	}
+}
+
 func (b *WPDFBuilder) Cell(txt string, opts ...*PDFCellOpt) {
 
 	txtTR := b.tr(txt)
@@ -164,6 +196,7 @@ func (b *WPDFBuilder) Cell(txt string, opts ...*PDFCellOpt) {
 	var fontNameOverride *PDFFontFamily
 	var fontStyleOverride *PDFFontStyle
 	var fontSizeOverride *float64
+	var alphaOverride *dataext.Tuple[float64, PDFBlendMode]
 	extraLn := float64(0)
 	var x *float64
 	autoWidth := false
@@ -184,6 +217,7 @@ func (b *WPDFBuilder) Cell(txt string, opts ...*PDFCellOpt) {
 		fontNameOverride = langext.CoalesceOpt(opt.fontNameOverride, fontNameOverride)
 		fontStyleOverride = langext.CoalesceOpt(opt.fontStyleOverride, fontStyleOverride)
 		fontSizeOverride = langext.CoalesceOpt(opt.fontSizeOverride, fontSizeOverride)
+		alphaOverride = langext.CoalesceOpt(opt.alphaOverride, alphaOverride)
 		extraLn = langext.Coalesce(opt.extraLn, extraLn)
 		x = langext.CoalesceOpt(opt.x, x)
 		autoWidth = langext.Coalesce(opt.autoWidth, autoWidth)
@@ -222,6 +256,12 @@ func (b *WPDFBuilder) Cell(txt string, opts ...*PDFCellOpt) {
 		defer func() { b.SetFillColor(oldColorR, oldColorG, oldColorB) }()
 	}
 
+	if alphaOverride != nil {
+		oldA, oldBMS := b.b.GetAlpha()
+		b.b.SetAlpha(alphaOverride.V1, string(alphaOverride.V2))
+		defer func() { b.b.SetAlpha(oldA, oldBMS) }()
+	}
+
 	if x != nil {
 		b.b.SetX(*x)
 	}

wpdf/wpdfConstants.go

@@ -74,6 +74,35 @@ const (
 	RectFillOutline PDFRectStyle = "FD"
 )
 
+type PDFBlendMode string
+
+const (
+	BlendNormal     PDFBlendMode = "Normal"
+	BlendMultiply   PDFBlendMode = "Multiply"
+	BlendScreen     PDFBlendMode = "Screen"
+	BlendOverlay    PDFBlendMode = "Overlay"
+	BlendDarken     PDFBlendMode = "Darken"
+	BlendLighten    PDFBlendMode = "Lighten"
+	BlendColorDodge PDFBlendMode = "ColorDodge"
+	BlendColorBurn  PDFBlendMode = "ColorBurn"
+	BlendHardLight  PDFBlendMode = "HardLight"
+	BlendSoftLight  PDFBlendMode = "SoftLight"
+	BlendDifference PDFBlendMode = "Difference"
+	BlendExclusion  PDFBlendMode = "Exclusion"
+	BlendHue        PDFBlendMode = "Hue"
+	BlendSaturation PDFBlendMode = "Saturation"
+	BlendColor      PDFBlendMode = "Color"
+	BlendLuminosity PDFBlendMode = "Luminosity"
+)
+
+type PDFLineCapStyle string
+
+const (
+	CapButt   PDFLineCapStyle = "butt"
+	CapRound  PDFLineCapStyle = "round"
+	CapSquare PDFLineCapStyle = "square"
+)
+
 const (
 	BackgroundFill        = true
 	BackgroundTransparent = false

wpdf/wpdfImage.go

@@ -3,10 +3,12 @@ package wpdf
 import (
 	"bytes"
 	"github.com/jung-kurt/gofpdf"
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
 	"gogs.mikescher.com/BlackForestBytes/goext/imageext"
 	"gogs.mikescher.com/BlackForestBytes/goext/langext"
 	"image"
 	"image/color"
+	"image/draw"
 	"net/http"
 )
 
@@ -64,7 +66,12 @@ func (b *WPDFBuilder) RegisterImage(bin []byte, opts ...*PDFImageRegisterOpt) *P
 	}
 
 	if imageType == "" {
-		ct := http.DetectContentType(bin[:512])
+		ct := ""
+		if len(bin) > 512 {
+			ct = http.DetectContentType(bin[:512])
+		} else {
+			ct = http.DetectContentType(bin)
+		}
 		switch ct {
 		case "image/jpg":
 			imageType = "JPG"
@@ -124,6 +131,8 @@ type PDFImageOpt struct {
 	compression           *imageext.ImageCompresson
 	reEncodePixelPerMM    *float64
 	crop                  *imageext.ImageCrop
+	alphaOverride         *dataext.Tuple[float64, PDFBlendMode]
+	debug                 *bool
 }
 
 func NewPDFImageOpt() *PDFImageOpt {
@@ -150,6 +159,11 @@ func (opt *PDFImageOpt) Height(v float64) *PDFImageOpt {
 	return opt
 }
 
+func (opt *PDFImageOpt) Debug(v bool) *PDFImageOpt {
+	opt.debug = &v
+	return opt
+}
+
 func (opt *PDFImageOpt) Flow(v bool) *PDFImageOpt {
 	opt.flow = &v
 	return opt
@@ -211,6 +225,11 @@ func (opt *PDFImageOpt) Crop(cropX float64, cropY float64, cropWidth float64, cr
 	return opt
 }
 
+func (opt *PDFImageOpt) Alpha(alpha float64, blendMode PDFBlendMode) *PDFImageOpt {
+	opt.alphaOverride = &dataext.Tuple[float64, PDFBlendMode]{V1: alpha, V2: blendMode}
+	return opt
+}
+
 func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 	var err error
 
@@ -228,7 +247,9 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 	var imageFit *imageext.ImageFit = nil
 	var fillColor color.Color = color.Transparent
 	compression := imageext.CompressionPNGSpeed
+	debug := false
 	var crop *imageext.ImageCrop = nil
+	var alphaOverride *dataext.Tuple[float64, PDFBlendMode]
 
 	for _, opt := range opts {
 		x = langext.Coalesce(opt.x, x)
@@ -246,10 +267,14 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 		compression = langext.Coalesce(opt.compression, compression)
 		reEncodePixelPerMM = langext.Coalesce(opt.reEncodePixelPerMM, reEncodePixelPerMM)
 		crop = langext.CoalesceOpt(opt.crop, crop)
+		debug = langext.Coalesce(opt.debug, debug)
+		alphaOverride = langext.CoalesceOpt(opt.alphaOverride, alphaOverride)
 	}
 
 	regName := img.Name
 
+	var subImageBounds *imageext.PercentageRectangle = nil
+
 	if imageFit != nil || fillColor != nil || crop != nil {
 
 		var dataimg image.Image
@@ -277,11 +302,21 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 			pxw := w * pdfPixelPerMillimeter
 			pxh := h * pdfPixelPerMillimeter
 
-			dataimg, err = imageext.ObjectFitImage(dataimg, pxw, pxh, *imageFit, fillColor)
+			var dataImgRect imageext.PercentageRectangle
+			dataimg, dataImgRect, err = imageext.ObjectFitImage(dataimg, pxw, pxh, *imageFit, fillColor)
 			if err != nil {
 				b.b.SetError(err)
 				return
 			}
+
+			subImageBounds = &dataImgRect
+		}
+
+		if dataimg.ColorModel() != color.RGBAModel && dataimg.ColorModel() != color.NRGBAModel {
+			// the image cannto be 16bpp or similar - otherwise fpdf errors out
+			dataImgRGBA := image.NewNRGBA(image.Rect(0, 0, dataimg.Bounds().Dx(), dataimg.Bounds().Dy()))
+			draw.Draw(dataImgRGBA, dataImgRGBA.Bounds(), dataimg, dataimg.Bounds().Min, draw.Src)
+			dataimg = dataImgRGBA
 		}
 
 		bfr, imgMime, err := imageext.EncodeImage(dataimg, compression)
@@ -305,6 +340,12 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 
 	}
 
+	if alphaOverride != nil {
+		oldA, oldBMS := b.b.GetAlpha()
+		b.b.SetAlpha(alphaOverride.V1, string(alphaOverride.V2))
+		defer func() { b.b.SetAlpha(oldA, oldBMS) }()
+	}
+
 	fpdfOpt := gofpdf.ImageOptions{
 		ImageType:             imageType,
 		ReadDpi:               readDpi,
@@ -312,4 +353,15 @@ func (b *WPDFBuilder) Image(img *PDFImageRef, opts ...*PDFImageOpt) {
 	}
 
 	b.b.ImageOptions(regName, x, y, w, h, flow, fpdfOpt, link, linkStr)
+
+	if debug {
+		b.Rect(w, h, RectOutline, NewPDFRectOpt().X(x).Y(y).LineWidth(2).DrawColor(255, 0, 0))
+
+		if subImageBounds != nil {
+			r := subImageBounds.Of(imageext.Rectangle{X: x, Y: y, W: w, H: h})
+			b.Rect(r.W, r.H, RectFill, NewPDFRectOpt().X(r.X).Y(r.Y).FillColor(255, 0, 0).Alpha(0.2, BlendNormal))
+			b.Line(r.X, r.Y, r.X+r.W, r.Y+r.H, NewPDFLineOpt().LineWidth(2).DrawColor(255, 0, 0))
+			b.Line(r.X+r.W, r.Y, r.X, r.Y+r.H, NewPDFLineOpt().LineWidth(2).DrawColor(255, 0, 0))
+		}
+	}
 }

wpdf/wpdfLine.go

@@ -0,0 +1,88 @@
+package wpdf
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
+
+type PDFLineOpt struct {
+	lineWidth *float64
+	drawColor *PDFColor
+	alpha     *dataext.Tuple[float64, PDFBlendMode]
+	capStyle  *PDFLineCapStyle
+}
+
+func NewPDFLineOpt() *PDFLineOpt {
+	return &PDFLineOpt{}
+}
+
+func (opt *PDFLineOpt) LineWidth(v float64) *PDFLineOpt {
+	opt.lineWidth = &v
+	return opt
+}
+
+func (opt *PDFLineOpt) DrawColor(cr, cg, cb int) *PDFLineOpt {
+	opt.drawColor = langext.Ptr(rgbToColor(cr, cg, cb))
+	return opt
+}
+
+func (opt *PDFLineOpt) DrawColorHex(c uint32) *PDFLineOpt {
+	opt.drawColor = langext.Ptr(hexToColor(c))
+	return opt
+}
+
+func (opt *PDFLineOpt) Alpha(alpha float64, blendMode PDFBlendMode) *PDFLineOpt {
+	opt.alpha = &dataext.Tuple[float64, PDFBlendMode]{V1: alpha, V2: blendMode}
+	return opt
+}
+
+func (opt *PDFLineOpt) CapButt() *PDFLineOpt {
+	opt.capStyle = langext.Ptr(CapButt)
+	return opt
+}
+
+func (opt *PDFLineOpt) CapSquare() *PDFLineOpt {
+	opt.capStyle = langext.Ptr(CapSquare)
+	return opt
+}
+
+func (opt *PDFLineOpt) CapRound() *PDFLineOpt {
+	opt.capStyle = langext.Ptr(CapRound)
+	return opt
+}
+
+func (b *WPDFBuilder) Line(x1 float64, y1 float64, x2 float64, y2 float64, opts ...*PDFLineOpt) {
+	var lineWidth *float64
+	var drawColor *PDFColor
+	var alphaOverride *dataext.Tuple[float64, PDFBlendMode]
+	capStyle := CapButt
+
+	for _, opt := range opts {
+		lineWidth = langext.CoalesceOpt(opt.lineWidth, lineWidth)
+		drawColor = langext.CoalesceOpt(opt.drawColor, drawColor)
+		alphaOverride = langext.CoalesceOpt(opt.alpha, alphaOverride)
+		capStyle = langext.Coalesce(opt.capStyle, capStyle)
+	}
+
+	if lineWidth != nil {
+		old := b.GetLineWidth()
+		b.SetLineWidth(*lineWidth)
+		defer func() { b.SetLineWidth(old) }()
+	}
+
+	if drawColor != nil {
+		oldR, oldG, oldB := b.GetDrawColor()
+		b.SetDrawColor(drawColor.R, drawColor.G, drawColor.B)
+		defer func() { b.SetDrawColor(oldR, oldG, oldB) }()
+	}
+
+	if alphaOverride != nil {
+		oldA, oldBMS := b.b.GetAlpha()
+		b.b.SetAlpha(alphaOverride.V1, string(alphaOverride.V2))
+		defer func() { b.b.SetAlpha(oldA, oldBMS) }()
+	}
+
+	b.b.SetLineCapStyle(string(capStyle))
+
+	b.b.Line(x1, y1, x2, y2)
+}

wpdf/wpdfMultiCell.go

@@ -1,6 +1,9 @@
 package wpdf
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
 
 type PDFMultiCellOpt struct {
 	width             *float64
@@ -11,6 +14,7 @@ type PDFMultiCellOpt struct {
 	fontNameOverride  *PDFFontFamily
 	fontStyleOverride *PDFFontStyle
 	fontSizeOverride  *float64
+	alphaOverride     *dataext.Tuple[float64, PDFBlendMode]
 	extraLn           *float64
 	x                 *float64
 	textColor         *PDFColor
@@ -119,6 +123,11 @@ func (opt *PDFMultiCellOpt) FillColorHex(c uint32) *PDFMultiCellOpt {
 	return opt
 }
 
+func (opt *PDFMultiCellOpt) Alpha(alpha float64, blendMode PDFBlendMode) *PDFMultiCellOpt {
+	opt.alphaOverride = &dataext.Tuple[float64, PDFBlendMode]{V1: alpha, V2: blendMode}
+	return opt
+}
+
 func (b *WPDFBuilder) MultiCell(txt string, opts ...*PDFMultiCellOpt) {
 
 	txtTR := b.tr(txt)
@@ -131,6 +140,7 @@ func (b *WPDFBuilder) MultiCell(txt string, opts ...*PDFMultiCellOpt) {
 	var fontNameOverride *PDFFontFamily
 	var fontStyleOverride *PDFFontStyle
 	var fontSizeOverride *float64
+	var alphaOverride *dataext.Tuple[float64, PDFBlendMode]
 	extraLn := float64(0)
 	var x *float64
 	var textColor *PDFColor
@@ -146,6 +156,7 @@ func (b *WPDFBuilder) MultiCell(txt string, opts ...*PDFMultiCellOpt) {
 		fontNameOverride = langext.CoalesceOpt(opt.fontNameOverride, fontNameOverride)
 		fontStyleOverride = langext.CoalesceOpt(opt.fontStyleOverride, fontStyleOverride)
 		fontSizeOverride = langext.CoalesceOpt(opt.fontSizeOverride, fontSizeOverride)
+		alphaOverride = langext.CoalesceOpt(opt.alphaOverride, alphaOverride)
 		extraLn = langext.Coalesce(opt.extraLn, extraLn)
 		x = langext.CoalesceOpt(opt.x, x)
 		textColor = langext.CoalesceOpt(opt.textColor, textColor)
@@ -182,6 +193,12 @@ func (b *WPDFBuilder) MultiCell(txt string, opts ...*PDFMultiCellOpt) {
 		defer func() { b.SetFillColor(oldColorR, oldColorG, oldColorB) }()
 	}
 
+	if alphaOverride != nil {
+		oldA, oldBMS := b.b.GetAlpha()
+		b.b.SetAlpha(alphaOverride.V1, string(alphaOverride.V2))
+		defer func() { b.b.SetAlpha(oldA, oldBMS) }()
+	}
+
 	if x != nil {
 		b.b.SetX(*x)
 	}

wpdf/wpdfRect.go

@@ -1,6 +1,9 @@
 package wpdf
 
-import "gogs.mikescher.com/BlackForestBytes/goext/langext"
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/dataext"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+)
 
 type PDFRectOpt struct {
 	x         *float64
@@ -8,6 +11,7 @@ type PDFRectOpt struct {
 	lineWidth *float64
 	drawColor *PDFColor
 	fillColor *PDFColor
+	alpha     *dataext.Tuple[float64, PDFBlendMode]
 	radiusTL  *float64
 	radiusTR  *float64
 	radiusBR  *float64
@@ -81,12 +85,18 @@ func (opt *PDFRectOpt) RadiusBR(radius float64) *PDFRectOpt {
 	return opt
 }
 
+func (opt *PDFRectOpt) Alpha(alpha float64, blendMode PDFBlendMode) *PDFRectOpt {
+	opt.alpha = &dataext.Tuple[float64, PDFBlendMode]{V1: alpha, V2: blendMode}
+	return opt
+}
+
 func (b *WPDFBuilder) Rect(w float64, h float64, styleStr PDFRectStyle, opts ...*PDFRectOpt) {
 	x := b.GetX()
 	y := b.GetY()
 	var lineWidth *float64
 	var drawColor *PDFColor
 	var fillColor *PDFColor
+	var alphaOverride *dataext.Tuple[float64, PDFBlendMode]
 	radiusTL := float64(0)
 	radiusTR := float64(0)
 	radiusBR := float64(0)
@@ -98,6 +108,7 @@ func (b *WPDFBuilder) Rect(w float64, h float64, styleStr PDFRectStyle, opts ...
 		lineWidth = langext.CoalesceOpt(opt.lineWidth, lineWidth)
 		drawColor = langext.CoalesceOpt(opt.drawColor, drawColor)
 		fillColor = langext.CoalesceOpt(opt.fillColor, fillColor)
+		alphaOverride = langext.CoalesceOpt(opt.alpha, alphaOverride)
 		radiusTL = langext.Coalesce(opt.radiusTL, radiusTL)
 		radiusTR = langext.Coalesce(opt.radiusTR, radiusTR)
 		radiusBR = langext.Coalesce(opt.radiusBR, radiusBR)
@@ -122,5 +133,11 @@ func (b *WPDFBuilder) Rect(w float64, h float64, styleStr PDFRectStyle, opts ...
 		defer func() { b.SetFillColor(oldR, oldG, oldB) }()
 	}
 
+	if alphaOverride != nil {
+		oldA, oldBMS := b.b.GetAlpha()
+		b.b.SetAlpha(alphaOverride.V1, string(alphaOverride.V2))
+		defer func() { b.b.SetAlpha(oldA, oldBMS) }()
+	}
+
 	b.b.RoundedRectExt(x, y, w, h, radiusTL, radiusTR, radiusBR, radiusBL, string(styleStr))
 }

wpdf/wpdfTable.go

@@ -0,0 +1,332 @@
+package wpdf
+
+import (
+	"gogs.mikescher.com/BlackForestBytes/goext/exerr"
+	"gogs.mikescher.com/BlackForestBytes/goext/langext"
+	"gogs.mikescher.com/BlackForestBytes/goext/rext"
+	"regexp"
+	"strconv"
+)
+
+// Column specifier:
+//
+// - `{number}`:             Use this amount of space
+// - `auto`:                 Use the needed space for the content
+// - `*` / `fr`:             Use the remaining space, evenly distributed, shrink down to auto
+// - `{num}fr` / `{num}*`:   Use the remaining space, evenly distributed (weighted), shrink down to auto
+//
+// # TableBuilder
+//    - PadX/PadY:            Padding between cells
+//    - DefaultStyle:         Default style for cells
+//
+// # TableCellStyleOpt
+//    - MultiCell:            Use wpdf.MultiCell() instead of wpdf.Cell()  --> supports linebreaks
+//    - Ellipsize:            Ellipsize text if too long
+//    - PaddingHorz:          Additional horizontal padding inside of cell to space text around
+//    - PDFCellOpt:           Normal styling options (evtl not all are supported, depending on MultiCell: true/false)
+
+var regexTableColumnSpecFr = rext.W(regexp.MustCompile(`^(?P<num>[0-9]*)(fr|\*)$`))
+
+type TableBuilder struct {
+	builder *WPDFBuilder
+
+	padx             float64
+	pady             float64
+	rows             []tableRow
+	defaultCellStyle *TableCellStyleOpt
+	columnWidths     *[]string
+}
+
+type TableCell struct {
+	Content string
+	Style   TableCellStyleOpt
+}
+
+type TableCellStyleOpt struct {
+	MultiCell   *bool
+	Ellipsize   *bool
+	PaddingHorz *float64
+	MinWidth    *float64
+
+	PDFCellOpt
+}
+
+type tableRow struct {
+	cells []TableCell
+}
+
+func (r tableRow) maxFontSize(defaultFontSize float64) float64 {
+	mfs := defaultFontSize
+	for _, cell := range r.cells {
+		if cell.Style.fontSizeOverride != nil {
+			mfs = max(mfs, *cell.Style.fontSizeOverride)
+		}
+	}
+	return mfs
+}
+
+func (b *TableBuilder) Widths(v ...string) *TableBuilder {
+	b.columnWidths = &v
+	return b
+}
+
+func (b *TableBuilder) DefaultStyle(s TableCellStyleOpt) *TableBuilder {
+	b.defaultCellStyle = &s
+	return b
+}
+
+func (b *TableBuilder) PadX(v float64) *TableBuilder {
+	b.padx = v
+	return b
+}
+
+func (b *TableBuilder) PadY(v float64) *TableBuilder {
+	b.pady = v
+	return b
+}
+
+func (b *TableBuilder) AddRow(cells ...TableCell) {
+	b.rows = append(b.rows, tableRow{cells: cells})
+}
+
+func (b *TableBuilder) AddRowWithStyle(style TableCellStyleOpt, cells ...string) {
+	tcels := make([]TableCell, 0, len(cells))
+	for _, cell := range cells {
+		tcels = append(tcels, TableCell{Content: cell, Style: style})
+	}
+
+	b.rows = append(b.rows, tableRow{cells: tcels})
+}
+
+func (b *TableBuilder) AddRowDefaultStyle(cells ...string) {
+	tcels := make([]TableCell, 0, len(cells))
+	for _, cell := range cells {
+		tcels = append(tcels, TableCell{Content: cell, Style: langext.Coalesce(b.defaultCellStyle, TableCellStyleOpt{})})
+	}
+
+	b.rows = append(b.rows, tableRow{cells: tcels})
+}
+
+func (b *TableBuilder) Build() {
+	builder := b.builder
+
+	if len(b.rows) == 0 {
+		return // nothing to do
+	}
+
+	_, pageHeight := builder.FPDF().GetPageSize()
+	pbEnabled, pbMargin := builder.FPDF().GetAutoPageBreak()
+
+	builder.FPDF().SetAutoPageBreak(false, 0) // manually handle pagebreak in tables
+	defer func() { builder.FPDF().SetAutoPageBreak(pbEnabled, pbMargin) }()
+
+	columnWidths := b.calculateColumns()
+
+	columnCount := len(columnWidths)
+
+	for i, dat := range b.rows {
+		if len(dat.cells) != columnCount {
+			builder.FPDF().SetError(exerr.New(exerr.TypeInternal, "data must have the same length as header").Int("idx", i).Build())
+			return
+		}
+	}
+
+	defaultFontSize, _ := builder.FPDF().GetFontSize()
+
+	for rowIdx, row := range b.rows {
+		nextY := builder.GetY()
+		for cellIdx, cell := range row.cells {
+
+			str := cell.Content
+			style := cell.Style
+
+			ellipsize := langext.Coalesce(style.Ellipsize, true)
+			cellPaddingHorz := langext.Coalesce(style.PaddingHorz, 2)
+
+			bx := builder.GetX()
+			by := builder.GetY()
+
+			cellWidth := columnWidths[cellIdx]
+
+			if langext.Coalesce(style.MultiCell, true) {
+
+				builder.MultiCell(str, style.PDFCellOpt.Copy().ToMulti().Width(cellWidth))
+
+			} else {
+
+				if ellipsize {
+					if builder.GetStringWidth(str, style.PDFCellOpt) > (cellWidth - cellPaddingHorz) {
+						for builder.GetStringWidth(str+"...", style.PDFCellOpt) > (cellWidth-cellPaddingHorz) && len(str) > 0 {
+							str = str[:len(str)-1]
+						}
+						str += "..."
+					}
+				}
+
+				builder.Cell(str, style.PDFCellOpt.Copy().Width(cellWidth))
+
+			}
+
+			nextY = max(nextY, builder.GetY())
+			builder.SetXY(bx+cellWidth+b.padx, by)
+		}
+		builder.SetY(nextY + b.pady)
+
+		if rowIdx < len(b.rows)-1 && pbEnabled && (builder.GetY()+b.rows[rowIdx+1].maxFontSize(defaultFontSize)) > (pageHeight-pbMargin) {
+			builder.FPDF().AddPage()
+		}
+	}
+
+}
+
+func (b *TableBuilder) calculateColumns() []float64 {
+	pageWidthTotal, _ := b.builder.FPDF().GetPageSize()
+	marginLeft, _, marginRight, _ := b.builder.FPDF().GetMargins()
+	pageWidth := pageWidthTotal - marginLeft - marginRight
+
+	columnDef := make([]string, 0)
+
+	if b.columnWidths != nil {
+		columnDef = *b.columnWidths
+	} else if len(b.rows) > 0 {
+		columnDef = make([]string, len(b.rows[0].cells))
+		for i := range columnDef {
+			columnDef[i] = "*"
+		}
+	} else {
+		return []float64{}
+	}
+
+	columnWidths := make([]float64, len(columnDef))
+
+	frColumnWidthCount := 0
+	frColumnWeights := make([]float64, len(columnDef))
+	remainingWidth := pageWidth - (float64(len(columnDef)-1) * b.padx)
+	autoWidths := make([]float64, len(columnDef))
+
+	for colIdx := range columnDef {
+		w := float64(0)
+		for _, row := range b.rows {
+			if len(row.cells) > colIdx {
+				w = max(w, b.builder.GetStringWidth(row.cells[colIdx].Content, row.cells[colIdx].Style.PDFCellOpt))
+			}
+		}
+		autoWidths[colIdx] = w
+	}
+
+	for colIdx, col := range columnDef {
+
+		maxPadHorz := float64(0)
+
+		minWidth := float64(0)
+		for _, row := range b.rows {
+			if len(row.cells) > colIdx {
+
+				ph := langext.Coalesce(row.cells[colIdx].Style.PaddingHorz, 2)
+				mw := langext.Coalesce(row.cells[colIdx].Style.MinWidth, 0)
+
+				minWidth = max(minWidth, ph+mw)
+
+				maxPadHorz = max(maxPadHorz, ph)
+			}
+		}
+
+		if col == "auto" {
+
+			w := max(autoWidths[colIdx]+maxPadHorz, minWidth)
+
+			columnWidths[colIdx] = w
+			remainingWidth -= w
+
+		} else if match, ok := regexTableColumnSpecFr.MatchFirst(col); ok {
+
+			if match.GroupByName("num").Value() == "" {
+				w := minWidth
+
+				frColumnWidthCount += 1
+				frColumnWeights[colIdx] = 1
+				columnWidths[colIdx] = w
+				remainingWidth -= w
+			} else {
+				w := minWidth
+
+				n, _ := strconv.Atoi(match.GroupByName("num").Value())
+				frColumnWidthCount += n
+				frColumnWeights[colIdx] = float64(n)
+				columnWidths[colIdx] = w
+				remainingWidth -= w
+			}
+
+		} else {
+
+			if w, err := strconv.ParseFloat(col, 64); err == nil {
+				w = max(w, minWidth)
+
+				columnWidths[colIdx] = w
+				remainingWidth -= w
+			} else {
+				b.builder.FPDF().SetError(exerr.New(exerr.TypeInternal, "invalid column width").Str("width", col).Build())
+				w = max(w, minWidth)
+
+				columnWidths[colIdx] = w
+				remainingWidth -= w
+				return nil
+			}
+
+		}
+	}
+
+	if remainingWidth < 0 {
+		// no remaining space to distribute
+		return columnWidths
+	}
+
+	for i, _ := range columnDef {
+		if frColumnWeights[i] != 0 {
+			w := min(autoWidths[i], (remainingWidth/float64(frColumnWidthCount))*frColumnWeights[i])
+			remainingWidth += columnWidths[i]
+			columnWidths[i] = w
+			remainingWidth -= w
+		}
+	}
+
+	if remainingWidth > 0 {
+		for i, _ := range columnDef {
+			if frColumnWeights[i] != 0 {
+				addW := (remainingWidth / float64(frColumnWidthCount)) * frColumnWeights[i]
+				columnWidths[i] += addW
+				remainingWidth -= addW
+			}
+		}
+	}
+
+	return columnWidths
+}
+
+func (b *TableBuilder) RowCount() int {
+	return len(b.rows)
+}
+
+func (b *WPDFBuilder) Table() *TableBuilder {
+	return &TableBuilder{
+		builder:          b,
+		rows:             make([]tableRow, 0),
+		pady:             2,
+		padx:             2,
+		defaultCellStyle: defaultTableStyle(),
+	}
+}
+
+func defaultTableStyle() *TableCellStyleOpt {
+	return &TableCellStyleOpt{
+		PDFCellOpt: *NewPDFCellOpt().
+			FontSize(float64(8)).
+			BorderColorHex(uint32(0x888888)).
+			FillColorHex(uint32(0xFFFFFF)).
+			TextColorHex(uint32(0x000000)).
+			FillBackground(false),
+		MinWidth:  langext.Ptr(float64(5)),
+		Ellipsize: langext.PTrue,
+		MultiCell: langext.PFalse,
+	}
+}