Merge branch 'main' into dev

2025-06-21 18:31:24 +02:00 · 2025-03-29 18:01:15 +00:00 · 2025-03-29 18:01:15 +00:00 · 7f0e9b3289
commit 7f0e9b3289
parent 9effff25df 9da7967158
8 changed files with 181 additions and 33 deletions
--- a/docs/configuration.md
+++ b/docs/configuration.md
@ -399,7 +399,7 @@ pages:
 | show-mobile-header | boolean | no | false |
 | columns | array | yes | |

-#### `title`
+#### `name`
 The name of the page which gets shown in the navigation bar.

 #### `slug`
@ -1340,6 +1340,7 @@ Examples:
 | body | any | no | |
 | frameless | boolean | no | false |
 | allow-insecure | boolean | no | false |
+| skip-json-validation | boolean | no | false |
 | template | string | yes | |
 | parameters | key (string) & value (string|array) | no | |
 | subrequests | map of requests | no | |
@ -1387,6 +1388,9 @@ When set to `true`, removes the border and padding around the widget.
 ##### `allow-insecure`
 Whether to ignore invalid/self-signed certificates.

+##### `skip-json-validation`
+When set to `true`, skips the JSON validation step. This is useful when the API returns JSON Lines/newline-delimited JSON, which is a format that consists of several JSON objects separated by newlines.
+
 ##### `template`
 The template that will be used to display the data. It relies on Go's `html/template` package so it's recommended to go through [its documentation](https://pkg.go.dev/text/template) to understand how to do basic things such as conditionals, loops, etc. In addition, it also uses [tidwall's gjson](https://github.com/tidwall/gjson) package to parse the JSON data so it's worth going through its documentation if you want to use more advanced JSON selectors. You can view additional examples with explanations and function definitions [here](custom-api.md).

--- a/docs/custom-api.md
+++ b/docs/custom-api.md
@ -226,10 +226,10 @@ JSON response:
 }
 ```

-Calculations can be performed, however all numbers must be converted to floats first if they are not already:
+Calculations can be performed on either ints or floats. If both numbers are ints, an int will be returned, otherwise a float will be returned. If you try to divide by zero, 0 will be returned. If you provide non-numeric values, `NaN` will be returned.

 ```html
-<div>{{ sub (.JSON.Int "price" | toFloat) (.JSON.Int "discount" | toFloat) }}</div>
+<div>{{ sub (.JSON.Int "price") (.JSON.Int "discount") }}</div>
 ```

 Output:
@ -309,6 +309,55 @@ You can also access the response headers:
 <div>{{ .Response.Header.Get "Content-Type" }}</div>
 ```

+<hr>
+
+JSON response:
+
+```json
+{"name": "Steve", "age": 30}
+{"name": "Alex", "age": 25}
+{"name": "John", "age": 35}
+```
+
+The above format is "[ndjson](https://docs.mulesoft.com/dataweave/latest/dataweave-formats-ndjson)" or "[JSON Lines](https://jsonlines.org/)", where each line is a separate JSON object. To parse this format, you must first disable the JSON validation check in your config, since by default the response is expected to be a single valid JSON object:
+
+```yaml
+- type: custom-api
+  skip-json-validation: true
+```
+
+Then, to iterate over each object you can use `.JSONLines`:
+
+```html
+{{ range .JSONLines }}
+  <p>{{ .String "name" }} is {{ .Int "age" }} years old</p>
+{{ end }}
+```
+
+Output:
+
+```html
+<p>Steve is 30 years old</p>
+<p>Alex is 25 years old</p>
+<p>John is 35 years old</p>
+```
+
+For other ways of selecting data from a JSON Lines response, have a look at the docs for [tidwall/gjson](https://github.com/tidwall/gjson/tree/master?tab=readme-ov-file#json-lines). For example, to  get an array of all names, you can use the following:
+
+```html
+{{ range .JSON.Array "..#.name" }}
+  <p>{{ .String "" }}</p>
+{{ end }}
+```
+
+Output:
+
+```html
+<p>Steve</p>
+<p>Alex</p>
+<p>John</p>
+```
+
 ## Functions

 The following functions are available on the `JSON` object:
@ -325,6 +374,9 @@ The following helper functions provided by Glance are available:
 - `toFloat(i int) float`: Converts an integer to a float.
 - `toInt(f float) int`: Converts a float to an integer.
 - `toRelativeTime(t time.Time) template.HTMLAttr`: Converts Time to a relative time such as 2h, 1d, etc which dynamically updates. **NOTE:** the value of this function should be used as an attribute in an HTML tag, e.g. `<span {{ toRelativeTime .Time }}></span>`.
+- `now() time.Time`: Returns the current time.
+- `offsetNow(offset string) time.Time`: Returns the current time with an offset. The offset can be positive or negative and must be in the format "3h" "-1h" or "2h30m10s".
+- `duration(str string) time.Duration`: Parses a string such as `1h`, `24h`, `5h30m`, etc into a `time.Duration`.
 - `parseTime(layout string, s string) time.Time`: Parses a string into time.Time. The layout must be provided in Go's [date format](https://pkg.go.dev/time#pkg-constants). You can alternatively use these values instead of the literal format: "unix", "RFC3339", "RFC3339Nano", "DateTime", "DateOnly".
 - `parseRelativeTime(layout string, s string) time.Time`: A shorthand for `{{ .String "date" | parseTime "rfc3339" | toRelativeTime }}`.
 - `add(a, b float) float`: Adds two numbers.
@ -343,6 +395,7 @@ The following helper functions provided by Glance are available:
 - `sortByInt(key string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by an integer key in either ascending or descending order.
 - `sortByFloat(key string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by a float key in either ascending or descending order.
 - `sortByTime(key string, layout string, order string, arr []JSON): []JSON`: Sorts an array of JSON objects by a time key in either ascending or descending order. The format must be provided in Go's [date format](https://pkg.go.dev/time#pkg-constants).
+- `concat(strings ...string) string`: Concatenates multiple strings together.

 The following helper functions provided by Go's `text/template` are available:

--- a/docs/extensions.md
+++ b/docs/extensions.md
@ -26,6 +26,9 @@ If you know how to setup an HTTP server and a bit of HTML and CSS you're ready t
 ### `Widget-Title`
 Used to specify the title of the widget. If not provided, the widget's title will be "Extension".

+### `Widget-Title-URL`
+Used to specify the URL that will be opened when the widget's title is clicked. If the user has specified a `title-url` in their config, it will take precedence over this header.
+
 ### `Widget-Content-Type`
 Used to specify the content type that will be returned by the extension. If not provided, the content will be shown as plain text.

--- a/internal/glance/templates.go
+++ b/internal/glance/templates.go
@ -27,6 +27,9 @@ var globalTemplateFunctions = template.FuncMap{
 	"formatPrice": func(price float64) string {
 		return intl.Sprintf("%.2f", price)
 	},
+	"formatPriceWithPrecision": func(precision int, price float64) string {
+		return intl.Sprintf("%."+strconv.Itoa(precision)+"f", price)
+	},
 	"dynamicRelativeTimeAttrs": dynamicRelativeTimeAttrs,
 	"formatServerMegabytes": func(mb uint64) template.HTML {
 		var value string
--- a/internal/glance/templates/markets.html
+++ b/internal/glance/templates/markets.html
@ -17,7 +17,7 @@

        <div class="market-values shrink-0">
            <div class="size-h3 text-right {{ if eq .PercentChange 0.0 }}{{ else if gt .PercentChange 0.0 }}color-positive{{ else }}color-negative{{ end }}">{{ printf "%+.2f" .PercentChange }}%</div>
-            <div class="text-right">{{ .Currency }}{{ .Price | formatPrice }}</div>
+            <div class="text-right">{{ .Currency }}{{ .Price | formatPriceWithPrecision .PriceHint }}</div>
        </div>
    </div>
    {{ end }}
--- a/internal/glance/widget-custom-api.go
+++ b/internal/glance/widget-custom-api.go
@ -32,6 +32,7 @@ type CustomAPIRequest struct {
 	Method             string               `yaml:"method"`
 	BodyType           string               `yaml:"body-type"`
 	Body               any                  `yaml:"body"`
+	SkipJSONValidation bool                 `yaml:"skip-json-validation"`
 	bodyReader         io.ReadSeeker        `yaml:"-"`
 	httpRequest        *http.Request        `yaml:"-"`
 }
@ -157,6 +158,17 @@ type customAPITemplateData struct {
 	subrequests map[string]*customAPIResponseData
 }

+func (data *customAPITemplateData) JSONLines() []decoratedGJSONResult {
+	result := make([]decoratedGJSONResult, 0, 5)
+
+	gjson.ForEachLine(data.JSON.Raw, func(line gjson.Result) bool {
+		result = append(result, decoratedGJSONResult{line})
+		return true
+	})
+
+	return result
+}
+
 func (data *customAPITemplateData) Subrequest(key string) *customAPIResponseData {
 	req, exists := data.subrequests[key]
 	if !exists {
@ -190,7 +202,7 @@ func fetchCustomAPIRequest(ctx context.Context, req *CustomAPIRequest) (*customA

 	body := strings.TrimSpace(string(bodyBytes))

-	if body != "" && !gjson.Valid(body) {
+	if !req.SkipJSONValidation && body != "" && !gjson.Valid(body) {
 		truncatedBody, isTruncated := limitStringLength(body, 100)
 		if isTruncated {
 			truncatedBody += "... <truncated>"
@ -342,6 +354,23 @@ func (r *decoratedGJSONResult) Bool(key string) bool {
 	return r.Get(key).Bool()
 }

+func customAPIDoMathOp[T int | float64](a, b T, op string) T {
+	switch op {
+	case "add":
+		return a + b
+	case "sub":
+		return a - b
+	case "mul":
+		return a * b
+	case "div":
+		if b == 0 {
+			return 0
+		}
+		return a / b
+	}
+	return 0
+}
+
 var customAPITemplateFuncs = func() template.FuncMap {
 	var regexpCacheMu sync.Mutex
 	var regexpCache = make(map[string]*regexp.Regexp)
@ -359,6 +388,31 @@ var customAPITemplateFuncs = func() template.FuncMap {
 		return regex
 	}

+	doMathOpWithAny := func(a, b any, op string) any {
+		switch at := a.(type) {
+		case int:
+			switch bt := b.(type) {
+			case int:
+				return customAPIDoMathOp(at, bt, op)
+			case float64:
+				return customAPIDoMathOp(float64(at), bt, op)
+			default:
+				return math.NaN()
+			}
+		case float64:
+			switch bt := b.(type) {
+			case int:
+				return customAPIDoMathOp(at, float64(bt), op)
+			case float64:
+				return customAPIDoMathOp(at, bt, op)
+			default:
+				return math.NaN()
+			}
+		default:
+			return math.NaN()
+		}
+	}
+
 	funcs := template.FuncMap{
 		"toFloat": func(a int) float64 {
 			return float64(a)
@ -366,21 +420,35 @@ var customAPITemplateFuncs = func() template.FuncMap {
 		"toInt": func(a float64) int {
 			return int(a)
 		},
-		"add": func(a, b float64) float64 {
-			return a + b
+		"add": func(a, b any) any {
+			return doMathOpWithAny(a, b, "add")
 		},
-		"sub": func(a, b float64) float64 {
-			return a - b
+		"sub": func(a, b any) any {
+			return doMathOpWithAny(a, b, "sub")
 		},
-		"mul": func(a, b float64) float64 {
-			return a * b
+		"mul": func(a, b any) any {
+			return doMathOpWithAny(a, b, "mul")
 		},
-		"div": func(a, b float64) float64 {
-			if b == 0 {
-				return math.NaN()
+		"div": func(a, b any) any {
+			return doMathOpWithAny(a, b, "div")
+		},
+		"now": func() time.Time {
+			return time.Now()
+		},
+		"offsetNow": func(offset string) time.Time {
+			d, err := time.ParseDuration(offset)
+			if err != nil {
+				return time.Now()
+			}
+			return time.Now().Add(d)
+		},
+		"duration": func(str string) time.Duration {
+			d, err := time.ParseDuration(str)
+			if err != nil {
+				return 0
 			}

-			return a / b
+			return d
 		},
 		"parseTime":      customAPIFuncParseTime,
 		"toRelativeTime": dynamicRelativeTimeAttrs,
@ -465,6 +533,9 @@ var customAPITemplateFuncs = func() template.FuncMap {

 			return results
 		},
+		"concat": func(items ...string) string {
+			return strings.Join(items, "")
+		},
 	}

 	for key, value := range globalTemplateFunctions {
--- a/internal/glance/widget-extension.go
+++ b/internal/glance/widget-extension.go
@ -59,6 +59,10 @@ func (widget *extensionWidget) update(ctx context.Context) {
 		widget.Title = extension.Title
 	}

+	if widget.TitleURL == "" && extension.TitleURL != "" {
+		widget.TitleURL = extension.TitleURL
+	}
+
 	widget.cachedHTML = widget.renderTemplate(widget, extensionWidgetTemplate)
 }

@ -70,7 +74,7 @@ type extensionType int

 const (
 	extensionContentHTML extensionType = iota
-	extensionContentUnknown               = iota
+	extensionContentUnknown
 )

 var extensionStringToType = map[string]extensionType{
@ -79,6 +83,7 @@ var extensionStringToType = map[string]extensionType{

 const (
 	extensionHeaderTitle            = "Widget-Title"
+	extensionHeaderTitleURL         = "Widget-Title-URL"
 	extensionHeaderContentType      = "Widget-Content-Type"
 	extensionHeaderContentFrameless = "Widget-Content-Frameless"
 )
@ -93,6 +98,7 @@ type extensionRequestOptions struct {

 type extension struct {
 	Title     string
+	TitleURL  string
 	Content   template.HTML
 	Frameless bool
 }
@ -142,6 +148,10 @@ func fetchExtension(options extensionRequestOptions) (extension, error) {
 		extension.Title = response.Header.Get(extensionHeaderTitle)
 	}

+	if response.Header.Get(extensionHeaderTitleURL) != "" {
+		extension.TitleURL = response.Header.Get(extensionHeaderTitleURL)
+	}
+
 	contentType, ok := extensionStringToType[response.Header.Get(extensionHeaderContentType)]

 	if !ok {
--- a/internal/glance/widget-markets.go
+++ b/internal/glance/widget-markets.go
@ -79,6 +79,7 @@ type market struct {
 	Name           string
 	Currency       string
 	Price          float64
+	PriceHint      int
 	PercentChange  float64
 	SvgChartPoints string
 }
@ -106,6 +107,7 @@ type marketResponseJson struct {
 				RegularMarketPrice float64 `json:"regularMarketPrice"`
 				ChartPreviousClose float64 `json:"chartPreviousClose"`
 				ShortName          string  `json:"shortName"`
+				PriceHint          int     `json:"priceHint"`
 			} `json:"meta"`
 			Indicators struct {
 				Quote []struct {
@ -152,13 +154,14 @@ func fetchMarketsDataFromYahoo(marketRequests []marketRequest) (marketList, erro
 			continue
 		}

-		prices := response.Chart.Result[0].Indicators.Quote[0].Close
+		result := &response.Chart.Result[0]
+		prices := result.Indicators.Quote[0].Close

 		if len(prices) > marketChartDays {
 			prices = prices[len(prices)-marketChartDays:]
 		}

-		previous := response.Chart.Result[0].Meta.RegularMarketPrice
+		previous := result.Meta.RegularMarketPrice

 		if len(prices) >= 2 && prices[len(prices)-2] != 0 {
 			previous = prices[len(prices)-2]
@ -166,21 +169,22 @@ func fetchMarketsDataFromYahoo(marketRequests []marketRequest) (marketList, erro

 		points := svgPolylineCoordsFromYValues(100, 50, maybeCopySliceWithoutZeroValues(prices))

-		currency, exists := currencyToSymbol[strings.ToUpper(response.Chart.Result[0].Meta.Currency)]
+		currency, exists := currencyToSymbol[strings.ToUpper(result.Meta.Currency)]
 		if !exists {
-			currency = response.Chart.Result[0].Meta.Currency
+			currency = result.Meta.Currency
 		}

 		markets = append(markets, market{
 			marketRequest: marketRequests[i],
-			Price:         response.Chart.Result[0].Meta.RegularMarketPrice,
+			Price:         result.Meta.RegularMarketPrice,
 			Currency:      currency,
+			PriceHint:     result.Meta.PriceHint,
 			Name: ternary(marketRequests[i].CustomName == "",
-				response.Chart.Result[0].Meta.ShortName,
+				result.Meta.ShortName,
 				marketRequests[i].CustomName,
 			),
 			PercentChange: percentChange(
-				response.Chart.Result[0].Meta.RegularMarketPrice,
+				result.Meta.RegularMarketPrice,
 				previous,
 			),
 			SvgChartPoints: points,