@jskit-ai/users-web 0.1.35 → 0.1.37

package/test/crudLookupFieldRuntime.test.js

@@ -2,7 +2,8 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   resolveLookupItemLabel,
-  resolveLookupFieldDisplayValue
+  resolveLookupFieldDisplayValue,
+  resolveRecordTitle
 } from "../src/client/composables/crudLookupFieldLabelSupport.js";
 
 test("resolveLookupItemLabel composes name + surname", () => {
@@ -31,6 +32,19 @@ test("resolveLookupItemLabel composes firstName + surname", () => {
   );
 });
 
+test("resolveLookupItemLabel composes firstName + lastName", () => {
+  assert.equal(
+    resolveLookupItemLabel(
+      {
+        firstName: "Ana",
+        lastName: "Marin"
+      },
+      "name"
+    ),
+    "Ana Marin"
+  );
+});
+
 test("resolveLookupItemLabel falls back to explicit labelKey", () => {
   assert.equal(
     resolveLookupItemLabel(
@@ -59,6 +73,42 @@ test("resolveLookupItemLabel returns empty when no label fields match", () => {
   assert.equal(resolveLookupItemLabel({ id: 42 }, "name"), "");
 });
 
+test("resolveRecordTitle composes name-like fields before fallback key", () => {
+  assert.equal(
+    resolveRecordTitle(
+      {
+        firstName: "Ana",
+        lastName: "Marin",
+        title: "Ignored"
+      },
+      {
+        fallbackKey: "title",
+        defaultValue: "Record"
+      }
+    ),
+    "Ana Marin"
+  );
+});
+
+test("resolveRecordTitle falls back to provided field key", () => {
+  assert.equal(
+    resolveRecordTitle(
+      {
+        title: "Harbor Visit"
+      },
+      {
+        fallbackKey: "title",
+        defaultValue: "Record"
+      }
+    ),
+    "Harbor Visit"
+  );
+});
+
+test('resolveRecordTitle falls back to "-" when no title data exists', () => {
+  assert.equal(resolveRecordTitle({}, { fallbackKey: "title", defaultValue: "" }), "-");
+});
+
 test("resolveLookupFieldDisplayValue returns hydrated label for lookup fields", () => {
   assert.equal(
     resolveLookupFieldDisplayValue(

package/test/listQueryParamSupport.test.js

@@ -0,0 +1,190 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import {
+  normalizeListSyncToRouteConfig,
+  resolveQueryParamDescriptors,
+  resolveActiveQueryParamEntries,
+  resolveWritableQueryParamBindings,
+  buildQueryParamEntriesToken,
+  parseRouteBindingValue,
+  areQueryParamBindingValuesEqual,
+  buildRouteQueryCompareToken,
+  mergeManagedQueryParamKeyHistory,
+  resolveRouteSyncManagedKeys
+} from "../src/client/composables/listQueryParamSupport.js";
+
+test("normalizeListSyncToRouteConfig defaults", () => {
+  assert.deepEqual(
+    normalizeListSyncToRouteConfig(false, {
+      defaultSearchParam: "search"
+    }),
+    {
+      enabled: false,
+      mode: "replace",
+      syncSearch: false,
+      syncQueryParams: false,
+      hydrateFromRoute: false,
+      searchParam: "search",
+      queryParamBlacklist: []
+    }
+  );
+
+  assert.deepEqual(
+    normalizeListSyncToRouteConfig(true),
+    {
+      enabled: true,
+      mode: "replace",
+      syncSearch: true,
+      syncQueryParams: true,
+      hydrateFromRoute: true,
+      searchParam: "q",
+      queryParamBlacklist: []
+    }
+  );
+
+  assert.deepEqual(
+    normalizeListSyncToRouteConfig({
+      enabled: true,
+      queryParamBlacklist: [" include ", "cursor", "include", ""]
+    }),
+    {
+      enabled: true,
+      mode: "replace",
+      syncSearch: true,
+      syncQueryParams: true,
+      hydrateFromRoute: true,
+      searchParam: "q",
+      queryParamBlacklist: ["include", "cursor"]
+    }
+  );
+});
+
+test("resolveQueryParamDescriptors keeps declared keys and supports writable bindings", () => {
+  const source = {
+    " status ": ref("open"),
+    " count ": 2,
+    includeArchived: ref(false),
+    empty: ""
+  };
+
+  const descriptors = resolveQueryParamDescriptors(source);
+  assert.deepEqual(
+    descriptors.map((descriptor) => descriptor.key),
+    ["count", "empty", "includeArchived", "status"]
+  );
+
+  const activeEntries = resolveActiveQueryParamEntries(descriptors);
+  assert.deepEqual(
+    activeEntries,
+    [
+      {
+        key: "count",
+        values: ["2"]
+      },
+      {
+        key: "status",
+        values: ["open"]
+      }
+    ]
+  );
+
+  const bindings = resolveWritableQueryParamBindings(descriptors);
+  const countBinding = bindings.find((binding) => binding.key === "count");
+  assert.ok(countBinding);
+  countBinding.set(9);
+  assert.equal(source[" count "], 9);
+  assert.equal(source.count, undefined);
+});
+
+test("buildQueryParamEntriesToken and compare token stay deterministic", () => {
+  assert.equal(
+    buildQueryParamEntriesToken([
+      {
+        key: "status",
+        values: ["open"]
+      },
+      {
+        key: "tags",
+        values: ["a", "b"]
+      }
+    ]),
+    "status=open&tags=a,b"
+  );
+
+  assert.equal(
+    buildRouteQueryCompareToken({
+      b: "2",
+      a: ["1"]
+    }),
+    buildRouteQueryCompareToken({
+      a: "1",
+      b: ["2"]
+    })
+  );
+});
+
+test("parseRouteBindingValue handles boolean, number and array bindings", () => {
+  const booleanBinding = {
+    valueType: "boolean",
+    get: () => false
+  };
+  assert.equal(parseRouteBindingValue(booleanBinding, "1"), true);
+  assert.equal(parseRouteBindingValue(booleanBinding, undefined), false);
+
+  const numberBinding = {
+    valueType: "number",
+    get: () => 7
+  };
+  assert.equal(parseRouteBindingValue(numberBinding, "12"), 12);
+  assert.equal(parseRouteBindingValue(numberBinding, "bad"), 7);
+  assert.equal(parseRouteBindingValue(numberBinding, undefined), null);
+
+  const arrayBinding = {
+    valueType: "array",
+    arrayItemType: "number",
+    get: () => []
+  };
+  assert.deepEqual(
+    parseRouteBindingValue(arrayBinding, ["1", "bad", "3"]),
+    [1, 3]
+  );
+});
+
+test("route sync key helpers preserve declared key history for cleanup", () => {
+  const history = mergeManagedQueryParamKeyHistory(
+    ["status"],
+    ["assignee", "status"]
+  );
+  assert.deepEqual(history, ["assignee", "status"]);
+
+  assert.deepEqual(
+    resolveRouteSyncManagedKeys({
+      searchEnabled: true,
+      searchParam: "q",
+      syncSearch: true,
+      syncQueryParams: true,
+      declaredKeys: ["status"],
+      keyHistory: ["assignee"]
+    }),
+    ["assignee", "q", "status"]
+  );
+});
+
+test("areQueryParamBindingValuesEqual handles arrays and dates", () => {
+  assert.equal(
+    areQueryParamBindingValuesEqual([1, 2], [1, 2]),
+    true
+  );
+  assert.equal(
+    areQueryParamBindingValuesEqual([1, 2], [2, 1]),
+    false
+  );
+  assert.equal(
+    areQueryParamBindingValuesEqual(
+      new Date("2026-01-01T00:00:00.000Z"),
+      new Date("2026-01-01T00:00:00.000Z")
+    ),
+    true
+  );
+});

package/test/listUiRuntime.test.js

@@ -22,6 +22,27 @@ test("createListUiRuntime resolves row keys and relative route templates from st
   assert.equal(runtime.resolveEditUrl(items.value[0]), "/w/acme/admin/contacts/abc%20123/edit");
 });
 
+test("createListUiRuntime resolves nested route links from the parent list scope", () => {
+  const runtime = createListUiRuntime({
+    items: ref([{ id: "901" }]),
+    isInitialLoading: ref(false),
+    recordIdParam: "petId",
+    routeParams: ref({
+      workspaceSlug: "dogandgroom",
+      contactId: "541841",
+      petId: "715528"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528"),
+    viewUrlTemplate: "./:petId",
+    editUrlTemplate: "./:petId/edit"
+  });
+
+  assert.equal(runtime.resolveParams("./new"), "/w/dogandgroom/admin/contacts/541841/pets/new");
+  assert.equal(runtime.resolveViewUrl({ id: "901" }), "/w/dogandgroom/admin/contacts/541841/pets/901");
+  assert.equal(runtime.resolveEditUrl({ id: "901" }), "/w/dogandgroom/admin/contacts/541841/pets/901/edit");
+});
+
 test("createListUiRuntime resolves templates that depend on existing route params", () => {
   const runtime = createListUiRuntime({
     items: ref([{ id: 42 }]),

package/test/menuIcons.test.js

@@ -19,9 +19,11 @@ test("resolveSurfaceSwitchIcon prefers explicit icon and maps known surfaces", (
   assert.equal(resolveSurfaceSwitchIcon("admin"), mdiShieldCrownOutline);
   assert.equal(resolveSurfaceSwitchIcon("console"), mdiConsoleNetworkOutline);
   assert.equal(resolveSurfaceSwitchIcon("admin", "custom-icon"), "custom-icon");
+  assert.equal(resolveSurfaceSwitchIcon("admin", "mdi-cog-outline"), mdiCogOutline);
 });
 
 test("resolveMenuLinkIcon resolves settings/login fallbacks and generic default", () => {
+  assert.equal(resolveMenuLinkIcon({ icon: "mdi-cog-outline" }), mdiCogOutline);
   assert.equal(resolveMenuLinkIcon({ to: "/account" }), mdiAccountCogOutline);
   assert.equal(resolveMenuLinkIcon({ label: "Sign in" }), mdiLogin);
   assert.equal(resolveMenuLinkIcon({ label: "Go to admin" }), mdiShieldCrownOutline);

package/test/routeTemplateHelpers.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   extractRouteParamNames,
+  resolveScopedRoutePathname,
   resolveRouteParamNamesInOrder
 } from "../src/client/composables/routeTemplateHelpers.js";
 
@@ -27,3 +28,58 @@ test("resolveRouteParamNamesInOrder prefers matched route templates", () => {
 
   assert.deepEqual(resolveRouteParamNamesInOrder(route), ["workspaceSlug", "contactId", "addressId"]);
 });
+
+test("resolveScopedRoutePathname supports at/before/after anchors", () => {
+  const currentPathname = "/w/dogandgroom/admin/contacts/541841/pets/715528/edit/advanced";
+  const params = {
+    workspaceSlug: "dogandgroom",
+    contactId: "541841",
+    petId: "715528"
+  };
+  const orderedParamNames = ["workspaceSlug", "contactId", "petId"];
+
+  assert.equal(
+    resolveScopedRoutePathname({
+      currentPathname,
+      params,
+      orderedParamNames,
+      anchorParamName: "contactId",
+      anchorMode: "at"
+    }),
+    "/w/dogandgroom/admin/contacts/541841"
+  );
+  assert.equal(
+    resolveScopedRoutePathname({
+      currentPathname,
+      params,
+      orderedParamNames,
+      anchorParamName: "petId",
+      anchorMode: "before"
+    }),
+    "/w/dogandgroom/admin/contacts/541841/pets"
+  );
+  assert.equal(
+    resolveScopedRoutePathname({
+      currentPathname,
+      params,
+      orderedParamNames,
+      anchorParamName: "petId",
+      anchorMode: "after"
+    }),
+    "/w/dogandgroom/admin/contacts/541841/pets/715528/edit"
+  );
+});
+
+test("resolveScopedRoutePathname falls back to direct value matching", () => {
+  assert.equal(
+    resolveScopedRoutePathname({
+      currentPathname: "/contacts/abc%20123/notes",
+      params: {},
+      orderedParamNames: [],
+      anchorParamName: "contactId",
+      anchorParamValue: "abc 123",
+      anchorMode: "at"
+    }),
+    "/contacts/abc%20123"
+  );
+});

package/test/usePagedCollection.test.js

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { trimInfinitePagesToFirst } from "../src/client/composables/usePagedCollection.js";
+
+test("trimInfinitePagesToFirst leaves non-object payloads untouched", () => {
+  assert.equal(trimInfinitePagesToFirst(null), null);
+  assert.equal(trimInfinitePagesToFirst(""), "");
+  assert.equal(trimInfinitePagesToFirst(12), 12);
+});
+
+test("trimInfinitePagesToFirst leaves single-page payload unchanged", () => {
+  const payload = Object.freeze({
+    pages: Object.freeze([{ items: [1, 2] }]),
+    pageParams: Object.freeze([null])
+  });
+
+  assert.equal(trimInfinitePagesToFirst(payload), payload);
+});
+
+test("trimInfinitePagesToFirst truncates to the first page and first pageParam", () => {
+  const payload = {
+    pages: [
+      { items: [1, 2] },
+      { items: [3, 4] },
+      { items: [5, 6] }
+    ],
+    pageParams: [null, "cursor-1", "cursor-2"],
+    extra: true
+  };
+
+  assert.deepEqual(
+    trimInfinitePagesToFirst(payload),
+    {
+      pages: [{ items: [1, 2] }],
+      pageParams: [null],
+      extra: true
+    }
+  );
+});
+
+test("trimInfinitePagesToFirst injects null pageParam when missing", () => {
+  const payload = {
+    pages: [{ items: [1] }, { items: [2] }]
+  };
+
+  assert.deepEqual(
+    trimInfinitePagesToFirst(payload),
+    {
+      pages: [{ items: [1] }],
+      pageParams: [null]
+    }
+  );
+});

package/test/viewUiRuntime.test.js

@@ -23,6 +23,41 @@ test("createViewUiRuntime resolves api/list/edit paths with nested params", () =
   assert.equal(runtime.resolveParams("./edit"), "/users/user-7/addresses/addr-42/edit");
 });
 
+test("createViewUiRuntime resolves view links from the record pathname when route is nested", () => {
+  const runtime = createViewUiRuntime({
+    recordIdParam: "contactId",
+    routeParams: ref({
+      workspaceSlug: "dogandgroom",
+      contactId: "541841",
+      petId: "715528"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528"),
+    listUrlTemplate: "..",
+    editUrlTemplate: "./edit"
+  });
+
+  assert.equal(runtime.listUrl.value, "/w/dogandgroom/admin/contacts");
+  assert.equal(runtime.editUrl.value, "/w/dogandgroom/admin/contacts/541841/edit");
+  assert.equal(runtime.resolveParams("./edit"), "/w/dogandgroom/admin/contacts/541841/edit");
+});
+
+test("createViewUiRuntime uses route param order when repeated values are present", () => {
+  const runtime = createViewUiRuntime({
+    recordIdParam: "contactId",
+    routeParams: ref({
+      workspaceSlug: "123",
+      contactId: "123",
+      petId: "123"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/123/admin/contacts/123/pets/123"),
+    editUrlTemplate: "./edit"
+  });
+
+  assert.equal(runtime.editUrl.value, "/w/123/admin/contacts/123/edit");
+});
+
 test("createViewUiRuntime uses explicit routeRecordId when route params do not include id", () => {
   const runtime = createViewUiRuntime({
     recordIdParam: "addressId",