seguims con los errores

app/descartados/erfmt/ftext/active.go

@@ -101,7 +101,7 @@ func DefaultFormatter () *ErrTextFormatter {
 			}),
 			WithSectionFormat(CauseSection, func (sec *SectionFormat) {
 				sec.BuildBefore = func (b fmts.Builder) {
-					b.AddText("- Prev Cause ---------------")
+					b.AddText("- Prev Causes ---------------")
 				}
 			}),
 			WithSectionFormat(TraceSection, func (sec *SectionFormat) {

app/descartados/errse/fmt_text.go

@@ -142,7 +142,7 @@ func (f *FmtText) format (s *FmtTextState, err error, head bool) {
 	if c := UnwrapCause(err); c != nil {
 		s.writeString("-Previous-----------------------------------------\n",[]FormatColor{FormatColorCyan})
 		s.IncLevel()
-		f.format(s,c.Cause(),true)
+		f.format(s,c.Causes(),true)
 		s.DecLevel()
 	}
 

core/errs/active.go

@@ -60,7 +60,7 @@ var (
 		ErrParamNil			: ErrCode(CodeParamNilError),
 		ErrParamOutOfRange	: ErrCode(CodeParamOutOfRangeError),
 
-		Formatter 			: ftext.NewFormatter(),//err_text_fmt.DefaultFormatter(),
+		Formatter 			: ftext.DefaultFormatter(),
 	}
 
 	g = struct {

core/errs/efmt/err_text_fmt/active.go

@@ -36,7 +36,7 @@ const (
 
 	fbBuildError  string = "Error building error format for type '%v'. Check formatter configuration or consider handling unsupported error types gracefully. Error: %s"
 	fbUnwrapError string = "Error building error from wrapped error. Encountered type '%v'. Consider handling this type explicitly or providing a generic fallback message. Error: %s"
-	fbCauseError  string = "Error formatting Cause error. Encountered type '%v'. Review formatter logic for handling Cause errors or provide a generic fallback message. Error: %s"
+	fbCauseError  string = "Error formatting Causes error. Encountered type '%v'. Review formatter logic for handling Causes errors or provide a generic fallback message. Error: %s"
 
 )
 
@@ -53,12 +53,12 @@ var (
 
 func DefaultFormatter () *TextFormatter {
 	G.buildDefault.Do(func() {
-		//c := Ansi.Code(0).SetFgColor(Ansi.ColorHWhite).SetBgColor(Ansi.ColorHRed).SetStyle(Ansi.StyleBold)
+		//c := ansiC.Code(0).SetFgColor(ansiC.ColorHWhite).SetBgColor(ansiC.ColorHRed).SetStyle(ansiC.StyleBold)
 		G.fmtDefault = NewTextFormatter(
 			WithSectionsFormat(func (c *SectionsConfig) {
 				c.Head.Ansi = ansi.Code(0).SetFgColor(ansi.ColorRed).SetStyle(ansi.StyleBold)
 				c.Cause.Before = func(b efmt.Builder){
-					b.AddText("Prev Cause --------------------------------------------")}
+					b.AddText("Prev Causes --------------------------------------------")}
 				c.Cause.Ansi = ansi.Code(0).SetFgColor(ansi.ColorRed)
 				c.Trace.Before = func(b efmt.Builder){
 					b.AddText("Stack Trace Information -------------------------------")}

core/errs/efmt/err_text_fmt/section.go

@@ -40,6 +40,8 @@ type (
 
 )
 
+func (s *SectionConfig) SetBefore
+
 
 func (s *SectionConfig) doBefore (b efmt.Builder) {
 	if s != nil && s.Before != nil {

core/errs/err_info.go

@@ -117,12 +117,12 @@ func (e ErrInfo) BuildFormat (builder efmt.Builder) {
 
 func (e ErrInfo) Format (builder fmtr.Builder) {
 	builder.Build(e.Error(),"core.errs.ErrInfo",func (fb fmtr.FieldBuilder){
-		fb.AddString("message",e.message)
+		fb.AddFieldString("message",e.message)
-		fb.AddString("info",e.info)
+		fb.AddFieldString("info",e.info)
-		fb.AddDate  ("date",e.date)
+		fb.AddFieldDate("date",e.date)
 		if len(e.metas) > 0 {
 			for n,v := range e.metas {
-				fb.AddString(n,v)
+				fb.AddFieldString(n,v)
 			}
 		}
 	})

core/errs/err_param.go

@@ -90,6 +90,6 @@ func (e ErrParam) BuildFormat (builder efmt.Builder) {
 func (e ErrParam) Format (builder fmtr.Builder) {
 	builder.Build(e.Error(),"core.errs.ErrParam",func (fb fmtr.FieldBuilder){
 		if len(e.message) > 0 && e.message != e.Error() {
-			fb.AddString(fmtr.FieldNameMessage,e.message)
+			fb.AddFieldString(fmtr.FieldNameMessage,e.message)
 		}
 	}) }

core/errs/fmtr/err_builder.go

@@ -91,7 +91,7 @@ func (e ErrBuilder) StackTrace () stack.Trace {
 func (e ErrBuilder) BuildFormat (builder Builder) {
 	builder.Build(e.Error(),"core.errs.efmtr.ErrBuilder",func (fb FieldBuilder){
 		if len(e.message) > 0 {
-			fb.AddString(FieldNameMessage,e.message)
+			fb.AddFieldString(FieldNameMessage,e.message)
 		}
 	})
 }

core/errs/fmtr/field_builder.go

@@ -28,13 +28,13 @@ import "time"
 type (
 
 	FieldBuilder interface {
-		AddAny   (name string, value any	)
+		AddFieldAny   (name string, value any	 )
-		AddInt   (name string, value int    )
+		AddFieldInt   (name string, value int    )
-		AddBool  (name string, value bool   )
+		AddFieldBool  (name string, value bool   )
-		AddString(name string, value string )
+		AddFieldString(name string, value string )
-		AddFloat (name string, value float64)
+		AddFieldFloat (name string, value float64)
-		AddTime  (name string, value time.Time)
+		AddFieldTime  (name string, value time.Time)
-		AddDate  (name string, value time.Time)
+		AddFieldDate  (name string, value time.Time)
 	}
 
 	BuildFieldFnc func (builder FieldBuilder)
@@ -44,28 +44,28 @@ type (
 
 func AddAny(name string, value any) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddAny(name,value) }}
+		b.AddFieldAny(name,value) }}
 
 func AddString(name, value string) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddString(name,value) }}
+		b.AddFieldString(name,value) }}
 
 func AddInt  (name string, value int) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddInt(name,value) }}
+		b.AddFieldInt(name,value) }}
 
 func AddFloat(name string, value float64) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddFloat(name,value) }}
+		b.AddFieldFloat(name,value) }}
 
 func AddBool (name string, value bool) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddBool(name,value) }}
+		b.AddFieldBool(name,value) }}
 
 func AddTime (name string, value time.Time) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddTime(name,value) }}
+		b.AddFieldTime(name,value) }}
 
 func AddDate (name string, value time.Time) BuildFieldFnc {
 	return func(b FieldBuilder) {
-		b.AddDate(name,value) }}
+		b.AddFieldDate(name,value) }}

core/errs/fmtr/ftext/active.go

@@ -23,4 +23,68 @@
 
 package ftext
 
+import (
+	"ansi"
+	"fmt"
+	"sync"
+)
 
+var (
+
+	g = struct {
+		buildDefault sync.Once
+		formatter    *TextFormatter
+	}{
+
+	}
+)
+
+
+func DefaultFormatter () *TextFormatter {
+	g.buildDefault.Do(func() {
+
+		g.formatter = NewTextFormatter(
+			WithSectionsFormat(func(c *Sections){
+
+		    	c.Main.Set(0,
+					func (b *TextBuilder){
+						c := ansi.Code(0).SetFgColor(ansi.ColorHRed).SetStyle(ansi.StyleBold)
+						b.AddText(c.Sprint("# ERROR #####################################################\n"))
+					},
+					nil)
+
+				c.Head.Set(ansi.Code(0).SetFgColor(ansi.ColorHRed),nil,nil)
+
+				c.Fields.Set(ansi.Code(0).SetFgColor(ansi.ColorGreen),
+					func(b *TextBuilder) {
+
+					},
+					nil)
+
+				c.Causes.Set(ansi.Code(0).SetFgColor(ansi.ColorCyan),
+					func(b *TextBuilder){
+						a := ansi.Code(0).SetStyle(ansi.StyleBold)
+						b.AddText(a.Sprint("* Prev Causes ***********************************************\n"))
+					},
+					func(b *TextBuilder){
+						a := ansi.Code(0).SetStyle(ansi.StyleBold)
+						b.AddText(a.Sprint("*************************************************************\n"))
+					})
+
+				c.Cause.Set(ansi.Code(0).SetFgColor(ansi.ColorCyan),
+					func(b *TextBuilder) {
+						b.AddText(fmt.Sprintf("-- %d --------------------------------------------------------\n",b.Level()))
+					},
+					nil)
+
+				c.Trace.Set(ansi.Code(0).SetFgColor(ansi.ColorHYellow),
+					func(b *TextBuilder){
+						a := b.ansiC.SetStyle(ansi.StyleBold)
+						b.AddText(a.Sprint("* Stack Trace ***********************************************\n"))
+					},
+					nil)
+			}),
+		)
+	})
+	return g.formatter
+}

core/errs/fmtr/ftext/builder.go

@@ -0,0 +1,308 @@
+// ------------------------------------------------------------------------
+//   Project active2
+//   Active Thing (activething.com) git.activething.com/go
+//
+//   File name  formatter_stae.go
+//   Created by DEV
+//   Modified   16/04/2024
+//
+//   Copyright 2024 activething.com 
+// ------------------------------------------------------------------------
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+package ftext
+
+import (
+	"ansi"
+	"bytes"
+	"errors"
+	"errs/fmtr"
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+)
+
+type (
+
+	TextBuilder 	struct {
+		f 			*TextFormatter
+		b 			bytes.Buffer
+
+		numFields 	int
+		indent 		string
+		level 		int
+		ansiC 	 	ansi.Code
+		unwrap 		bool
+	}
+
+
+	TextBuilderFnc func (s *TextBuilder)
+)
+
+
+func newTextBuilder(formatter *TextFormatter) *TextBuilder {
+	return &TextBuilder{
+		f  	  : formatter,
+	}
+}
+
+
+func (s *TextBuilder) Indent() string {
+	return s.indent }
+
+func (s *TextBuilder) Level () int {
+	return s.level }
+
+func (s *TextBuilder) Ansi  () ansi.Code {
+	return s.ansiC }
+
+
+func (s *TextBuilder) AddText (text string) {
+	s.b.WriteString(s.ansiC.String())
+	s.b.WriteString(text)
+	s.b.WriteString(s.ansiC.End())
+}
+
+
+
+func (s *TextBuilder) AddFieldAny(name string, value any	 ) {
+	if value == nil && s.f.NotShowEmpty() {
+		return
+	}
+}
+
+func (s *TextBuilder) AddFieldInt(name string, value int    ) {
+	s.writeField(name,fmt.Sprintf(s.f.layouts.intLayout,value))}
+
+func (s *TextBuilder) AddFieldBool(name string, value bool   ) {
+	s.writeField(name,fmt.Sprintf(s.f.layouts.boolLayout)) }
+
+func (s *TextBuilder) AddFieldString(name string, value string ) {
+	if len(value) == 0 && s.f.NotShowEmpty() {
+		return
+	}
+	s.writeField(name,value) }
+
+func (s *TextBuilder) AddFieldFloat(name string, value float64) {
+	s.writeField(name,fmt.Sprintf(s.f.layouts.floatLayout,value)) }
+
+func (s *TextBuilder) AddFieldTime(name string, value time.Time) {
+	if value.IsZero() && s.f.NotShowEmpty() {
+		return
+	}
+	s.writeField(name,value.Format(s.f.layouts.timeLayout)) }
+
+func (s *TextBuilder) AddFieldDate(name string, value time.Time) {
+	if value.IsZero() && s.f.NotShowEmpty() {
+		return
+	}
+	s.writeField(name,value.Format(s.f.layouts.dateLayout)) }
+
+
+
+
+func (s *TextBuilder) Build(errCode, errType string, fbuilder fmtr.BuildFieldFnc) {
+	if !s.unwrap {
+		if s.level == 0 {
+			s.f.sections.Head.begin(s)
+		}
+		s.writeField(fmtr.FieldNameError,errCode)
+		if s.f.ShowType() {
+			s.writeField(fmtr.FieldNameType, errType)
+		}
+		if s.level == 0	{
+			s.f.sections.Head.end(s)
+		}
+	}
+	if fbuilder != nil {
+		if s.level == 0 {
+			s.f.sections.Fields.begin(s)
+		}
+		fbuilder(s)
+	}
+}
+
+
+
+
+func (s *TextBuilder) format (err error) (fe error) {
+
+	s.f.sections.Main.begin(s)
+
+	if fe = s.addError(err); fe != nil {
+		return fe
+	}
+
+	if s.numFields > 0 {
+		s.f.sections.Fields.end(s)
+	}
+
+	if s.f.ShowCause() {
+		s.f.sections.Causes.begin(s)
+		if fe = s.addCause(err); fe != nil {
+			//todo
+		}
+		s.f.sections.Causes.end(s)
+	}
+
+	if s.f.ShowTrace() {
+		s.f.sections.Trace.begin(s)
+		s.f.sections.Trace.end(s)
+	}
+
+	s.f.sections.Main.end(s)
+
+	return
+}
+
+
+
+
+func (s *TextBuilder) addError(err error) (fe error) {
+	if err == nil {
+		return
+	}
+
+
+	if eb,is := err.(fmtr.Formattable); is {
+		eb.Format(s)
+	} else {
+		rt := reflect.TypeOf(err)
+		if rt.Kind() == reflect.Pointer {
+			rt = rt.Elem()
+		}
+		eb := fmtr.GetErrorTypeBuilder(rt)
+		if eb != nil {
+			eb.BuildError(s,err)
+			return
+		}
+
+		eb = fmtr.MakeErrorTypeBuilder(s,err)
+		fmtr.SetErrorTypeBuilder(rt,eb)
+	}
+
+	if !s.unwrap {
+		s.unwrap = true
+	}
+	if fe = s.addError(errors.Unwrap(err)); fe != nil {
+		//todo
+		return fe
+	}
+
+	s.unwrap = false
+
+	return fe
+}
+
+
+
+
+func (s *TextBuilder) addCause(err error) (fe error) {
+	ls := getCauses(err)
+	for _,ce := range ls {
+		s.incLevel()
+		s.f.sections.Cause.begin(s)
+		if fe = s.addError(ce); fe != nil {
+			//todo
+			continue
+		}
+		if fe = s.addCause(ce); fe != nil {
+			//todo
+		}
+		s.f.sections.Cause.end(s)
+		s.decLevel()
+	}
+	return
+}
+
+
+
+func getCauses (err error) []error {
+	ne := err
+	for ne != nil {
+		if cs, is := ne.(interface{ Cause() error }); is {
+			ce := cs.Cause()
+			if ce == nil {
+				return nil
+			}
+			return []error{ce}
+		}
+		if cs, is := ne.(interface{ Causes() []error }); is {
+			return cs.Causes()
+		}
+		if cs, is := ne.(interface{ Unwrap() []error }); is {
+			return cs.Unwrap()
+		}
+		ne = errors.Unwrap(ne)
+	}
+	return nil
+}
+
+
+
+
+
+func (s *TextBuilder) setAnsi(ansiC ansi.Code) {
+	if ansiC != 0 {
+		s.ansiC = ansiC
+	} else {
+		s.ansiC = s.f.ansiC
+	}
+}
+
+
+
+func (s *TextBuilder) writeField (name string, value string) {
+	s.numFields++
+
+	n := s.f.nameTrans.Apply(name)
+	v := s.f.valueTrans.Apply(value)
+
+	if s.ansiC != 0 {
+		s.b.WriteString(s.ansiC.String())
+	}
+	s.b.WriteString(s.indent)
+	s.b.WriteString(n)
+	s.b.WriteString(s.f.sep)
+	s.b.WriteString(v)
+	s.b.WriteByte('\n')
+
+	if s.ansiC != 0 {
+		s.b.WriteString(s.ansiC.String())
+	}
+}
+
+
+
+
+func (s *TextBuilder) incLevel () {
+	s.level++
+	if s.f.ShowIndent() {
+		s.indent = strings.Repeat(s.f.indent,s.level)
+	}
+}
+
+func (s *TextBuilder) decLevel () {
+	s.level--
+	if s.f.ShowIndent() && s.level > 0 {
+		s.indent = strings.Repeat(s.f.indent,s.level)
+	}
+}
+
+
+
+
+
+

core/errs/fmtr/ftext/formatter.go

@@ -23,31 +23,44 @@
 
 package ftext
 
-import "atypes/astrings"
+import (
+	"ansi"
+	"atypes/astrings"
+	"errs/stack"
+)
 
 type (
 
 
-	Formatter 		struct {
+	TextFormatter 		struct {
 		option
 
-		lays 		layouts
+		ansiC 			ansi.Code
-		secs 		Sections
+		indent 			string
+		sep 			string
+
+		layouts  		layouts
+		sections 		Sections
 
-		nameTrans ,
+		nameTrans 		astrings.Transformers
-		valueTrans,
+		valueTrans		astrings.Transformers
-		stringTrans astrings.Transformers
 
+		frameBuilder 	func (builder *TextBuilder, frame stack.Frame, num int)
 	}
 
-	FormatterFnc 	func (formatter *Formatter)
+	TextFormatterFnc func (formatter *TextFormatter)
 )
 
 
-func NewFormatter (options ...FormatterFnc) *Formatter {
+func NewTextFormatter(options ...TextFormatterFnc) *TextFormatter {
-	fm := &Formatter {
+	fm := &TextFormatter{
-		option: optionsDefault,
+		option	: optionsDefault,
-		lays: *newLayouts(),
+		indent  : " ",
+		sep   	: " : ",
+		layouts	: *newLayouts(),
+	}
+	for _,o := range options {
+		o(fm)
 	}
 	return fm
 }
@@ -55,9 +68,9 @@ func NewFormatter (options ...FormatterFnc) *Formatter {
 
 
 
-func (f *Formatter) FormatError (err error) []byte {
+func (f *TextFormatter) FormatError (err error) []byte {
 
-	s := newState(f)
+	s := newTextBuilder(f)
 	if fe := s.format(err); fe != nil {
 
 	}
@@ -65,3 +78,10 @@ func (f *Formatter) FormatError (err error) []byte {
 	return s.b.Bytes()
 }
 
+
+
+
+
+func WithSectionsFormat(config SectionsFnc) TextFormatterFnc {
+	return func(f *TextFormatter) {
+		config(&f.sections) } }

core/errs/fmtr/ftext/layouts.go

@@ -30,8 +30,6 @@ import (
 type (
 
 	layouts 		struct {
-		sep 		string
-		indent 		string
 		timeLayout 	string
 		dateLayout 	string
 		intLayout 	string
@@ -44,8 +42,6 @@ type (
 
 func newLayouts () *layouts {
 	return &layouts{
-		indent     	: " ",
-		sep   		: " : ",
 		timeLayout 	: time.RFC822Z,
 		dateLayout 	: time.RFC822Z,
 		intLayout  	: "%d",

core/errs/fmtr/ftext/section.go

@@ -27,19 +27,32 @@ import "ansi"
 
 type (
 
-	Section 	struct {
+	section 	struct {
-		Ansi 	ansi.Code
+		ansiC   ansi.Code
+		beginFn func(textBuilder *TextBuilder)
+		endFn   func(textBuilder *TextBuilder)
 	}
 
 
 )
 
 
-func (s Section) Begin () {
+func (s *section) Set(ansiC ansi.Code, beginFn, endFn TextBuilderFnc) {
+	s.ansiC = ansiC
+	s.beginFn,s.endFn = beginFn,endFn }
 
-}
 
-func (s Section) End  () {
+func (s *section) begin(txtBuilder *TextBuilder) {
+	txtBuilder.setAnsi(s.ansiC)
+	if s.beginFn != nil {
+		s.beginFn(txtBuilder)
+	}
+}
 
+func (s *section) end(txtBuilder *TextBuilder) {
+	txtBuilder.setAnsi(s.ansiC)
+	if s.endFn != nil {
+		s.endFn(txtBuilder)
+	}
 }
 

core/errs/fmtr/ftext/sections.go

@@ -27,12 +27,18 @@ package ftext
 type (
 
 	Sections 	struct {
-		Main 	Section
+		Main   section
-		Head 	Section
+		Head   section
-		Fields 	Section
+		Fields section
-		Cause 	Section
+		Causes section
-		Trace 	Section
+		Cause  section
+		Trace  section
 	}
+
+
+	SectionsFnc func(secs *Sections)
 )
 
 
+
+

core/errs/fmtr/ftext/state.go

@@ -1,279 +0,0 @@
-// ------------------------------------------------------------------------
-//   Project active2
-//   Active Thing (activething.com) git.activething.com/go
-//
-//   File name  formatter_stae.go
-//   Created by DEV
-//   Modified   16/04/2024
-//
-//   Copyright 2024 activething.com 
-// ------------------------------------------------------------------------
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ------------------------------------------------------------------------
-
-package ftext
-
-import (
-	"ansi"
-	"bytes"
-	"errors"
-	"errs/fmtr"
-	"fmt"
-	"reflect"
-	"strings"
-	"time"
-)
-
-type (
-
-	state struct {
-		f 			*Formatter
-		b 			bytes.Buffer
-
-		section 	*Section
-		level 		int
-		ansiC 	 	ansi.Code
-		unwrap 		bool
-	}
-)
-
-
-func newState(formatter *Formatter) *state {
-	return &state{
-		f  	  : formatter,
-	}
-}
-
-
-func (s *state) format (err error) (fe error) {
-
-	if fe = s.wError(err,0); fe != nil {
-		return fe
-	}
-
-	if fe = s.wCause(err,0); fe != nil {
-
-	}
-
-	return
-}
-
-
-
-func (s *state) wError (err error, level int) (fe error) {
-	if err == nil {
-		return
-	}
-
-	if s.level != level && !s.unwrap {
-		ol := s.level
-		s.level = level
-		defer func(){ s.level = ol }()
-	}
-
-	if eb,is := err.(fmtr.Formattable); is {
-		eb.Format(s)
-	} else {
-		rt := reflect.TypeOf(err)
-		if rt.Kind() == reflect.Pointer {
-			rt = rt.Elem()
-		}
-		eb := fmtr.GetErrorTypeBuilder(rt)
-		if eb != nil {
-			eb.BuildError(s,err)
-			return
-		}
-
-		eb = fmtr.MakeErrorTypeBuilder(s,err)
-		fmtr.SetErrorTypeBuilder(rt,eb)
-	}
-
-	if !s.unwrap {
-		s.unwrap = true
-	}
-	if fe = s.wError(errors.Unwrap(err), level); fe != nil {
-
-		return fe
-	}
-
-	s.unwrap = false
-
-	return fe
-}
-
-func (s *state) wCause(err error, level int ) (fe error){
-	nx := err
-	for nx != nil {
-
-		if cs, is := nx.(interface{ Cause() error }); is {
-			if ce := cs.Cause(); ce != nil {
-				s.b.WriteString("-Prev Cause --------------------\n")
-				if fe := s.wError(ce, level+1); fe != nil {
-					// llamamos al fallback del formateador
-				}
-				nx = errors.Unwrap(ce)
-				continue
-			}
-		}
-
-		var lc []error
-		if cs, is := nx.(interface{ Causes() []error }); is {
-			lc = cs.Causes()
-		} else if me, ok := nx.(interface{ Unwrap() []error }); ok {
-			lc = me.Unwrap()
-		}
-		if len(lc) > 0 {
-			for i, e := range lc {
-				s.b.WriteString(fmt.Sprintf("-%d---------------\n",i))
-				if fe = s.wError(e,level+1); fe != nil {
-					// llamamos al fallback del formateado
-				}
-				if fe = s.wCause(e,level+1); fe != nil {
-
-				}
-			}
-			return
-		}
-
-		nx = errors.Unwrap(nx)
-	}
-	return
-}
-
-
-
-
-
-func getCauses (err error) []error {
-	if err == nil {
-		return nil
-	}
-	if cs,is := err.(interface { Cause() error }); is  {
-		ce := cs.Cause()
-		if ce == nil {
-			return nil
-		}
-		return []error{ce}
-	}
-
-	if cs,is := err.(interface { Causes() []error }); is {
-		return cs.Causes()
-	}
-	if cs,is := err.(interface{ Unwrap() []error }); is {
-		return cs.Unwrap()
-	}
-	return nil
-}
-
-
-
-
-func (s *state) applySection (sec *Section, begin bool) {
-	if begin {
-		s.section = sec
-		s.section.Begin()
-	}
-
-}
-
-
-func (s *state) indent () string {
-	if s.level == 0 {
-		return ""
-	}
-	return strings.Repeat(s.f.lays.indent,s.level)
-}
-
-
-func (s *state) Build(errCode, errType string, fbuilder fmtr.BuildFieldFnc) {
-	if !s.unwrap {
-		s.applySection(&s.f.secs.Head,true)
-		s.writeField(fmtr.FieldNameError,errCode)
-		if s.f.ShowType() {
-			s.writeField(fmtr.FieldNameType, errType)
-		}
-		s.applySection(&s.f.secs.Head,false)
-	}
-	if fbuilder != nil {
-		s.applySection(&s.f.secs.Fields,true)
-		fbuilder(s)
-	}
-}
-
-
-func (s *state) AddAny   (name string, value any	 ) {
-	if value == nil && s.f.NotShowEmpty() {
-		return
-	}
-}
-
-func (s *state) AddInt   (name string, value int    ) {
-	s.writeField(name,fmt.Sprintf(s.f.lays.intLayout,value))}
-
-func (s *state) AddBool  (name string, value bool   ) {
-	s.writeField(name,fmt.Sprintf(s.f.lays.boolLayout)) }
-
-func (s *state) AddString(name string, value string ) {
-	if len(value) == 0 && s.f.NotShowEmpty() {
-		return
-	}
-	s.writeField(name,value) }
-
-func (s *state) AddFloat (name string, value float64) {
-	s.writeField(name,fmt.Sprintf(s.f.lays.floatLayout,value)) }
-
-func (s *state) AddTime  (name string, value time.Time) {
-	if value.IsZero() && s.f.NotShowEmpty() {
-		return
-	}
-	s.writeField(name,value.Format(s.f.lays.timeLayout)) }
-
-func (s *state) AddDate  (name string, value time.Time) {
-	if value.IsZero() && s.f.NotShowEmpty() {
-		return
-	}
-	s.writeField(name,value.Format(s.f.lays.dateLayout)) }
-
-
-
-func (s *state) writeField (name string, value string) {
-
-	n := s.f.nameTrans.Apply(name)
-	v := s.f.valueTrans.Apply(value)
-
-	s.b.WriteString(s.indent())
-	if s.ansiC == 0 {
-		s.b.WriteString(n)
-		s.b.WriteString(s.f.lays.sep)
-		s.b.WriteString(v)
-		s.b.WriteByte('\n')
-		return
-	}
-
-	s.b.WriteString(s.ansiC.String())
-	s.b.WriteString(n)
-	s.b.WriteString(s.f.lays.sep)
-	s.b.WriteString(v)
-	s.b.WriteByte('\n')
-	s.b.WriteString(s.ansiC.End())
-}
-
-
-
-
-
-
-
-
-
-