@jskit-ai/users-web 0.1.36 → 0.1.38

package/test/crudBindingSupport.test.js

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { ref } from "vue";
+import {
+  CRUD_BINDING_MODE_ROUTE,
+  CRUD_BINDING_MODE_MERGE,
+  CRUD_BINDING_MODE_EXPLICIT,
+  CRUD_BINDING_MODE_NONE,
+  normalizeCrudBindingMode,
+  resolveCrudBoundValues
+} from "../src/client/composables/crud/crudBindingSupport.js";
+
+test("normalizeCrudBindingMode defaults invalid values to route", () => {
+  assert.equal(normalizeCrudBindingMode(""), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("unknown"), CRUD_BINDING_MODE_ROUTE);
+  assert.equal(normalizeCrudBindingMode("merge"), CRUD_BINDING_MODE_MERGE);
+  assert.equal(normalizeCrudBindingMode("explicit"), CRUD_BINDING_MODE_EXPLICIT);
+  assert.equal(normalizeCrudBindingMode("none"), CRUD_BINDING_MODE_NONE);
+});
+
+test("resolveCrudBoundValues returns route values in route mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "route",
+      values: {
+        contactId: "22"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11"
+  });
+});
+
+test("resolveCrudBoundValues merges explicit values over route values in merge mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "merge",
+      values: {
+        contactId: "22",
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "22",
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues uses only explicit values in explicit mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "explicit",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    serviceId: "4"
+  });
+});
+
+test("resolveCrudBoundValues disables automatic binding in none mode", () => {
+  const values = resolveCrudBoundValues({
+    binding: {
+      mode: "none",
+      values: {
+        serviceId: "4"
+      }
+    },
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {});
+});
+
+test("resolveCrudBoundValues unwraps reactive binding config and values", () => {
+  const values = resolveCrudBoundValues({
+    binding: ref({
+      mode: "merge",
+      values: ref({
+        serviceId: "4"
+      })
+    }),
+    routeValues: {
+      contactId: "11"
+    }
+  });
+
+  assert.deepEqual(values, {
+    contactId: "11",
+    serviceId: "4"
+  });
+});

package/test/crudLookupFieldRuntime.test.js

@@ -2,8 +2,9 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   resolveLookupItemLabel,
-  resolveLookupFieldDisplayValue
-} from "../src/client/composables/crudLookupFieldLabelSupport.js";
+  resolveLookupFieldDisplayValue,
+  resolveRecordTitle
+} from "../src/client/composables/crud/crudLookupFieldLabelSupport.js";
 
 test("resolveLookupItemLabel composes name + surname", () => {
   assert.equal(
@@ -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/errorMessageHelpers.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/errorMessageHelpers.js";
+import { toQueryErrorMessage, toUiErrorMessage } from "../src/client/composables/support/errorMessageHelpers.js";
 
 test("toQueryErrorMessage returns empty when query has no error", () => {
   assert.equal(toQueryErrorMessage(null, "Unable to load list."), "");

package/test/exportsContract.test.js

@@ -13,7 +13,16 @@ test("users-web exports are explicit and aligned with production/template usage"
     repoRoot: REPO_ROOT,
     packageDir: PACKAGE_DIR,
     packageId: "@jskit-ai/users-web",
-    requiredExports: ["./client"]
+    requiredExports: [
+      "./client",
+      "./client/composables/useAddEdit",
+      "./client/composables/useList",
+      "./client/composables/useView",
+      "./client/composables/useCrudAddEdit",
+      "./client/composables/useCrudList",
+      "./client/composables/useCrudView",
+      "./client/support/menuLinkTarget"
+    ]
   });
 
   assert.deepEqual(

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/support/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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { createListUiRuntime } from "../src/client/composables/listUiRuntime.js";
+import { createListUiRuntime } from "../src/client/composables/runtime/listUiRuntime.js";
 
 test("createListUiRuntime resolves row keys and relative route templates from string record ids", () => {
   const items = ref([{ uuid: "abc 123" }]);
@@ -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/menuLinkTarget.test.js

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  normalizeMenuLinkPathname,
+  resolveMenuLinkTarget
+} from "../src/client/support/menuLinkTarget.js";
+
+const WORKSPACE_PLACEMENT_CONTEXT = Object.freeze({
+  surfaceConfig: {
+    enabledSurfaceIds: ["admin"],
+    surfacesById: {
+      admin: {
+        id: "admin",
+        requiresWorkspace: true
+      }
+    }
+  }
+});
+
+const MIXED_PLACEMENT_CONTEXT = Object.freeze({
+  surfaceConfig: {
+    enabledSurfaceIds: ["app", "admin"],
+    surfacesById: {
+      app: {
+        id: "app",
+        requiresWorkspace: false
+      },
+      admin: {
+        id: "admin",
+        requiresWorkspace: true
+      }
+    }
+  }
+});
+
+function createPageResolver() {
+  return function resolvePagePath(relativePath = "", options = {}) {
+    return `page:${String(options.surface || "")}:${String(relativePath || "")}`;
+  };
+}
+
+test("resolveMenuLinkTarget resolves suffix targets when no explicit to is provided", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/practice/vets",
+      nonWorkspaceSuffix: "/practice/vets",
+      resolvePagePath: createPageResolver()
+    }),
+    "page:admin:/practice/vets"
+  );
+});
+
+test("resolveMenuLinkTarget resolves relative targets through suffix templates", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "./notes",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/contacts/[contactId]/notes",
+      nonWorkspaceSuffix: "/contacts/[contactId]/notes",
+      routeParams: {
+        contactId: 42
+      },
+      resolvePagePath: createPageResolver()
+    }),
+    "page:admin:/contacts/42/notes"
+  );
+});
+
+test("resolveMenuLinkTarget returns empty string for unresolved relative targets", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "./notes",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/contacts/[contactId]/notes",
+      nonWorkspaceSuffix: "/contacts/[contactId]/notes",
+      resolvePagePath: createPageResolver()
+    }),
+    ""
+  );
+});
+
+test("resolveMenuLinkTarget keeps absolute targets unchanged", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      to: "/practice/vets",
+      surface: "admin",
+      placementContext: WORKSPACE_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/ignored",
+      nonWorkspaceSuffix: "/ignored",
+      resolvePagePath: createPageResolver()
+    }),
+    "/practice/vets"
+  );
+});
+
+test("resolveMenuLinkTarget uses non-workspace suffix for non-workspace surfaces", () => {
+  assert.equal(
+    resolveMenuLinkTarget({
+      surface: "app",
+      currentSurfaceId: "admin",
+      placementContext: MIXED_PLACEMENT_CONTEXT,
+      workspaceSuffix: "/workspace-only",
+      nonWorkspaceSuffix: "/public-page",
+      resolvePagePath: createPageResolver()
+    }),
+    "page:app:/public-page"
+  );
+});
+
+test("normalizeMenuLinkPathname removes query strings and hashes", () => {
+  assert.equal(normalizeMenuLinkPathname("/practice/vets?tab=all#section"), "/practice/vets");
+});

package/test/permissions.test.js

@@ -30,6 +30,6 @@ test("arePermissionListsEqual returns false for different permission sets", () =
 });
 
 test("hasPermission supports namespace wildcard matches", () => {
-  assert.equal(hasPermission(["crud_contacts.*"], "crud_contacts.update"), true);
-  assert.equal(hasPermission(["crud_contacts.*"], "crud_projects.update"), false);
+  assert.equal(hasPermission(["crud.contacts.*"], "crud.contacts.update"), true);
+  assert.equal(hasPermission(["crud.contacts.*"], "crud.projects.update"), false);
 });

package/test/refValueHelpers.test.js

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { computed, ref } from "vue";
-import { resolveEnabledRef } from "../src/client/composables/refValueHelpers.js";
+import { resolveEnabledRef } from "../src/client/composables/support/refValueHelpers.js";
 
 test("resolveEnabledRef unwraps refs", () => {
   assert.equal(resolveEnabledRef(ref(true)), true);

package/test/resourceLoadStateHelpers.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { hasResolvedQueryData } from "../src/client/composables/resourceLoadStateHelpers.js";
+import { hasResolvedQueryData } from "../src/client/composables/support/resourceLoadStateHelpers.js";
 
 test("hasResolvedQueryData returns true when the query succeeded", () => {
   const query = {

package/test/routeTemplateHelpers.test.js

@@ -2,8 +2,9 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
   extractRouteParamNames,
+  resolveScopedRoutePathname,
   resolveRouteParamNamesInOrder
-} from "../src/client/composables/routeTemplateHelpers.js";
+} from "../src/client/composables/support/routeTemplateHelpers.js";
 
 test("extractRouteParamNames reads dynamic params from route templates", () => {
   assert.deepEqual(
@@ -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/scopeHelpers.test.js

@@ -6,7 +6,7 @@ import {
   normalizeOwnershipFilter,
   resolveApiSuffix,
   resolveResourceMessages
-} from "../src/client/composables/scopeHelpers.js";
+} from "../src/client/composables/support/scopeHelpers.js";
 
 test("resolveResourceMessages merges defaults with resource messages", () => {
   const messages = resolveResourceMessages(