@jskit-ai/users-web 0.1.36 → 0.1.38

package/src/client/composables/{routeTemplateHelpers.js → support/routeTemplateHelpers.js}

@@ -40,6 +40,17 @@ function resolveRouteParamsSource(source = null) {
   return asPlainObject(resolveRouteSourceValue(source));
 }
 
+function normalizeRouteParamNameList(value = []) {
+  const source = Array.isArray(value) ? value : [];
+  return source
+    .map((entry) => String(entry || "").trim())
+    .filter(Boolean);
+}
+
+function resolveRouteParamNamesSource(source = []) {
+  return normalizeRouteParamNameList(resolveRouteSourceValue(source));
+}
+
 function normalizeRoutePathname(value = "") {
   const rawPathname = String(value || "").trim();
   const sanitizedPathname = rawPathname.split(/[?#]/u, 1)[0] || "";
@@ -54,6 +65,115 @@ function resolveRoutePathnameSource(source = "") {
   return normalizeRoutePathname(resolveRouteSourceValue(source));
 }
 
+function segmentMatchesParamValue(segment = "", paramValue = "") {
+  const normalizedSegment = String(segment || "").trim();
+  const normalizedParamValue = toRouteParamValue(paramValue);
+  if (!normalizedSegment || !normalizedParamValue) {
+    return false;
+  }
+
+  const encodedParamValue = encodeURIComponent(normalizedParamValue);
+  if (normalizedSegment === encodedParamValue) {
+    return true;
+  }
+
+  try {
+    return decodeURIComponent(normalizedSegment) === normalizedParamValue;
+  } catch {
+    return false;
+  }
+}
+
+function findRouteParamSegmentIndex(segments = [], paramValue = "", fromIndex = 0) {
+  const source = Array.isArray(segments) ? segments : [];
+  const cursor = Number.isInteger(fromIndex) && fromIndex > 0 ? fromIndex : 0;
+  for (let index = cursor; index < source.length; index += 1) {
+    if (segmentMatchesParamValue(source[index], paramValue)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function normalizePathPrefix(segments = [], endIndex = -1) {
+  const source = Array.isArray(segments) ? segments : [];
+  if (!Number.isInteger(endIndex) || endIndex < 0) {
+    return "/";
+  }
+  return `/${source.slice(0, endIndex + 1).join("/")}`;
+}
+
+function resolveAnchorEndIndex(segmentIndex = -1, totalSegments = 0, anchorMode = "at") {
+  const normalizedSegmentIndex = Number.isInteger(segmentIndex) ? segmentIndex : -1;
+  if (normalizedSegmentIndex < 0) {
+    return -1;
+  }
+
+  const normalizedTotalSegments = Number.isInteger(totalSegments) && totalSegments > 0 ? totalSegments : 0;
+  const normalizedMode = String(anchorMode || "at").trim().toLowerCase();
+  if (normalizedMode === "before") {
+    return normalizedSegmentIndex - 1;
+  }
+  if (normalizedMode === "after") {
+    return normalizedTotalSegments > 0
+      ? Math.min(normalizedSegmentIndex + 1, normalizedTotalSegments - 1)
+      : normalizedSegmentIndex + 1;
+  }
+
+  return normalizedSegmentIndex;
+}
+
+function resolveScopedRoutePathname({
+  currentPathname = "/",
+  params = {},
+  orderedParamNames = [],
+  anchorParamName = "",
+  anchorParamValue = "",
+  anchorMode = "at"
+} = {}) {
+  const normalizedCurrentPathname = resolveRoutePathnameSource(currentPathname);
+  const normalizedAnchorParamName = String(anchorParamName || "").trim();
+  if (!normalizedAnchorParamName) {
+    return normalizedCurrentPathname;
+  }
+
+  const sourceParams = asPlainObject(params);
+  const segments = normalizedCurrentPathname.split("/").filter(Boolean);
+  if (segments.length < 1) {
+    return normalizedCurrentPathname;
+  }
+
+  const paramNames = resolveRouteParamNamesSource(orderedParamNames);
+  let cursor = 0;
+  for (const paramName of paramNames) {
+    const segmentIndex = findRouteParamSegmentIndex(segments, sourceParams[paramName], cursor);
+    if (segmentIndex < 0) {
+      continue;
+    }
+
+    if (paramName === normalizedAnchorParamName) {
+      const endIndex = resolveAnchorEndIndex(segmentIndex, segments.length, anchorMode);
+      return normalizePathPrefix(segments, endIndex);
+    }
+
+    cursor = segmentIndex + 1;
+  }
+
+  const fallbackAnchorValue = toRouteParamValue(anchorParamValue) ||
+    toRouteParamValue(sourceParams[normalizedAnchorParamName]);
+  if (!fallbackAnchorValue) {
+    return normalizedCurrentPathname;
+  }
+
+  const fallbackSegmentIndex = findRouteParamSegmentIndex(segments, fallbackAnchorValue, 0);
+  if (fallbackSegmentIndex < 0) {
+    return normalizedCurrentPathname;
+  }
+
+  const fallbackEndIndex = resolveAnchorEndIndex(fallbackSegmentIndex, segments.length, anchorMode);
+  return normalizePathPrefix(segments, fallbackEndIndex);
+}
+
 function resolveRouteTemplatePath(routeTemplate = "", params = {}) {
   const normalizedTemplate = String(routeTemplate || "").trim();
   if (!normalizedTemplate) {
@@ -155,7 +275,9 @@ export {
   normalizeRouteParamName,
   toRouteParamValue,
   resolveRouteParamsSource,
+  resolveRouteParamNamesSource,
   resolveRoutePathnameSource,
+  resolveScopedRoutePathname,
   resolveRouteTemplatePath,
   resolveRouteTemplateLocation,
   extractRouteParamNames,

package/src/client/composables/useAccess.js

@@ -1,10 +1,10 @@
 import { computed } from "vue";
 import { hasPermission, normalizePermissionList } from "../lib/permissions.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "./support/refValueHelpers.js";
 import {
   normalizeAccessMode,
   resolveAccessModeEnabled
-} from "./scopeHelpers.js";
+} from "./support/scopeHelpers.js";
 import { useWebPlacementContext } from "@jskit-ai/shell-web/client/placement";
 
 function asPermissionList(value) {

package/src/client/composables/useAccountSettingsRuntime.js

@@ -19,9 +19,9 @@ import {
 import {
   useWorkspaceSurfaceId
 } from "./useWorkspaceSurfaceId.js";
-import { useAddEdit } from "./useAddEdit.js";
+import { useAddEdit } from "./records/useAddEdit.js";
 import { useCommand } from "./useCommand.js";
-import { useView } from "./useView.js";
+import { useView } from "./records/useView.js";
 import { usePaths } from "./usePaths.js";
 import { resolveAccountSettingsPathFromPlacementContext } from "../lib/workspaceSurfacePaths.js";
 import {
@@ -34,16 +34,16 @@ import {
   NUMBER_FORMAT_OPTIONS,
   THEME_OPTIONS,
   TIME_ZONE_OPTIONS
-} from "./accountSettingsRuntimeConstants.js";
+} from "./account-settings/accountSettingsRuntimeConstants.js";
 import {
   normalizeAvatarSize,
   normalizePendingInvite,
   normalizeReturnToPath,
   normalizeSettingsPayload,
   resolveAllowedReturnToOrigins
-} from "./accountSettingsRuntimeHelpers.js";
-import { createAccountSettingsAvatarUploadRuntime } from "./accountSettingsAvatarUploadRuntime.js";
-import { createAccountSettingsInvitesRuntime } from "./accountSettingsInvitesRuntime.js";
+} from "./account-settings/accountSettingsRuntimeHelpers.js";
+import { createAccountSettingsAvatarUploadRuntime } from "./account-settings/accountSettingsAvatarUploadRuntime.js";
+import { createAccountSettingsInvitesRuntime } from "./account-settings/accountSettingsInvitesRuntime.js";
 
 function useAccountSettingsRuntime() {
   const route = useRoute();

package/src/client/composables/useBootstrapQuery.js

@@ -5,7 +5,7 @@ import { useQuery } from "@tanstack/vue-query";
 import { normalizeQueryToken } from "@jskit-ai/kernel/shared/support/normalize";
 import { usersWebHttpClient } from "../lib/httpClient.js";
 import { buildBootstrapApiPath } from "../lib/bootstrap.js";
-import { resolveEnabledRef, resolveTextRef } from "./refValueHelpers.js";
+import { resolveEnabledRef, resolveTextRef } from "./support/refValueHelpers.js";
 
 const DEFAULT_BOOTSTRAP_STALE_TIME_MS = 60_000;
 

package/src/client/composables/useCommand.js

@@ -1,14 +1,14 @@
 import { proxyRefs } from "vue";
 import { USERS_ROUTE_VISIBILITY_WORKSPACE } from "@jskit-ai/users-core/shared/support/usersVisibility";
-import { useCommandCore } from "./useCommandCore.js";
-import { useEndpointResource } from "./useEndpointResource.js";
+import { useCommandCore } from "./runtime/useCommandCore.js";
+import { useEndpointResource } from "./runtime/useEndpointResource.js";
 import { useOperationScope } from "./internal/useOperationScope.js";
-import { useUiFeedback } from "./useUiFeedback.js";
-import { useFieldErrorBag } from "./useFieldErrorBag.js";
+import { useUiFeedback } from "./runtime/useUiFeedback.js";
+import { useFieldErrorBag } from "./runtime/useFieldErrorBag.js";
 import {
   setupRouteChangeCleanup,
   setupOperationErrorReporting
-} from "./operationUiHelpers.js";
+} from "./runtime/operationUiHelpers.js";
 
 function useCommand({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,

package/src/client/composables/useCrudListParentTitle.js

@@ -0,0 +1,131 @@
+import { computed, proxyRefs } from "vue";
+import { useRoute } from "vue-router";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  resolveRouteParamsSource,
+  toRouteParamValue
+} from "./support/routeTemplateHelpers.js";
+import { useView } from "./records/useView.js";
+import {
+  resolveCrudListParentDescriptor,
+  resolveCrudListParentRecordTitle,
+  resolveCrudListParentTitleFromItems
+} from "./internal/crudListParentTitleSupport.js";
+
+function normalizeQueryKeyPrefix(value = []) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => normalizeText(entry))
+      .filter(Boolean);
+  }
+
+  const normalizedValue = normalizeText(value);
+  return normalizedValue ? [normalizedValue] : [];
+}
+
+function useCrudListParentTitle({
+  listRuntime = null,
+  resource = {},
+  adapter = null,
+  recordIdParam = "recordId",
+  queryKeyPrefix = ["users-web", "crud-list-parent-title"],
+  placementSource = "users-web.crud-list-parent-title",
+  fallbackLoadError = "Unable to load parent record.",
+  notFoundMessage = "Parent record not found.",
+  route = null,
+  viewRuntimeFactory = useView
+} = {}) {
+  const sourceRoute = route && typeof route === "object" ? route : useRoute();
+  const parentDescriptor = computed(() => {
+    const descriptor = resolveCrudListParentDescriptor({
+      resource,
+      route: sourceRoute,
+      recordIdParam
+    });
+    if (!descriptor) {
+      return null;
+    }
+
+    const routeParams = resolveRouteParamsSource(sourceRoute?.params || {});
+    const routeParamValue = toRouteParamValue(routeParams[descriptor.routeParamKey]);
+    if (!routeParamValue) {
+      return null;
+    }
+
+    return Object.freeze({
+      ...descriptor,
+      routeParamValue
+    });
+  });
+
+  const initialParentDescriptor = parentDescriptor.value || {};
+  const normalizedQueryKeyPrefix = normalizeQueryKeyPrefix(queryKeyPrefix);
+  const shouldLoadParentRecord = computed(() => {
+    const descriptor = parentDescriptor.value;
+    if (!descriptor?.apiUrlTemplate) {
+      return false;
+    }
+    if (Boolean(listRuntime?.isInitialLoading) || normalizeText(listRuntime?.loadError)) {
+      return false;
+    }
+
+    const items = Array.isArray(listRuntime?.items) ? listRuntime.items : [];
+    return items.length < 1;
+  });
+
+  const parentView = viewRuntimeFactory({
+    adapter,
+    apiUrlTemplate: normalizeText(initialParentDescriptor.apiUrlTemplate),
+    readEnabled: shouldLoadParentRecord,
+    recordIdParam: normalizeText(initialParentDescriptor.routeParamKey) || "recordId",
+    includeRecordIdInQueryKey: true,
+    queryKeyFactory: (surfaceId = "", workspaceSlug = "") => [
+      ...normalizedQueryKeyPrefix,
+      normalizeText(initialParentDescriptor.relationNamespace),
+      normalizeText(initialParentDescriptor.routeParamKey),
+      String(surfaceId || ""),
+      String(workspaceSlug || "")
+    ],
+    placementSource,
+    fallbackLoadError,
+    notFoundMessage
+  });
+
+  const title = computed(() => {
+    const descriptor = parentDescriptor.value;
+    if (!descriptor) {
+      return "";
+    }
+
+    const parentRecordTitle = resolveCrudListParentRecordTitle(parentView?.record || {}, descriptor);
+    if (parentRecordTitle && shouldLoadParentRecord.value) {
+      return parentRecordTitle;
+    }
+
+    const listTitle = resolveCrudListParentTitleFromItems(listRuntime?.items, descriptor);
+    if (listTitle) {
+      return listTitle;
+    }
+
+    if (parentRecordTitle) {
+      return parentRecordTitle;
+    }
+
+    if (descriptor.routeParamValue) {
+      return `${descriptor.entityLabel} #${descriptor.routeParamValue}`;
+    }
+
+    return descriptor.entityLabel;
+  });
+
+  return proxyRefs({
+    title,
+    descriptor: parentDescriptor,
+    shouldLoadParentRecord,
+    record: computed(() => parentView?.record || null),
+    isLoading: computed(() => Boolean(parentView?.isLoading)),
+    loadError: computed(() => normalizeText(parentView?.loadError))
+  });
+}
+
+export { useCrudListParentTitle };

package/src/client/composables/usePagedCollection.js

@@ -1,8 +1,8 @@
-import { computed } from "vue";
-import { useInfiniteQuery } from "@tanstack/vue-query";
-import { asPlainObject } from "./scopeHelpers.js";
-import { resolveEnabledRef } from "./refValueHelpers.js";
-import { toQueryErrorMessage } from "./errorMessageHelpers.js";
+import { computed, unref } from "vue";
+import { useInfiniteQuery, useQueryClient } from "@tanstack/vue-query";
+import { asPlainObject } from "./support/scopeHelpers.js";
+import { resolveEnabledRef } from "./support/refValueHelpers.js";
+import { toQueryErrorMessage } from "./support/errorMessageHelpers.js";
 
 function defaultSelectItems(page) {
   return Array.isArray(page?.items) ? page.items : [];
@@ -12,6 +12,42 @@ function defaultGetNextPageParam(lastPage) {
   return lastPage?.nextCursor ?? null;
 }
 
+function normalizeQueryKeyValue(queryKey = null) {
+  const resolved = unref(queryKey);
+  if (Array.isArray(resolved)) {
+    return resolved;
+  }
+  if (resolved === null || resolved === undefined || resolved === "") {
+    return [];
+  }
+
+  return [resolved];
+}
+
+function trimInfinitePagesToFirst(data = null) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return data;
+  }
+
+  const sourcePages = Array.isArray(data.pages) ? data.pages : [];
+  const sourcePageParams = Array.isArray(data.pageParams) ? data.pageParams : [];
+  if (sourcePages.length < 2 && sourcePageParams.length < 2) {
+    return data;
+  }
+  const pages = sourcePages.slice(0, 1);
+  const pageParams = sourcePageParams.length > 0
+    ? sourcePageParams.slice(0, 1)
+    : pages.length > 0
+      ? [null]
+      : [];
+
+  return {
+    ...data,
+    pages,
+    pageParams
+  };
+}
+
 function usePagedCollection({
   queryKey,
   enabled = true,
@@ -36,7 +72,9 @@ function usePagedCollection({
     throw new TypeError("usePagedCollection dedupeBy must be a function when provided.");
   }
 
+  const queryClient = useQueryClient();
   const queryEnabled = computed(() => resolveEnabledRef(enabled));
+  const normalizedQueryKey = computed(() => normalizeQueryKeyValue(queryKey));
 
   const query = useInfiniteQuery({
     queryKey,
@@ -106,6 +144,15 @@ function usePagedCollection({
     return query.fetchNextPage();
   }
 
+  function trimToFirstPage() {
+    const key = normalizedQueryKey.value;
+    if (key.length < 1) {
+      return;
+    }
+
+    queryClient.setQueryData(key, (data) => trimInfinitePagesToFirst(data));
+  }
+
   return Object.freeze({
     query,
     pages,
@@ -118,8 +165,12 @@ function usePagedCollection({
     hasMore,
     loadError,
     reload,
-    loadMore
+    loadMore,
+    trimToFirstPage
   });
 }
 
-export { usePagedCollection };
+export {
+  usePagedCollection,
+  trimInfinitePagesToFirst
+};

package/src/client/composables/useScopeRuntime.js

@@ -11,7 +11,7 @@ import {
   resolveAccessModeEnabled,
   normalizeOwnershipFilter,
   resolveApiSuffix
-} from "./scopeHelpers.js";
+} from "./support/scopeHelpers.js";
 
 function useScopeRuntime({
   ownershipFilter = USERS_ROUTE_VISIBILITY_WORKSPACE,

package/src/client/lib/bootstrap.js

@@ -30,7 +30,7 @@ function normalizeWorkspaceEntry(entry) {
     surfaceColor: String(entry.surfaceColor || "").trim(),
     surfaceVariantColor: String(entry.surfaceVariantColor || "").trim(),
     avatarUrl: String(entry.avatarUrl || "").trim(),
-    roleId: String(entry.roleId || "member").trim().toLowerCase() || "member",
+    roleSid: String(entry.roleSid || "member").trim().toLowerCase() || "member",
     isAccessible: entry.isAccessible !== false
   });
 }

package/src/client/lib/menuIcons.js

@@ -1,3 +1,4 @@
+import * as mdiIcons from "@mdi/js";
 import {
   mdiAccountCircleOutline,
   mdiAccountCogOutline,
@@ -26,6 +27,26 @@ const SURFACE_SWITCH_ICON_BY_ID = Object.freeze({
   console: mdiConsoleNetworkOutline
 });
 
+function resolveExplicitIconValue(explicitIcon = "") {
+  const normalizedExplicitIcon = normalizeText(explicitIcon);
+  if (!normalizedExplicitIcon) {
+    return "";
+  }
+
+  if (!normalizedExplicitIcon.startsWith("mdi-")) {
+    return normalizedExplicitIcon;
+  }
+
+  const iconKey = normalizedExplicitIcon
+    .slice("mdi-".length)
+    .split("-")
+    .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join("");
+  const exportName = `mdi${iconKey}`;
+  const resolvedIcon = mdiIcons[exportName];
+  return typeof resolvedIcon === "string" && resolvedIcon ? resolvedIcon : normalizedExplicitIcon;
+}
+
 function normalizePathname(value) {
   const normalizedValue = normalizeText(value);
   if (!normalizedValue) {
@@ -70,9 +91,9 @@ function resolveSurfaceSwitchIdFromLabel(label = "") {
 }
 
 function resolveSurfaceSwitchIcon(surfaceId = "", explicitIcon = "") {
-  const normalizedExplicitIcon = normalizeText(explicitIcon);
-  if (normalizedExplicitIcon) {
-    return normalizedExplicitIcon;
+  const resolvedExplicitIcon = resolveExplicitIconValue(explicitIcon);
+  if (resolvedExplicitIcon) {
+    return resolvedExplicitIcon;
   }
 
   const normalizedSurfaceId = normalizeText(surfaceId).toLowerCase();
@@ -80,9 +101,9 @@ function resolveSurfaceSwitchIcon(surfaceId = "", explicitIcon = "") {
 }
 
 function resolveMenuLinkIcon({ icon = "", label = "", to = "" } = {}) {
-  const normalizedIcon = normalizeText(icon);
-  if (normalizedIcon) {
-    return normalizedIcon;
+  const resolvedExplicitIcon = resolveExplicitIconValue(icon);
+  if (resolvedExplicitIcon) {
+    return resolvedExplicitIcon;
   }
 
   const normalizedLabel = normalizeText(label).toLowerCase();

package/src/client/support/menuLinkTarget.js

@@ -0,0 +1,93 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { surfaceRequiresWorkspaceFromPlacementContext } from "../lib/workspaceSurfaceContext.js";
+
+function normalizeMenuLinkPathname(pathname = "") {
+  const source = String(pathname || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const queryIndex = source.indexOf("?");
+  const hashIndex = source.indexOf("#");
+  const cutoff =
+    queryIndex < 0
+      ? hashIndex
+      : hashIndex < 0
+        ? queryIndex
+        : Math.min(queryIndex, hashIndex);
+
+  return cutoff < 0 ? source : source.slice(0, cutoff);
+}
+
+function resolveMenuLinkSurfaceId(surface = "", fallbackSurfaceId = "") {
+  const explicitSurface = normalizeText(surface).toLowerCase();
+  if (explicitSurface && explicitSurface !== "*") {
+    return explicitSurface;
+  }
+
+  return normalizeText(fallbackSurfaceId).toLowerCase();
+}
+
+function interpolateBracketParams(pathTemplate = "", params = {}) {
+  const source = String(pathTemplate || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  return source.replace(/\[([^\]]+)\]/g, (_match, rawKey) => {
+    const key = String(rawKey || "").trim();
+    if (!key) {
+      return "";
+    }
+
+    const value = params?.[key];
+    return value == null ? `[${key}]` : encodeURIComponent(String(value));
+  });
+}
+
+function isRelativeMenuLinkTarget(target = "") {
+  const normalizedTarget = normalizeText(target);
+  return normalizedTarget.startsWith("./") || normalizedTarget.startsWith("../");
+}
+
+function resolveMenuLinkTarget({
+  to = "",
+  surface = "",
+  currentSurfaceId = "",
+  placementContext = null,
+  workspaceSuffix = "/",
+  nonWorkspaceSuffix = "/",
+  routeParams = {},
+  resolvePagePath = null
+} = {}) {
+  const explicitTarget = normalizeText(to);
+  const targetSurfaceId = resolveMenuLinkSurfaceId(surface, currentSurfaceId);
+  const workspaceRequired = surfaceRequiresWorkspaceFromPlacementContext(placementContext, targetSurfaceId);
+  const suffixTemplate = normalizeText(workspaceRequired ? workspaceSuffix : nonWorkspaceSuffix) || "/";
+  const interpolatedSuffix = interpolateBracketParams(suffixTemplate, routeParams);
+  const resolvedSuffixTarget =
+    typeof resolvePagePath === "function" &&
+    targetSurfaceId &&
+    interpolatedSuffix &&
+    !interpolatedSuffix.includes("[")
+      ? normalizeText(resolvePagePath(interpolatedSuffix, {
+          surface: targetSurfaceId,
+          mode: "auto"
+        }))
+      : "";
+
+  if (!explicitTarget) {
+    return resolvedSuffixTarget;
+  }
+
+  if (isRelativeMenuLinkTarget(explicitTarget)) {
+    return resolvedSuffixTarget;
+  }
+
+  return explicitTarget;
+}
+
+export {
+  normalizeMenuLinkPathname,
+  resolveMenuLinkTarget
+};

package/templates/src/components/WorkspaceNotFoundCard.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { mdiAlertCircleOutline } from "@mdi/js";
 import { computed } from "vue";
 
 const props = defineProps({
@@ -20,7 +21,7 @@ const normalizedMessage = computed(() => String(props.message || "").trim() || "
   <v-card rounded="lg" elevation="1" border>
     <v-card-item>
       <template #prepend>
-        <v-icon icon="mdi-alert-circle-outline" color="error" />
+        <v-icon :icon="mdiAlertCircleOutline" color="error" />
       </template>
       <v-card-title class="text-h5">Unavailable</v-card-title>
       <v-card-subtitle>{{ normalizedSurfaceLabel }} surface.</v-card-subtitle>

package/templates/src/components/account/settings/AccountSettingsInvitesSection.vue

@@ -33,7 +33,7 @@ const invites = props.runtime.invites;
             v-for="invite in invites.items.value"
             :key="invite.id"
             :title="invite.workspaceName"
-            :subtitle="`/${invite.workspaceSlug} • role: ${invite.roleId}`"
+            :subtitle="`/${invite.workspaceSlug} • role: ${invite.roleSid}`"
             class="px-0"
           >
             <template #prepend>

package/test/addEditUiRuntime.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { ref } from "vue";
-import { createAddEditUiRuntime } from "../src/client/composables/addEditUiRuntime.js";
+import { createAddEditUiRuntime } from "../src/client/composables/runtime/addEditUiRuntime.js";
 
 test("createAddEditUiRuntime resolves api/list/cancel paths from route params", () => {
   const runtime = createAddEditUiRuntime({
@@ -51,6 +51,24 @@ test("createAddEditUiRuntime resolves edit-page relative list and cancel links",
   assert.equal(runtime.cancelUrl.value, "/contacts/7/addresses/42");
 });
 
+test("createAddEditUiRuntime resolves nested edit links from the record scope", () => {
+  const runtime = createAddEditUiRuntime({
+    recordIdParam: "petId",
+    routeParams: ref({
+      workspaceSlug: "dogandgroom",
+      contactId: "541841",
+      petId: "715528"
+    }),
+    routeParamNames: ref(["workspaceSlug", "contactId", "petId"]),
+    routePath: ref("/w/dogandgroom/admin/contacts/541841/pets/715528/edit/advanced"),
+    viewUrlTemplate: "..",
+    listUrlTemplate: "../.."
+  });
+
+  assert.equal(runtime.cancelUrl.value, "/w/dogandgroom/admin/contacts/541841/pets/715528");
+  assert.equal(runtime.listUrl.value, "/w/dogandgroom/admin/contacts/541841/pets");
+});
+
 test("createAddEditUiRuntime supports custom saved-record selector", () => {
   const runtime = createAddEditUiRuntime({
     recordIdParam: "addressId",