@jskit-ai/users-web 0.1.52 → 0.1.54

package/src/client/lib/workspaceSurfacePaths.js

@@ -1,163 +0,0 @@
-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/UsersWorkspacesClientProvider.js

@@ -1,24 +0,0 @@
-import UsersWorkspaceSelector from "../components/UsersWorkspaceSelector.vue";
-import UsersWorkspaceToolsWidget from "../components/UsersWorkspaceToolsWidget.vue";
-import UsersWorkspaceSettingsMenuItem from "../components/UsersWorkspaceSettingsMenuItem.vue";
-import UsersWorkspaceMembersMenuItem from "../components/UsersWorkspaceMembersMenuItem.vue";
-import MembersAdminClientElement from "../components/MembersAdminClientElement.vue";
-
-class UsersWorkspacesClientProvider {
-  static id = "workspaces.web.client";
-  static dependsOn = ["users.web.client"];
-
-  register(app) {
-    if (!app || typeof app.singleton !== "function") {
-      throw new Error("UsersWorkspacesClientProvider requires application singleton().");
-    }
-
-    app.singleton("users.web.workspace.selector", () => UsersWorkspaceSelector);
-    app.singleton("users.web.workspace.tools.widget", () => UsersWorkspaceToolsWidget);
-    app.singleton("users.web.workspace-settings.menu-item", () => UsersWorkspaceSettingsMenuItem);
-    app.singleton("users.web.workspace-members.menu-item", () => UsersWorkspaceMembersMenuItem);
-    app.singleton("users.web.members-admin.element", () => MembersAdminClientElement);
-  }
-}
-
-export { UsersWorkspacesClientProvider };

package/src/client/runtime/bootstrapPlacementRouteGuards.js

@@ -1,371 +0,0 @@
-import {
-  resolveSurfaceDefinitionFromPlacementContext,
-  resolveSurfaceIdFromPlacementPathname,
-  resolveSurfaceRootPathFromPlacementContext,
-  resolveRuntimePathname
-} from "@jskit-ai/shell-web/client/placement";
-import {
-  extractWorkspaceSlugFromSurfacePathname,
-  resolveSurfaceWorkspacePathFromPlacementContext
-} from "../lib/workspaceSurfacePaths.js";
-import { evaluateSurfaceAccess } from "../lib/surfaceAccessPolicy.js";
-import {
-  SHELL_GUARD_EVALUATOR_KEY,
-  WORKSPACE_BOOTSTRAP_STATUS_FORBIDDEN,
-  WORKSPACE_BOOTSTRAP_STATUS_NOT_FOUND,
-  WORKSPACE_FORBIDDEN_GUARD_REASON,
-  WORKSPACE_NOT_FOUND_GUARD_REASON
-} from "./bootstrapPlacementRuntimeConstants.js";
-import {
-  isGuardDenied,
-  normalizeSearch,
-  normalizeWorkspaceBootstrapStatus,
-  normalizeWorkspaceSlugKey,
-  resolveSearchFromFullPath
-} from "./bootstrapPlacementRuntimeHelpers.js";
-
-function createBootstrapPlacementRouteGuards({
-  placementRuntime,
-  router = null,
-  root = null,
-  getWorkspaceBootstrapStatus = () => ""
-} = {}) {
-  const cleanup = [];
-  let delegatedGuardEvaluator = null;
-  let workspaceGuardEvaluatorInstalled = false;
-
-  function resolveNormalizedSurfaceState(pathname = "/", search = "") {
-    const context = placementRuntime.getContext();
-    const normalizedPathname = resolveRuntimePathname(pathname);
-    const normalizedSearch = normalizeSearch(search);
-    const surfaceId = String(resolveSurfaceIdFromPlacementPathname(context, normalizedPathname) || "")
-      .trim()
-      .toLowerCase();
-    if (!surfaceId) {
-      return null;
-    }
-
-    const surfaceDefinition = resolveSurfaceDefinitionFromPlacementContext(context, surfaceId);
-    if (!surfaceDefinition) {
-      return null;
-    }
-
-    return Object.freeze({
-      context,
-      normalizedPathname,
-      normalizedSearch,
-      surfaceId,
-      surfaceDefinition
-    });
-  }
-
-  function resolveWorkspaceRouteState(pathname = "/", search = "") {
-    const surfaceState = resolveNormalizedSurfaceState(pathname, search);
-    if (!surfaceState || surfaceState.surfaceDefinition.requiresWorkspace !== true) {
-      return null;
-    }
-
-    const workspaceSlug = normalizeWorkspaceSlugKey(
-      extractWorkspaceSlugFromSurfacePathname(surfaceState.context, surfaceState.surfaceId, surfaceState.normalizedPathname)
-    );
-    if (!workspaceSlug) {
-      return null;
-    }
-
-    return Object.freeze({
-      pathname: surfaceState.normalizedPathname,
-      search: surfaceState.normalizedSearch,
-      surfaceId: surfaceState.surfaceId,
-      workspaceSlug,
-      workspaceRootPath: resolveRuntimePathname(
-        resolveSurfaceWorkspacePathFromPlacementContext(surfaceState.context, surfaceState.surfaceId, workspaceSlug, "/")
-      ),
-      workspaceBootstrapStatus: String(getWorkspaceBootstrapStatus(workspaceSlug) || "")
-    });
-  }
-
-  function resolveSurfaceRouteState(pathname = "/", search = "") {
-    const surfaceState = resolveNormalizedSurfaceState(pathname, search);
-    if (!surfaceState || surfaceState.surfaceDefinition.enabled === false) {
-      return null;
-    }
-
-    const workspaceSlug =
-      surfaceState.surfaceDefinition.requiresWorkspace === true
-        ? normalizeWorkspaceSlugKey(
-            extractWorkspaceSlugFromSurfacePathname(
-              surfaceState.context,
-              surfaceState.surfaceId,
-              surfaceState.normalizedPathname
-            )
-          )
-        : "";
-    return Object.freeze({
-      pathname: surfaceState.normalizedPathname,
-      search: surfaceState.normalizedSearch,
-      surfaceId: surfaceState.surfaceId,
-      workspaceSlug,
-      workspaceBootstrapStatus: workspaceSlug ? String(getWorkspaceBootstrapStatus(workspaceSlug) || "") : ""
-    });
-  }
-
-  function resolveDefaultSurfaceFallbackPath(surfaceState = null) {
-    const context = placementRuntime.getContext();
-    const defaultSurfaceId = String(context?.surfaceConfig?.defaultSurfaceId || "")
-      .trim()
-      .toLowerCase();
-    const fallbackSurfaceId = defaultSurfaceId || surfaceState?.surfaceId || "";
-    if (!fallbackSurfaceId) {
-      return "/";
-    }
-
-    const fallbackSurfaceDefinition = resolveSurfaceDefinitionFromPlacementContext(context, fallbackSurfaceId);
-    if (fallbackSurfaceDefinition?.requiresWorkspace === true) {
-      const fallbackWorkspaceSlug =
-        normalizeWorkspaceSlugKey(surfaceState?.workspaceSlug) || normalizeWorkspaceSlugKey(context?.workspace?.slug);
-      if (!fallbackWorkspaceSlug) {
-        return "/";
-      }
-      return resolveRuntimePathname(
-        resolveSurfaceWorkspacePathFromPlacementContext(context, fallbackSurfaceId, fallbackWorkspaceSlug, "/")
-      );
-    }
-
-    const fallbackPath = resolveRuntimePathname(resolveSurfaceRootPathFromPlacementContext(context, fallbackSurfaceId));
-    if (fallbackPath.includes(":")) {
-      return "/";
-    }
-    return fallbackPath || "/";
-  }
-
-  function resolveWorkspaceGuardDecision(pathname = "/", search = "") {
-    const workspaceState = resolveWorkspaceRouteState(pathname, search);
-    if (!workspaceState) {
-      return null;
-    }
-
-    if (workspaceState.workspaceBootstrapStatus === WORKSPACE_BOOTSTRAP_STATUS_NOT_FOUND) {
-      if (workspaceState.workspaceRootPath && workspaceState.workspaceRootPath !== workspaceState.pathname) {
-        return {
-          allow: false,
-          redirectTo: workspaceState.workspaceRootPath,
-          reason: WORKSPACE_NOT_FOUND_GUARD_REASON
-        };
-      }
-      return null;
-    }
-
-    if (workspaceState.workspaceBootstrapStatus === WORKSPACE_BOOTSTRAP_STATUS_FORBIDDEN) {
-      if (workspaceState.workspaceRootPath && workspaceState.workspaceRootPath !== workspaceState.pathname) {
-        return {
-          allow: false,
-          redirectTo: workspaceState.workspaceRootPath,
-          reason: WORKSPACE_FORBIDDEN_GUARD_REASON
-        };
-      }
-      return null;
-    }
-
-    return null;
-  }
-
-  function resolveSurfaceAccessGuardDecision(pathname = "/", search = "", { allowOnUnknown = true } = {}) {
-    const surfaceState = resolveSurfaceRouteState(pathname, search);
-    if (!surfaceState) {
-      return null;
-    }
-
-    if (
-      surfaceState.workspaceBootstrapStatus === WORKSPACE_BOOTSTRAP_STATUS_NOT_FOUND ||
-      surfaceState.workspaceBootstrapStatus === WORKSPACE_BOOTSTRAP_STATUS_FORBIDDEN
-    ) {
-      return null;
-    }
-
-    const accessDecision = evaluateSurfaceAccess({
-      context: placementRuntime.getContext(),
-      surfaceId: surfaceState.surfaceId,
-      workspaceSlug: surfaceState.workspaceSlug,
-      allowOnUnknown
-    });
-    if (accessDecision.allowed || accessDecision.pending) {
-      return null;
-    }
-
-    const redirectTarget = resolveDefaultSurfaceFallbackPath(surfaceState);
-    const redirectTo = redirectTarget && redirectTarget !== surfaceState.pathname ? redirectTarget : "";
-
-    return {
-      allow: false,
-      redirectTo,
-      reason: accessDecision.reason || "surface-access-denied"
-    };
-  }
-
-  async function replaceRouteIfNeeded(targetPath = "") {
-    if (!router || typeof router.replace !== "function") {
-      return;
-    }
-
-    const normalizedTargetPath = String(targetPath || "").trim();
-    if (!normalizedTargetPath) {
-      return;
-    }
-
-    const currentRoute = router.currentRoute?.value || {};
-    const currentFullPath = String(currentRoute.fullPath || "").trim();
-    const currentPath = resolveRuntimePathname(currentRoute.path || "/");
-    const currentComparablePath = currentFullPath || currentPath;
-    if (currentComparablePath === normalizedTargetPath) {
-      return;
-    }
-
-    try {
-      await router.replace(normalizedTargetPath);
-    } catch {}
-  }
-
-  function enforceWorkspaceRouteForStatusUpdate({ workspaceSlug = "", status = "" } = {}) {
-    const normalizedWorkspaceSlug = normalizeWorkspaceSlugKey(workspaceSlug);
-    const normalizedStatus = normalizeWorkspaceBootstrapStatus(status);
-    if (!normalizedWorkspaceSlug || !normalizedStatus || !router) {
-      return;
-    }
-
-    const currentRoute = router.currentRoute?.value || {};
-    const currentPath = resolveRuntimePathname(currentRoute.path || "/");
-    const currentSearch = resolveSearchFromFullPath(currentRoute.fullPath || "");
-    const workspaceState = resolveWorkspaceRouteState(currentPath, currentSearch);
-    if (!workspaceState || workspaceState.workspaceSlug !== normalizedWorkspaceSlug) {
-      return;
-    }
-
-    if (normalizedStatus === WORKSPACE_BOOTSTRAP_STATUS_NOT_FOUND) {
-      if (workspaceState.workspaceRootPath && workspaceState.workspaceRootPath !== workspaceState.pathname) {
-        void replaceRouteIfNeeded(workspaceState.workspaceRootPath);
-      }
-      return;
-    }
-
-    if (normalizedStatus === WORKSPACE_BOOTSTRAP_STATUS_FORBIDDEN) {
-      if (workspaceState.workspaceRootPath && workspaceState.workspaceRootPath !== workspaceState.pathname) {
-        void replaceRouteIfNeeded(workspaceState.workspaceRootPath);
-      }
-    }
-  }
-
-  function enforceSurfaceAccessForCurrentRoute() {
-    if (!router) {
-      return;
-    }
-
-    const currentRoute = router.currentRoute?.value || {};
-    const currentPath = resolveRuntimePathname(currentRoute.path || "/");
-    const currentSearch = resolveSearchFromFullPath(currentRoute.fullPath || "");
-    const surfaceDecision = resolveSurfaceAccessGuardDecision(currentPath, currentSearch, {
-      allowOnUnknown: false
-    });
-    if (!surfaceDecision || !surfaceDecision.redirectTo) {
-      return;
-    }
-
-    void replaceRouteIfNeeded(surfaceDecision.redirectTo);
-  }
-
-  function installWorkspaceGuardEvaluator() {
-    if (!root || workspaceGuardEvaluatorInstalled) {
-      return;
-    }
-
-    if (typeof delegatedGuardEvaluator !== "function") {
-      const currentEvaluator = root[SHELL_GUARD_EVALUATOR_KEY];
-      delegatedGuardEvaluator = typeof currentEvaluator === "function" ? currentEvaluator : null;
-    }
-
-    const previousDescriptor = Object.getOwnPropertyDescriptor(root, SHELL_GUARD_EVALUATOR_KEY);
-    const previousOwnProperty = previousDescriptor || null;
-    let released = false;
-
-    const workspaceGuardEvaluator = ({ guard, phase, context } = {}) => {
-      const baseOutcome =
-        typeof delegatedGuardEvaluator === "function"
-          ? delegatedGuardEvaluator({
-              guard,
-              phase,
-              context
-            })
-          : true;
-      if (isGuardDenied(baseOutcome)) {
-        return baseOutcome;
-      }
-
-      const pathname = resolveRuntimePathname(context?.location?.pathname || context?.to?.path || "/");
-      const search = normalizeSearch(context?.location?.search || resolveSearchFromFullPath(context?.to?.fullPath || ""));
-      const workspaceDecision = resolveWorkspaceGuardDecision(pathname, search);
-      if (workspaceDecision) {
-        return workspaceDecision;
-      }
-
-      const surfaceDecision = resolveSurfaceAccessGuardDecision(pathname, search, {
-        allowOnUnknown: true
-      });
-      if (surfaceDecision) {
-        return surfaceDecision;
-      }
-
-      return baseOutcome;
-    };
-
-    Object.defineProperty(root, SHELL_GUARD_EVALUATOR_KEY, {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return workspaceGuardEvaluator;
-      },
-      set(nextEvaluator) {
-        if (nextEvaluator === workspaceGuardEvaluator) {
-          return;
-        }
-        delegatedGuardEvaluator = typeof nextEvaluator === "function" ? nextEvaluator : null;
-      }
-    });
-    workspaceGuardEvaluatorInstalled = true;
-
-    cleanup.push(() => {
-      if (released || !root) {
-        return;
-      }
-      released = true;
-
-      try {
-        if (previousOwnProperty) {
-          Object.defineProperty(root, SHELL_GUARD_EVALUATOR_KEY, previousOwnProperty);
-        } else {
-          delete root[SHELL_GUARD_EVALUATOR_KEY];
-        }
-      } catch {}
-      delegatedGuardEvaluator = null;
-      workspaceGuardEvaluatorInstalled = false;
-    });
-  }
-
-  function shutdown() {
-    for (const release of cleanup.splice(0, cleanup.length)) {
-      if (typeof release !== "function") {
-        continue;
-      }
-      try {
-        release();
-      } catch {}
-    }
-  }
-
-  return Object.freeze({
-    enforceSurfaceAccessForCurrentRoute,
-    enforceWorkspaceRouteForStatusUpdate,
-    installWorkspaceGuardEvaluator,
-    shutdown
-  });
-}
-
-export { createBootstrapPlacementRouteGuards };