@jskit-ai/users-web 0.1.4

package/src/client/lib/workspaceLinkResolver.js

@@ -0,0 +1,207 @@
+import { unref } from "vue";
+import { resolveLinkPath } from "@jskit-ai/kernel/shared";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import {
+  useWebPlacementContext,
+  resolveRuntimePathname,
+  resolveSurfaceDefinitionFromPlacementContext,
+  resolveSurfaceIdFromPlacementPathname,
+  resolveSurfaceRootPathFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+import {
+  resolveWorkspaceSurfaceIdFromPlacementPathname,
+  resolveSurfaceWorkspacePathFromPlacementContext,
+  extractWorkspaceSlugFromSurfacePathname
+} from "./workspaceSurfacePaths.js";
+import { surfaceRequiresWorkspaceFromPlacementContext } from "./workspaceSurfaceContext.js";
+import { parseWorkspacePathname } from "@jskit-ai/users-core/shared/support/workspacePathModel";
+
+function resolveSurfaceBasePath(context = null, surface = "") {
+  const normalizedSurface = normalizeSurfaceId(surface);
+  if (!normalizedSurface) {
+    return "";
+  }
+
+  if (!resolveSurfaceDefinitionFromPlacementContext(context, normalizedSurface)) {
+    return "";
+  }
+
+  return resolveSurfaceRootPathFromPlacementContext(context, normalizedSurface);
+}
+
+function resolveWorkspaceSlugFromContextOrPath({
+  context = null,
+  surface = "",
+  workspaceSlug = "",
+  pathname = ""
+} = {}) {
+  const explicitWorkspaceSlug = String(workspaceSlug || "").trim();
+  if (explicitWorkspaceSlug) {
+    return explicitWorkspaceSlug;
+  }
+
+  const workspaceSlugFromContext = String(context?.workspace?.slug || "").trim();
+  if (workspaceSlugFromContext) {
+    return workspaceSlugFromContext;
+  }
+
+  const currentPathname = resolveRuntimePathname(pathname);
+  const workspaceSlugFromPath = String(parseWorkspacePathname(currentPathname)?.workspaceSlug || "").trim();
+  if (workspaceSlugFromPath) {
+    return workspaceSlugFromPath;
+  }
+
+  const normalizedSurface = normalizeSurfaceId(surface);
+  const workspaceSurfaceId = resolveWorkspaceSurfaceIdFromPlacementPathname(context, currentPathname);
+  const surfaceIdFromPath = workspaceSurfaceId || resolveSurfaceIdFromPlacementPathname(context, currentPathname);
+  const activeSurfaceId = normalizeSurfaceId(surfaceIdFromPath || normalizedSurface);
+  if (!activeSurfaceId) {
+    return "";
+  }
+
+  return String(extractWorkspaceSlugFromSurfacePathname(context, activeSurfaceId, currentPathname) || "").trim();
+}
+
+function resolveWorkspaceBasePath(context = null, surface = "", workspaceSlug = "") {
+  const normalizedSurface = normalizeSurfaceId(surface);
+  const normalizedWorkspaceSlug = String(workspaceSlug || "").trim();
+  if (!normalizedSurface || !normalizedWorkspaceSlug) {
+    return "";
+  }
+
+  if (!resolveSurfaceDefinitionFromPlacementContext(context, normalizedSurface)) {
+    return "";
+  }
+
+  if (!surfaceRequiresWorkspaceFromPlacementContext(context, normalizedSurface)) {
+    return resolveSurfaceBasePath(context, normalizedSurface);
+  }
+
+  return resolveSurfaceWorkspacePathFromPlacementContext(context, normalizedSurface, normalizedWorkspaceSlug, "/");
+}
+
+function resolveWorkspaceShellLinkPath({
+  context = null,
+  surface = "",
+  mode = "auto",
+  explicitTo = "",
+  relativePath = "/",
+  workspaceRelativePath = "",
+  surfaceRelativePath = "",
+  workspaceSlug = "",
+  pathname = ""
+} = {}) {
+  const explicitTarget = String(explicitTo || "").trim();
+  if (explicitTarget) {
+    return explicitTarget;
+  }
+
+  const normalizedSurface = normalizeSurfaceId(surface);
+  const normalizedMode = String(mode || "auto").trim().toLowerCase();
+  const hasSurfaceDefinition = Boolean(
+    normalizedSurface && resolveSurfaceDefinitionFromPlacementContext(context, normalizedSurface)
+  );
+  if (!hasSurfaceDefinition) {
+    return "";
+  }
+
+  const resolvedWorkspaceSlug = resolveWorkspaceSlugFromContextOrPath({
+    context,
+    surface: normalizedSurface,
+    workspaceSlug,
+    pathname
+  });
+
+  const nextWorkspaceRelativePath = String(workspaceRelativePath || "").trim() || String(relativePath || "").trim() || "/";
+  const nextSurfaceRelativePath = String(surfaceRelativePath || "").trim() || String(relativePath || "").trim() || "/";
+  const nextSurfaceBasePath = resolveSurfaceBasePath(context, normalizedSurface);
+
+  if (normalizedMode === "surface") {
+    return resolveLinkPath(nextSurfaceBasePath, nextSurfaceRelativePath);
+  }
+
+  if (normalizedMode === "workspace") {
+    if (!surfaceRequiresWorkspaceFromPlacementContext(context, normalizedSurface)) {
+      return resolveLinkPath(nextSurfaceBasePath, nextSurfaceRelativePath);
+    }
+    if (!resolvedWorkspaceSlug) {
+      return "";
+    }
+    const workspaceBasePath = resolveWorkspaceBasePath(context, normalizedSurface, resolvedWorkspaceSlug);
+    if (!workspaceBasePath) {
+      return "";
+    }
+    return resolveLinkPath(
+      workspaceBasePath,
+      nextWorkspaceRelativePath
+    );
+  }
+
+  if (surfaceRequiresWorkspaceFromPlacementContext(context, normalizedSurface)) {
+    if (!resolvedWorkspaceSlug) {
+      return "";
+    }
+    const workspaceBasePath = resolveWorkspaceBasePath(context, normalizedSurface, resolvedWorkspaceSlug);
+    if (!workspaceBasePath) {
+      return "";
+    }
+    return resolveLinkPath(
+      workspaceBasePath,
+      nextWorkspaceRelativePath
+    );
+  }
+
+  return resolveLinkPath(nextSurfaceBasePath, nextSurfaceRelativePath);
+}
+
+function useWorkspaceLinkResolver({ surface = "", workspaceSlug = "", pathname = "" } = {}) {
+  const { context: placementContext } = useWebPlacementContext();
+
+  function resolve(relativePath = "/", options = {}) {
+    return resolveWorkspaceShellLinkPath({
+      context: placementContext.value,
+      surface: String(unref(options.surface ?? surface) || ""),
+      workspaceSlug: String(unref(options.workspaceSlug ?? workspaceSlug) || ""),
+      pathname: String(unref(options.pathname ?? pathname) || ""),
+      mode: String(options.mode || "auto"),
+      explicitTo: options.explicitTo,
+      relativePath,
+      workspaceRelativePath: options.workspaceRelativePath,
+      surfaceRelativePath: options.surfaceRelativePath
+    });
+  }
+
+  function toSurface(relativePath = "/", options = {}) {
+    return resolve(relativePath, {
+      ...options,
+      mode: "surface"
+    });
+  }
+
+  function toWorkspace(relativePath = "/", options = {}) {
+    return resolve(relativePath, {
+      ...options,
+      mode: "workspace"
+    });
+  }
+
+  function toAuto(relativePath = "/", options = {}) {
+    return resolve(relativePath, {
+      ...options,
+      mode: "auto"
+    });
+  }
+
+  return Object.freeze({
+    resolve,
+    toSurface,
+    toWorkspace,
+    toAuto
+  });
+}
+
+export {
+  resolveWorkspaceSlugFromContextOrPath,
+  resolveWorkspaceShellLinkPath,
+  useWorkspaceLinkResolver
+};

package/src/client/lib/workspaceSurfaceContext.js

@@ -0,0 +1,82 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface";
+import {
+  readPlacementSurfaceConfig,
+  resolveSurfaceDefinitionFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+
+function listWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig = null) {
+  return listSurfaceIdsFromSurfaceConfig(surfaceConfig, {
+    requiresWorkspace: true
+  });
+}
+
+function listNonWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig = null) {
+  return listSurfaceIdsFromSurfaceConfig(surfaceConfig, {
+    requiresWorkspace: false
+  });
+}
+
+function listSurfaceIdsFromSurfaceConfig(surfaceConfig = null, { requiresWorkspace = null } = {}) {
+  const source = surfaceConfig && typeof surfaceConfig === "object" ? surfaceConfig : {};
+  const enabledSurfaceIds = Array.isArray(source.enabledSurfaceIds) ? source.enabledSurfaceIds : [];
+  const surfacesById = source.surfacesById && typeof source.surfacesById === "object" ? source.surfacesById : {};
+
+  const result = [];
+  for (const candidate of enabledSurfaceIds) {
+    const surfaceId = normalizeSurfaceId(candidate);
+    if (!surfaceId) {
+      continue;
+    }
+    const surfaceRequiresWorkspace = surfacesById[surfaceId]?.requiresWorkspace === true;
+    if (requiresWorkspace === true && !surfaceRequiresWorkspace) {
+      continue;
+    }
+    if (requiresWorkspace === false && surfaceRequiresWorkspace) {
+      continue;
+    }
+    result.push(surfaceId);
+  }
+  return result;
+}
+
+function surfaceRequiresWorkspaceFromPlacementContext(contextValue = null, surfaceId = "") {
+  return Boolean(resolveSurfaceDefinitionFromPlacementContext(contextValue, surfaceId)?.requiresWorkspace);
+}
+
+function firstAlternativeSurfaceId(surfaceIds = [], excludeSurfaceId = "") {
+  const normalizedExcludeSurfaceId = normalizeSurfaceId(excludeSurfaceId);
+  for (const candidate of Array.isArray(surfaceIds) ? surfaceIds : []) {
+    const surfaceId = normalizeSurfaceId(candidate);
+    if (!surfaceId || surfaceId === normalizedExcludeSurfaceId) {
+      continue;
+    }
+    return surfaceId;
+  }
+  return "";
+}
+
+function resolveSurfaceSwitchTargetsFromPlacementContext(contextValue = null, surfaceId = "") {
+  const surfaceConfig = readPlacementSurfaceConfig(contextValue);
+  const currentSurface = resolveSurfaceDefinitionFromPlacementContext(contextValue, surfaceId);
+  const currentSurfaceId = normalizeSurfaceId(currentSurface?.id);
+  const defaultSurfaceId = normalizeSurfaceId(surfaceConfig.defaultSurfaceId);
+  const defaultSurface = defaultSurfaceId ? surfaceConfig.surfacesById[defaultSurfaceId] || null : null;
+  const workspaceSurfaceIds = listWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig);
+  const nonWorkspaceSurfaceIds = listNonWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig);
+
+  return Object.freeze({
+    surfaceConfig,
+    currentSurfaceId,
+    currentSurface,
+    defaultSurfaceId,
+    defaultSurface,
+    workspaceSurfaceId: firstAlternativeSurfaceId(workspaceSurfaceIds, currentSurfaceId),
+    nonWorkspaceSurfaceId: firstAlternativeSurfaceId(nonWorkspaceSurfaceIds, currentSurfaceId)
+  });
+}
+
+export {
+  listWorkspaceSurfaceIdsFromSurfaceConfig,
+  surfaceRequiresWorkspaceFromPlacementContext,
+  resolveSurfaceSwitchTargetsFromPlacementContext
+};

package/src/client/lib/workspaceSurfacePaths.js

@@ -0,0 +1,163 @@
+import {
+  normalizeSurfaceId
+} from "@jskit-ai/kernel/shared/surface";
+import {
+  normalizePathname,
+  normalizeSurfaceSegmentFromRouteBase,
+  parseWorkspacePathname,
+  resolveDefaultWorkspaceSurfaceId,
+  resolveWorkspaceSurfaceIdFromSuffixSegments
+} from "@jskit-ai/users-core/shared/support/workspacePathModel";
+import {
+  readPlacementSurfaceConfig,
+  resolveSurfaceDefinitionFromPlacementContext,
+  resolveSurfacePathFromPlacementContext,
+  resolveSurfaceRootPathFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+import {
+  listWorkspaceSurfaceIdsFromSurfaceConfig,
+  surfaceRequiresWorkspaceFromPlacementContext
+} from "./workspaceSurfaceContext.js";
+
+const ACCOUNT_SURFACE_ID = "account";
+const ACCOUNT_SETTINGS_SUFFIX = "/";
+const ACCOUNT_SETTINGS_FALLBACK_PATH = "/account";
+
+function normalizeWorkspaceSuffix(suffix) {
+  const rawSuffix = String(suffix || "/").trim();
+  if (!rawSuffix || rawSuffix === "/") {
+    return "/";
+  }
+  return rawSuffix.startsWith("/") ? rawSuffix : `/${rawSuffix}`;
+}
+
+function resolveWorkspaceSurfaceIdFromSurfaceConfig(surfaceConfig, pathname = "") {
+  const parsedWorkspacePath = parseWorkspacePathname(pathname, {
+    workspaceBasePath: "/w"
+  });
+  if (!parsedWorkspacePath) {
+    return "";
+  }
+
+  const workspaceSurfaceIds = listWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig);
+  const defaultWorkspaceSurfaceId = resolveDefaultWorkspaceSurfaceId({
+    defaultSurfaceId: surfaceConfig?.defaultSurfaceId,
+    workspaceSurfaceIds,
+    surfaceRequiresWorkspace: (surfaceId) => Boolean(surfaceConfig?.surfacesById?.[surfaceId]?.requiresWorkspace)
+  });
+  if (parsedWorkspacePath.suffixSegments.length < 1) {
+    return defaultWorkspaceSurfaceId || normalizeSurfaceId(surfaceConfig?.defaultSurfaceId);
+  }
+
+  const workspaceSurfaces = workspaceSurfaceIds
+    .map((surfaceId) => normalizeSurfaceId(surfaceId))
+    .map((surfaceId) => {
+      if (!surfaceId) {
+        return null;
+      }
+      const definition = surfaceConfig.surfacesById?.[surfaceId];
+      return {
+        id: surfaceId,
+        routeBase: definition?.routeBase
+      };
+    })
+    .filter(Boolean);
+
+  return (
+    resolveWorkspaceSurfaceIdFromSuffixSegments({
+      suffixSegments: parsedWorkspacePath.suffixSegments,
+      defaultWorkspaceSurfaceId,
+      workspaceSurfaces
+    }) ||
+    defaultWorkspaceSurfaceId ||
+    normalizeSurfaceId(surfaceConfig?.defaultSurfaceId)
+  );
+}
+
+function resolveWorkspaceSurfaceIdFromPlacementPathname(contextValue = null, pathname = "") {
+  const surfaceConfig = readPlacementSurfaceConfig(contextValue);
+  const normalizedPathname =
+    normalizePathname(pathname) ||
+    (typeof window === "object" && window?.location?.pathname ? normalizePathname(window.location.pathname) : "/");
+
+  return resolveWorkspaceSurfaceIdFromSurfaceConfig(surfaceConfig, normalizedPathname);
+}
+
+function resolveAccountSettingsPathFromPlacementContext(contextValue = null) {
+  const accountSurfaceDefinition = resolveSurfaceDefinitionFromPlacementContext(contextValue, ACCOUNT_SURFACE_ID);
+  if (!accountSurfaceDefinition) {
+    return ACCOUNT_SETTINGS_FALLBACK_PATH;
+  }
+
+  return resolveSurfacePathFromPlacementContext(contextValue, ACCOUNT_SURFACE_ID, ACCOUNT_SETTINGS_SUFFIX);
+}
+
+function resolveSurfaceWorkspacePathFromPlacementContext(contextValue = null, surfaceId = "", workspaceSlug = "", suffix = "/") {
+  const normalizedWorkspaceSlug = String(workspaceSlug || "").trim();
+  const normalizedSurfaceId = normalizeSurfaceId(surfaceId);
+  if (!normalizedWorkspaceSlug) {
+    return "";
+  }
+
+  const surfaceConfig = readPlacementSurfaceConfig(contextValue);
+  const surfaceDefinition = surfaceConfig.surfacesById[normalizedSurfaceId] || null;
+  const normalizedSuffix = normalizeWorkspaceSuffix(suffix);
+
+  if (surfaceDefinition && !surfaceDefinition.requiresWorkspace) {
+    if (normalizedSuffix === "/") {
+      return resolveSurfaceRootPathFromPlacementContext(contextValue, normalizedSurfaceId);
+    }
+    return resolveSurfacePathFromPlacementContext(contextValue, normalizedSurfaceId, normalizedSuffix);
+  }
+
+  let workspaceRootPath = `/w/${normalizedWorkspaceSlug}`;
+  const workspaceSurfaceIds = listWorkspaceSurfaceIdsFromSurfaceConfig(surfaceConfig);
+  const defaultWorkspaceSurfaceId = resolveDefaultWorkspaceSurfaceId({
+    defaultSurfaceId: surfaceConfig?.defaultSurfaceId,
+    workspaceSurfaceIds,
+    surfaceRequiresWorkspace: (candidateSurfaceId) => Boolean(surfaceConfig?.surfacesById?.[candidateSurfaceId]?.requiresWorkspace)
+  });
+  if (normalizedSurfaceId && normalizedSurfaceId !== defaultWorkspaceSurfaceId) {
+    const surfaceSegment = normalizeSurfaceSegmentFromRouteBase(surfaceDefinition?.routeBase) || normalizedSurfaceId;
+    if (surfaceSegment) {
+      workspaceRootPath = `${workspaceRootPath}/${surfaceSegment}`;
+    }
+  }
+
+  if (normalizedSuffix === "/") {
+    return normalizePathname(workspaceRootPath);
+  }
+  return normalizePathname(`${workspaceRootPath}${normalizedSuffix}`);
+}
+
+function extractWorkspaceSlugFromSurfacePathname(contextValue = null, surfaceId = "", pathname = "") {
+  const normalizedPathname = normalizePathname(
+    pathname || (typeof window === "object" && window?.location?.pathname ? window.location.pathname : "/")
+  );
+  const normalizedSurfaceId = normalizeSurfaceId(surfaceId);
+  if (!normalizedSurfaceId) {
+    return "";
+  }
+  if (!surfaceRequiresWorkspaceFromPlacementContext(contextValue, normalizedSurfaceId)) {
+    return "";
+  }
+
+  const parsedWorkspacePath = parseWorkspacePathname(normalizedPathname);
+  if (!parsedWorkspacePath) {
+    return "";
+  }
+
+  const resolvedSurfaceId = resolveWorkspaceSurfaceIdFromPlacementPathname(contextValue, normalizedPathname);
+  if (resolvedSurfaceId !== normalizedSurfaceId) {
+    return "";
+  }
+
+  return parsedWorkspacePath.workspaceSlug;
+}
+
+export {
+  resolveAccountSettingsPathFromPlacementContext,
+  resolveWorkspaceSurfaceIdFromPlacementPathname,
+  resolveSurfaceWorkspacePathFromPlacementContext,
+  extractWorkspaceSlugFromSurfacePathname
+};

package/src/client/providers/UsersWebClientProvider.js

@@ -0,0 +1,85 @@
+import UsersWorkspaceSelector from "../components/UsersWorkspaceSelector.vue";
+import UsersWorkspaceToolsWidget from "../components/UsersWorkspaceToolsWidget.vue";
+import UsersShellMenuLinkItem from "../components/UsersShellMenuLinkItem.vue";
+import UsersSurfaceAwareMenuLinkItem from "../components/UsersSurfaceAwareMenuLinkItem.vue";
+import UsersProfileSurfaceSwitchMenuItem from "../components/UsersProfileSurfaceSwitchMenuItem.vue";
+import UsersWorkspaceSettingsMenuItem from "../components/UsersWorkspaceSettingsMenuItem.vue";
+import UsersWorkspaceMembersMenuItem from "../components/UsersWorkspaceMembersMenuItem.vue";
+import ProfileClientElement from "../components/ProfileClientElement.vue";
+import MembersAdminClientElement from "../components/MembersAdminClientElement.vue";
+import WorkspaceSettingsClientElement from "../components/WorkspaceSettingsClientElement.vue";
+import {
+  USERS_WEB_BOOTSTRAP_PLACEMENT_RUNTIME_TOKEN,
+  createBootstrapPlacementRuntime
+} from "../runtime/bootstrapPlacementRuntime.js";
+
+const USERS_WEB_WORKSPACE_SELECTOR_TOKEN = "users.web.workspace.selector";
+const USERS_WEB_WORKSPACE_TOOLS_WIDGET_TOKEN = "users.web.workspace.tools.widget";
+const USERS_WEB_SHELL_MENU_LINK_ITEM_TOKEN = "users.web.shell.menu-link-item";
+const USERS_WEB_SURFACE_AWARE_MENU_LINK_ITEM_TOKEN = "users.web.shell.surface-aware-menu-link-item";
+const USERS_WEB_PROFILE_SURFACE_SWITCH_MENU_ITEM_TOKEN = "users.web.profile.menu.surface-switch-item";
+const USERS_WEB_WORKSPACE_SETTINGS_MENU_ITEM_TOKEN = "users.web.workspace-settings.menu-item";
+const USERS_WEB_WORKSPACE_MEMBERS_MENU_ITEM_TOKEN = "users.web.workspace-members.menu-item";
+const USERS_WEB_PROFILE_ELEMENT_TOKEN = "users.web.profile.element";
+const USERS_WEB_MEMBERS_ADMIN_ELEMENT_TOKEN = "users.web.members-admin.element";
+const USERS_WEB_WORKSPACE_SETTINGS_ELEMENT_TOKEN = "users.web.workspace-settings.element";
+
+class UsersWebClientProvider {
+  static id = "users.web.client";
+  static dependsOn = ["shell.web.client"];
+
+  register(app) {
+    if (!app || typeof app.singleton !== "function") {
+      throw new Error("UsersWebClientProvider requires application singleton().");
+    }
+
+    app.singleton(USERS_WEB_WORKSPACE_SELECTOR_TOKEN, () => UsersWorkspaceSelector);
+    app.singleton(USERS_WEB_WORKSPACE_TOOLS_WIDGET_TOKEN, () => UsersWorkspaceToolsWidget);
+    app.singleton(USERS_WEB_SHELL_MENU_LINK_ITEM_TOKEN, () => UsersShellMenuLinkItem);
+    app.singleton(USERS_WEB_SURFACE_AWARE_MENU_LINK_ITEM_TOKEN, () => UsersSurfaceAwareMenuLinkItem);
+    app.singleton(USERS_WEB_PROFILE_SURFACE_SWITCH_MENU_ITEM_TOKEN, () => UsersProfileSurfaceSwitchMenuItem);
+    app.singleton(USERS_WEB_WORKSPACE_SETTINGS_MENU_ITEM_TOKEN, () => UsersWorkspaceSettingsMenuItem);
+    app.singleton(USERS_WEB_WORKSPACE_MEMBERS_MENU_ITEM_TOKEN, () => UsersWorkspaceMembersMenuItem);
+    app.singleton(USERS_WEB_PROFILE_ELEMENT_TOKEN, () => ProfileClientElement);
+    app.singleton(USERS_WEB_MEMBERS_ADMIN_ELEMENT_TOKEN, () => MembersAdminClientElement);
+    app.singleton(USERS_WEB_WORKSPACE_SETTINGS_ELEMENT_TOKEN, () => WorkspaceSettingsClientElement);
+    app.singleton(USERS_WEB_BOOTSTRAP_PLACEMENT_RUNTIME_TOKEN, (scope) => createBootstrapPlacementRuntime({ app: scope }));
+  }
+
+  async boot(app) {
+    if (!app || typeof app.make !== "function") {
+      throw new Error("UsersWebClientProvider requires application make().");
+    }
+
+    const runtime = app.make(USERS_WEB_BOOTSTRAP_PLACEMENT_RUNTIME_TOKEN);
+    if (runtime && typeof runtime.initialize === "function") {
+      await runtime.initialize();
+    }
+  }
+
+  shutdown(app) {
+    if (!app || typeof app.make !== "function") {
+      return;
+    }
+
+    const runtime = app.make(USERS_WEB_BOOTSTRAP_PLACEMENT_RUNTIME_TOKEN);
+    if (runtime && typeof runtime.shutdown === "function") {
+      runtime.shutdown();
+    }
+  }
+}
+
+export {
+  UsersWebClientProvider,
+  USERS_WEB_WORKSPACE_SELECTOR_TOKEN,
+  USERS_WEB_WORKSPACE_TOOLS_WIDGET_TOKEN,
+  USERS_WEB_SHELL_MENU_LINK_ITEM_TOKEN,
+  USERS_WEB_SURFACE_AWARE_MENU_LINK_ITEM_TOKEN,
+  USERS_WEB_PROFILE_SURFACE_SWITCH_MENU_ITEM_TOKEN,
+  USERS_WEB_WORKSPACE_SETTINGS_MENU_ITEM_TOKEN,
+  USERS_WEB_WORKSPACE_MEMBERS_MENU_ITEM_TOKEN,
+  USERS_WEB_PROFILE_ELEMENT_TOKEN,
+  USERS_WEB_MEMBERS_ADMIN_ELEMENT_TOKEN,
+  USERS_WEB_WORKSPACE_SETTINGS_ELEMENT_TOKEN,
+  USERS_WEB_BOOTSTRAP_PLACEMENT_RUNTIME_TOKEN
+};