@voxgig/sdkgen 4.22.0 → 4.24.0

package/project/.sdk/tm/elixir/lib/projectname/feature/test.ex

@@ -55,16 +55,22 @@ defmodule ProjectName.Feature.Test do
   defp envelope(fctx, data) do
     spec = S.getprop(S.getprop(S.getprop(fctx, "point"), "transform"), "res")
 
-    # Exactly `body.<key>`; a deeper path is not an envelope this mock can
-    # synthesise, so it is left alone rather than guessed at.
+    # Rebuild whatever nesting the transform unwraps. Multi-segment on purpose:
+    # GraphQL ops unwrap `body.data.<field>`, not just one envelope property.
     case {data, spec} do
       {nil, _} ->
         data
 
       {_, s} when is_binary(s) ->
-        case Regex.run(~r/^`body\.([^`.]+)`$/, s) do
-          [_, inner] -> S.jm([inner, data])
-          _ -> data
+        case Regex.run(~r/^`body\.(.+)`$/, s) do
+          [_, inner] ->
+            inner
+            |> String.split(".")
+            |> Enum.reverse()
+            |> Enum.reduce(data, fn seg, out -> S.jm([seg, out]) end)
+
+          _ ->
+            data
         end
 
       _ ->
@@ -161,20 +167,11 @@ defmodule ProjectName.Feature.Test do
         found = S.select(entmap, args)
         ent = S.getelem(found, 0)
 
-        ent =
-          if ent == nil and S.ismap(entmap) do
-            ks = S.keysof(entmap)
-            Enum.find_value(ks, fn k -> v = S.getprop(entmap, k); if S.ismap(v), do: v end)
-          else
-            ent
-          end
-
         if ent == nil do
+          # update miss: 404, never another record
           respond(fctx, 404, nil, S.jm(["statusText", "Not found"]))
         else
-          if S.ismap(ent) and reqdata != nil do
-            Enum.each(H.entries(reqdata), fn {k, v} -> S.setprop(ent, k, v) end)
-          end
+          if S.ismap(ent) and S.ismap(reqdata), do: S.merge(S.jt([ent, reqdata]))
 
           S.delprop(ent, "$KEY")
           respond(fctx, 200, S.clone(ent))
@@ -216,6 +213,45 @@ defmodule ProjectName.Feature.Test do
     :crypto.strong_rand_bytes(8) |> Base.encode16(case: :lower)
   end
 
+  defp point_terminal?(p) do
+    parts = S.getprop(p, "parts")
+    n = if S.islist(parts), do: S.size(parts), else: 0
+    last = if n > 0, do: S.getelem(parts, n - 1), else: nil
+    is_binary(last) and String.starts_with?(last, "{")
+  end
+
+  defp point_depth(p) do
+    parts = S.getprop(p, "parts")
+    if S.islist(parts), do: S.size(parts), else: 0
+  end
+
+  # The entity's own endpoint: a terminal `{param}` marks a record route,
+  # and among equals the shallower path wins (the same rule as make_point).
+  defp pick_point(points) do
+    n = if S.islist(points), do: S.size(points), else: 0
+
+    if n == 0 do
+      nil
+    else
+      rest = if n > 1, do: Enum.to_list(1..(n - 1)), else: []
+
+      Enum.reduce(rest, S.getelem(points, 0), fn i, point ->
+        cand = S.getelem(points, i)
+
+        cond do
+          point_terminal?(cand) != point_terminal?(point) -> if point_terminal?(cand), do: cand, else: point
+          point_depth(cand) < point_depth(point) -> cand
+          true -> point
+        end
+      end)
+    end
+  end
+
+  defp reqd_names(point, kind) do
+    reqd_args = S.select(S.getpath(point, "args." <> kind), S.jm(["reqd", true]))
+    S.transform(reqd_args, S.jt(["`$EACH`", "", "`$KEY.name`"]))
+  end
+
   # Build a struct select query ($AND of $OR alternatives) from the required
   # params + id, resolving each value through the pipeline param resolver.
   def build_args(_f, ctx, op, args) do
@@ -223,10 +259,11 @@ defmodule ProjectName.Feature.Test do
     config = S.getprop(ctx, "config")
     entname = Context.entity_name(S.getprop(ctx, "entity"))
     points = S.getpath(config, "entity." <> entname <> ".op." <> opname <> ".points")
-    point = S.getelem(points, -1)
-    params_path = S.getpath(point, "args.params")
-    reqd_params = S.select(params_path, S.jm(["reqd", true]))
-    reqd = S.transform(reqd_params, S.jt(["`$EACH`", "", "`$KEY.name`"]))
+    point = pick_point(points)
+    # Path AND query: a path-only read misses a query-addressed record
+    # (e.g. GET /result?trace_id=), which has no path param at all.
+    reqd_params = reqd_names(point, "params")
+    reqd_query = reqd_names(point, "query")
 
     qand = S.jt([])
     q = S.jm(["`$AND`", qand])
@@ -234,8 +271,7 @@ defmodule ProjectName.Feature.Test do
     if args != nil do
       Enum.each(S.keysof(args), fn key ->
         is_id = key == "id"
-        selected = S.select(reqd, key)
-        is_reqd = not S.isempty(selected)
+        is_reqd = not S.isempty(S.select(reqd_params, key)) or not S.isempty(S.select(reqd_query, key))
 
         if is_id or is_reqd do
           v = Utility.param(ctx, key)

package/project/.sdk/tm/elixir/lib/projectname/utility.ex

@@ -1209,7 +1209,8 @@ defmodule ProjectName.Utility do
     out = S.jm([])
 
     Enum.each(H.entries(reqmatch), fn {key, val} ->
-      if val != nil and is_binary(key) and not Enum.member?(param_strs, key) do
+      if val != nil and is_binary(key) and key != "$action" and
+           not Enum.member?(param_strs, key) do
         S.setprop(out, key, val)
       end
     end)
@@ -1446,6 +1447,23 @@ defmodule ProjectName.Utility do
 
   # ---- transform_* ---------------------------------------------------------
 
+  # `$action` selects the point (see make_point_impl); it is never an API
+  # field, so the body is a copy without it. The caller's map is left
+  # untouched.
+  defp strip_action(reqdata) do
+    if S.ismap(reqdata) and S.haskey(reqdata, "$action") do
+      body = S.jm([])
+
+      Enum.each(H.entries(reqdata), fn {key, val} ->
+        if key != "$action", do: S.setprop(body, key, val)
+      end)
+
+      body
+    else
+      reqdata
+    end
+  end
+
   def transform_request_impl(ctx) do
     spec = S.getprop(ctx, "spec")
     point = S.getprop(ctx, "point")
@@ -1453,17 +1471,20 @@ defmodule ProjectName.Utility do
 
     transform = H.to_map(S.getprop(point, "transform"))
 
-    if transform == nil do
-      S.getprop(ctx, "reqdata")
-    else
-      reqform = S.getprop(transform, "req")
-
-      if reqform == nil do
+    reqdata =
+      if transform == nil do
         S.getprop(ctx, "reqdata")
       else
-        S.transform(S.jm(["reqdata", S.getprop(ctx, "reqdata")]), reqform)
+        reqform = S.getprop(transform, "req")
+
+        if reqform == nil do
+          S.getprop(ctx, "reqdata")
+        else
+          S.transform(S.jm(["reqdata", S.getprop(ctx, "reqdata")]), reqform)
+        end
       end
-    end
+
+    strip_action(reqdata)
   end
 
   def transform_response_impl(ctx) do

package/project/.sdk/tm/go/core/context.go

@@ -9,18 +9,18 @@ import (
 )
 
 type Context struct {
-	Id      string
-	Out     map[string]any
-	Ctrl    *Control
-	Meta    map[string]any
-	Client  *ProjectNameSDK
-	Utility *Utility
-	Op      *Operation
-	Point   map[string]any
-	Config  map[string]any
-	Entopts map[string]any
-	Options map[string]any
-	Opmap   map[string]*Operation
+	Id       string
+	Out      map[string]any
+	Ctrl     *Control
+	Meta     map[string]any
+	Client   *ProjectNameSDK
+	Utility  *Utility
+	Op       *Operation
+	Point    map[string]any
+	Config   map[string]any
+	Entopts  map[string]any
+	Options  map[string]any
+	Opmap    map[string]*Operation
 	Opmu     *sync.Mutex
 	Response *Response
 	Result   *Result
@@ -86,7 +86,7 @@ func NewContext(ctxmap map[string]any, basectx *Context) *Context {
 		} else if ctrl, ok := c.(*Control); ok {
 			ctx.Ctrl = ctrl
 		}
-	} else if basectx != nil && basectx.Ctrl != nil {
+	} else if basectx != nil && basectx.Ctrl != nil && getCtxProp(ctxmap, "opname") == nil {
 		ctx.Ctrl = basectx.Ctrl
 	}
 

package/project/.sdk/tm/go/feature/paging_feature.go

@@ -68,7 +68,11 @@ func (f *PagingFeature) PreRequest(ctx *core.Context) {
 	if cursor, has := paging["cursor"]; has && cursor != nil {
 		spec.Query[cursorParam] = cursor
 	} else if spec.Query[pageParam] == nil {
-		if page, has := paging["page"]; has && page != nil {
+		// A record written back by PreResult holds the page just fetched as
+		// "page" and the one to fetch as "nextPage", so nextPage wins.
+		if next, has := paging["nextPage"]; has && next != nil {
+			spec.Query[pageParam] = next
+		} else if page, has := paging["page"]; has && page != nil {
 			spec.Query[pageParam] = page
 		} else {
 			spec.Query[pageParam] = foptInt(f.options, "startPage", 1)
@@ -178,17 +182,36 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 		}
 	}
 
-	// Body-level cursors.
+	// Body-level signals; snake_case forms are read first so camelCase wins.
 	if bm, ok := body.(map[string]any); ok {
 		if bm["next"] != nil && paging["next"] == nil {
 			paging["next"] = bm["next"]
 		}
+		if bm["next_cursor"] != nil {
+			paging["cursor"] = bm["next_cursor"]
+		}
 		if bm["cursor"] != nil {
 			paging["cursor"] = bm["cursor"]
 		}
 		if bm["nextCursor"] != nil {
 			paging["cursor"] = bm["nextCursor"]
 		}
+		if paging["nextPage"] == nil {
+			np := bm["nextPage"]
+			if np == nil {
+				np = bm["next_page"]
+			}
+			switch n := np.(type) {
+			case float64:
+				paging["nextPage"] = int(n)
+			case int, string:
+				paging["nextPage"] = n
+			}
+		}
+		if hasMore, ok := bm["has_more"].(bool); ok {
+			paging["hasMore"] = hasMore
+			explicitMore = true
+		}
 		if hasMore, ok := bm["hasMore"].(bool); ok {
 			paging["hasMore"] = hasMore
 			explicitMore = true
@@ -207,6 +230,21 @@ func (f *PagingFeature) PreResult(ctx *core.Context) {
 
 	result.Paging = paging
 	f.Last = paging
+
+	if ctx.Ctrl != nil {
+		// The Context shares the caller's paging map by reference, so refill
+		// it in place; a fresh map on Ctrl would never reach the caller.
+		if ctx.Ctrl.Paging != nil {
+			for k := range ctx.Ctrl.Paging {
+				delete(ctx.Ctrl.Paging, k)
+			}
+			for k, v := range paging {
+				ctx.Ctrl.Paging[k] = v
+			}
+		} else {
+			ctx.Ctrl.Paging = paging
+		}
+	}
 }
 
 func (f *PagingFeature) isList(ctx *core.Context) bool {

package/project/.sdk/tm/go/feature/test_feature.go

@@ -164,24 +164,12 @@ func (f *TestFeature) Init(ctx *core.Context, options map[string]any) {
 			args := self.buildArgs(ctx, op, updateMatch)
 			found := vs.Select(entmap, args)
 			ent := vs.GetElem(found, 0)
-			if ent == nil && entmap != nil {
-				for _, e := range entmap {
-					if _, ok := e.(map[string]any); ok {
-						ent = e
-						break
-					}
-				}
-			}
 			if ent == nil {
+				// update miss: 404, never another record
 				return respond(404, nil, map[string]any{"statusText": "Not found"}), nil
 			}
-			if entm, ok := ent.(map[string]any); ok {
-				reqdata := ctx.Reqdata
-				if reqdata != nil {
-					for k, v := range reqdata {
-						entm[k] = v
-					}
-				}
+			if _, ok := ent.(map[string]any); ok && ctx.Reqdata != nil {
+				vs.Merge([]any{ent, ctx.Reqdata})
 			}
 			vs.DelProp(ent, "$KEY")
 			out := vs.Clone(ent)

package/project/.sdk/tm/go/test/feature_corpus_test.go

@@ -428,6 +428,7 @@ func TestFeatureCorpus(t *testing.T) {
 				"feature": []any{map[string]any{"name": name, "active": true}},
 			})
 			if fcRecord(probe, name) == nil {
+				t.Logf("feature.%s: inert (this SDK does not generate the feature)", name)
 				t.Skipf("this SDK was generated without the %s feature", name)
 			}
 

package/project/.sdk/tm/go/test/feature_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"reflect"
 	"regexp"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -1042,6 +1043,59 @@ func TestFeaturePaging(t *testing.T) {
 		}
 	})
 
+	t.Run("snake-case-signals-and-ctrl-write-back", func(t *testing.T) {
+		rec := &fhRecorder{reply: func(n int, _ map[string]any) (any, error) {
+			if n == 1 {
+				return fhResponse(200, map[string]any{"has_more": true, "next_cursor": "c2"}, nil), nil
+			}
+			return fhResponse(200, map[string]any{"has_more": false}, nil), nil
+		}}
+		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))
+		pg := map[string]any{}
+		ctrl := map[string]any{"paging": pg}
+		res := h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if res.result.Paging["hasMore"] != true {
+			t.Errorf("expected has_more read, got %v", res.result.Paging["hasMore"])
+		}
+		if res.result.Paging["cursor"] != "c2" {
+			t.Errorf("expected next_cursor read, got %v", res.result.Paging["cursor"])
+		}
+		if pg["cursor"] != "c2" || pg["hasMore"] != true {
+			t.Errorf("expected record written back into ctrl, got %v", pg)
+		}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if !strings.Contains(rec.url(1), "cursor=c2") {
+			t.Errorf("expected written-back cursor sent, got %s", rec.url(1))
+		}
+		if pg["hasMore"] != false || pg["cursor"] != nil {
+			t.Errorf("expected ctrl to carry the last record, got %v", pg)
+		}
+	})
+
+	t.Run("continues-from-written-back-next-page", func(t *testing.T) {
+		rec := &fhRecorder{reply: func(n int, _ map[string]any) (any, error) {
+			body := map[string]any{}
+			if n == 1 {
+				body["next_page"] = 2
+			}
+			return fhResponse(200, body, map[string]any{"x-page": strconv.Itoa(n)}), nil
+		}}
+		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))
+		pg := map[string]any{}
+		ctrl := map[string]any{"paging": pg}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if pg["page"] != 1 || pg["nextPage"] != 2 || pg["hasMore"] != true {
+			t.Errorf("expected next_page read and written back, got %v", pg)
+		}
+		h.op(fhOpSpec{op: "list", path: "/w", ctrl: ctrl})
+		if !strings.Contains(rec.url(1), "page=2") {
+			t.Errorf("expected written-back next page sent, got %s", rec.url(1))
+		}
+		if pg["hasMore"] != false {
+			t.Errorf("expected no more pages, got %v", pg)
+		}
+	})
+
 	t.Run("non-list-not-paged", func(t *testing.T) {
 		rec := &fhRecorder{}
 		h := fhMake(rec.fetch, fhF(feat.NewPagingFeature(), nil))

package/project/.sdk/tm/go/utility/fetcher.go

@@ -6,12 +6,52 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"sync"
 
 	vs "github.com/voxgig/struct"
 
 	"GOMODULE/core"
 )
 
+// Proxied clients keyed by proxy URL. A client per request would open a
+// fresh connection every call; a cached one pools like http.DefaultClient.
+var proxyClients sync.Map
+
+func clientFor(fetchdef map[string]any) *http.Client {
+	client := http.DefaultClient
+
+	if proxy, ok := fetchdef["proxy"].(string); ok && proxy != "" {
+		if cached, ok := proxyClients.Load(proxy); ok {
+			client = cached.(*http.Client)
+		} else if proxyURL, perr := url.Parse(proxy); perr == nil {
+			// http.DefaultTransport is a package variable the host program can
+			// replace, and an unchecked assertion on it panics the SDK inside
+			// whatever called it. Clone the real one where it is there, and
+			// build a plain transport where it is not.
+			var transport *http.Transport
+			if def, ok := http.DefaultTransport.(*http.Transport); ok {
+				transport = def.Clone()
+			} else {
+				transport = &http.Transport{}
+			}
+			transport.Proxy = http.ProxyURL(proxyURL)
+			cached, _ := proxyClients.LoadOrStore(proxy, &http.Client{Transport: transport})
+			client = cached.(*http.Client)
+		}
+	}
+
+	// A shallow copy shares the pooled Transport; only CheckRedirect differs.
+	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
+		manual := *client
+		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		}
+		client = &manual
+	}
+
+	return client
+}
+
 func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any, error) {
 	method, _ := fetchdef["method"].(string)
 	if method == "" {
@@ -46,26 +86,7 @@ func defaultHTTPFetch(fullurl string, fetchdef map[string]any) (map[string]any,
 		req.Header.Set("User-Agent", "Mozilla/5.0 (compatible; ProjectNameSDK/1.0)")
 	}
 
-	// Honour a proxy annotation on the fetch definition (set by the proxy
-	// feature): route the request through an http.Transport with Proxy set.
-	client := http.DefaultClient
-	if proxy, ok := fetchdef["proxy"].(string); ok && proxy != "" {
-		if proxyURL, perr := url.Parse(proxy); perr == nil {
-			client = &http.Client{
-				Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
-			}
-		}
-	}
-
-	if redirect, ok := fetchdef["redirect"].(string); ok && redirect == "manual" {
-		manual := *client
-		manual.CheckRedirect = func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse
-		}
-		client = &manual
-	}
-
-	resp, err := client.Do(req)
+	resp, err := clientFor(fetchdef).Do(req)
 	if err != nil {
 		return nil, err
 	}

package/project/.sdk/tm/go/utility/prepare_query.go

@@ -29,7 +29,7 @@ func prepareQueryUtil(ctx *core.Context) map[string]any {
 	for _, item := range vs.Items(reqmatch) {
 		key, _ := item[0].(string)
 		val := item[1]
-		if val != nil && !containsStr(params, key) {
+		if val != nil && key != "$action" && !containsStr(params, key) {
 			out[key] = val
 		}
 	}

package/project/.sdk/tm/go/utility/transform_request.go

@@ -16,12 +16,12 @@ func transformRequestUtil(ctx *core.Context) any {
 
 	transform := core.ToMapAny(vs.GetProp(point, "transform"))
 	if transform == nil {
-		return ctx.Reqdata
+		return stripAction(ctx.Reqdata)
 	}
 
 	reqform := vs.GetProp(transform, "req")
 	if reqform == nil {
-		return ctx.Reqdata
+		return stripAction(ctx.Reqdata)
 	}
 
 	reqdata, terr := vs.Transform(map[string]any{
@@ -36,5 +36,24 @@ func transformRequestUtil(ctx *core.Context) any {
 		return terr
 	}
 
-	return reqdata
+	return stripAction(reqdata)
+}
+
+// `$action` selects the point (see makePointUtil); it is never an API field,
+// so the body is a copy without it. The caller's map is left untouched.
+func stripAction(reqdata any) any {
+	src, ok := reqdata.(map[string]any)
+	if !ok {
+		return reqdata
+	}
+	if _, has := src["$action"]; !has {
+		return reqdata
+	}
+	body := make(map[string]any, len(src))
+	for k, v := range src {
+		if k != "$action" {
+			body[k] = v
+		}
+	}
+	return body
 }

package/project/.sdk/tm/java/core/Context.java

@@ -82,7 +82,8 @@ public class Context {
         this.ctrl = (Control) cv;
       }
     }
-    else if (basectx != null && basectx.ctrl != null) {
+    else if (basectx != null && basectx.ctrl != null
+        && Helpers.getCtxProp(ctxmap, "opname") == null) {
       this.ctrl = basectx.ctrl;
     }
 

package/project/.sdk/tm/java/feature/PagingFeature.java

@@ -18,8 +18,8 @@ import JAVAPACKAGE.utility.struct.Struct;
 // stamps page/limit (or a cursor) into the request query; on the way back
 // (PreResult) it reads the server's pagination signals — a `Link:
 // rel="next"` header, `X-Page`/`X-Next-Page`/`X-Total-Count` headers, or
-// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body — and records
-// them on `ctx.result.paging`. A per-call cursor/page from ctrl takes
+// `next`/`cursor`/`nextCursor`/`hasMore` fields in the body (snake_case
+// forms too) — and records them on `ctx.result.paging` and `ctrl.paging`. A per-call cursor/page from ctrl takes
 // priority (used by auto-iteration). Parameter names (`pageParam`,
 // `limitParam`, `cursorParam`), the page size (`limit`) and the start page
 // (`startPage`, default 1) are configurable.
@@ -82,7 +82,12 @@ public class PagingFeature extends BaseFeature {
       spec.query.put(cursorParam, cursor);
     }
     else if (spec.query.get(pageParam) == null) {
-      Object page = paging.get("page");
+      // A record written back by preResult holds the page just fetched as
+      // "page" and the one to fetch as "nextPage", so nextPage wins.
+      Object page = paging.get("nextPage");
+      if (page == null) {
+        page = paging.get("page");
+      }
       if (page != null) {
         spec.query.put(pageParam, page);
       }
@@ -206,18 +211,37 @@ public class PagingFeature extends BaseFeature {
       }
     }
 
-    // Body-level cursors.
+    // Body-level signals; snake_case forms are read first so camelCase wins.
     if (body instanceof Map) {
       Map<String, Object> bm = (Map<String, Object>) body;
       if (bm.get("next") != null && paging.get("next") == null) {
         paging.put("next", bm.get("next"));
       }
+      if (bm.get("next_cursor") != null) {
+        paging.put("cursor", bm.get("next_cursor"));
+      }
       if (bm.get("cursor") != null) {
         paging.put("cursor", bm.get("cursor"));
       }
       if (bm.get("nextCursor") != null) {
         paging.put("cursor", bm.get("nextCursor"));
       }
+      if (paging.get("nextPage") == null) {
+        Object np = bm.get("nextPage");
+        if (np == null) {
+          np = bm.get("next_page");
+        }
+        if (np instanceof Number) {
+          paging.put("nextPage", ((Number) np).intValue());
+        }
+        else if (np instanceof String) {
+          paging.put("nextPage", np);
+        }
+      }
+      if (bm.get("has_more") instanceof Boolean) {
+        paging.put("hasMore", bm.get("has_more"));
+        explicitMore = true;
+      }
       if (bm.get("hasMore") instanceof Boolean) {
         paging.put("hasMore", bm.get("hasMore"));
         explicitMore = true;
@@ -237,6 +261,24 @@ public class PagingFeature extends BaseFeature {
 
     result.paging = paging;
     this.last = paging;
+
+    if (ctx.ctrl != null) {
+      // The Context shares the caller's paging map by reference, so refill
+      // it in place; an immutable map falls back to replacing the reference.
+      Map<String, Object> shared = ctx.ctrl.paging;
+      if (shared == null) {
+        ctx.ctrl.paging = paging;
+      }
+      else {
+        try {
+          shared.clear();
+          shared.putAll(paging);
+        }
+        catch (UnsupportedOperationException e) {
+          ctx.ctrl.paging = paging;
+        }
+      }
+    }
   }
 
   private boolean isList(Context ctx) {