@jskit-ai/users-web 0.1.53 → 0.1.54

package/test/menuIcons.test.js

@@ -1,34 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  mdiAccountCogOutline,
-  mdiCogOutline,
-  mdiFolderOutline,
-  mdiLogin,
-  mdiShieldCrownOutline,
-  mdiViewDashboardOutline,
-  mdiViewListOutline
-} from "@mdi/js";
-import {
-  resolveMenuLinkIcon,
-  resolveSurfaceSwitchIcon
-} from "../src/client/lib/menuIcons.js";
-
-test("resolveSurfaceSwitchIcon prefers explicit icon and maps known surfaces", () => {
-  assert.equal(resolveSurfaceSwitchIcon("admin"), mdiShieldCrownOutline);
-  assert.equal(resolveSurfaceSwitchIcon("ops", "mdi-cog-outline"), mdiCogOutline);
-  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);
-  assert.equal(resolveMenuLinkIcon({ label: "Workspace", to: "/w/acme" }), mdiViewDashboardOutline);
-  assert.equal(resolveMenuLinkIcon({ to: "/projects" }), mdiFolderOutline);
-  assert.equal(resolveMenuLinkIcon({ label: "Settings", to: "/workspace/settings" }), mdiCogOutline);
-  assert.equal(resolveMenuLinkIcon({ label: "Anything else", to: "/foo" }), mdiFolderOutline);
-  assert.equal(resolveMenuLinkIcon({ label: "Anything else" }), mdiViewListOutline);
-});

package/test/menuLinkTarget.test.js

@@ -1,116 +0,0 @@
-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/profileSurfaceMenuLinks.test.js

@@ -1,208 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mdiShieldCrownOutline } from "@mdi/js";
-import {
-  hasWorkspaceMembership,
-  resolvePrimarySurfaceSwitchLink,
-  resolveProfileSurfaceMenuLinks
-} from "../src/client/lib/profileSurfaceMenuLinks.js";
-
-function createPlacementContext({
-  workspace = null,
-  workspaces = [],
-  authenticated = true,
-  opsOwner = false
-} = {}) {
-  return {
-    auth: {
-      authenticated
-    },
-    workspace,
-    workspaces,
-    permissions: [],
-    surfaceAccess: {
-      opsowner: opsOwner
-    },
-    surfaceAccessPolicies: {
-      public: {},
-      workspace_member: {
-        requireAuth: true,
-        requireWorkspaceMembership: true
-      },
-      ops_owner: {
-        requireAuth: true,
-        requireFlagsAll: ["ops_owner"]
-      }
-    },
-    surfaceConfig: {
-      tenancyMode: "workspaces",
-      defaultSurfaceId: "app",
-      enabledSurfaceIds: ["home", "app", "admin", "ops"],
-      surfacesById: {
-        home: {
-          id: "home",
-          enabled: true,
-          pagesRoot: "",
-          routeBase: "/",
-          requiresAuth: false,
-          requiresWorkspace: false,
-          accessPolicyId: "public"
-        },
-        app: {
-          id: "app",
-          enabled: true,
-          pagesRoot: "w/[workspaceSlug]",
-          routeBase: "/w/:workspaceSlug",
-          requiresAuth: true,
-          requiresWorkspace: true,
-          accessPolicyId: "workspace_member"
-        },
-        admin: {
-          id: "admin",
-          enabled: true,
-          pagesRoot: "w/[workspaceSlug]/admin",
-          routeBase: "/w/:workspaceSlug/admin",
-          requiresAuth: true,
-          requiresWorkspace: true,
-          accessPolicyId: "workspace_member"
-        },
-        ops: {
-          id: "ops",
-          enabled: true,
-          pagesRoot: "ops",
-          routeBase: "/ops",
-          requiresAuth: true,
-          requiresWorkspace: false,
-          accessPolicyId: "ops_owner",
-          icon: "mdi-cog-outline"
-        }
-      }
-    }
-  };
-}
-
-const originalWindow = globalThis.window;
-
-test.afterEach(() => {
-  if (typeof originalWindow === "undefined") {
-    delete globalThis.window;
-    return;
-  }
-  globalThis.window = originalWindow;
-});
-
-test("hasWorkspaceMembership matches context.workspace slug", () => {
-  const context = createPlacementContext({
-    workspace: {
-      id: 1,
-      slug: "acme"
-    },
-    workspaces: []
-  });
-
-  assert.equal(hasWorkspaceMembership(context, "acme"), true);
-});
-
-test("hasWorkspaceMembership matches context.workspaces slug", () => {
-  const context = createPlacementContext({
-    workspace: null,
-    workspaces: [
-      {
-        id: 1,
-        slug: "acme"
-      }
-    ]
-  });
-
-  assert.equal(hasWorkspaceMembership(context, "acme"), true);
-});
-
-test("resolvePrimarySurfaceSwitchLink shows Go to admin only for member workspace", () => {
-  const context = createPlacementContext({
-    workspace: {
-      id: 1,
-      slug: "acme"
-    },
-    workspaces: [
-      {
-        id: 1,
-        slug: "acme"
-      }
-    ]
-  });
-
-  const link = resolvePrimarySurfaceSwitchLink({
-    context,
-    surface: "app"
-  });
-
-  assert.deepEqual(link, {
-    id: "surface-switch.admin",
-    label: "Go to admin",
-    icon: mdiShieldCrownOutline,
-    to: "/w/acme/admin"
-  });
-});
-
-test("resolvePrimarySurfaceSwitchLink hides workspace switch when slug is only in URL and user is not member", () => {
-  globalThis.window = {
-    location: {
-      pathname: "/w/acme/admin",
-      search: "",
-      hash: ""
-    }
-  };
-
-  const context = createPlacementContext({
-    workspace: null,
-    workspaces: []
-  });
-
-  const link = resolvePrimarySurfaceSwitchLink({
-    context,
-    surface: "admin"
-  });
-
-  assert.equal(link, null);
-});
-
-test("resolveProfileSurfaceMenuLinks includes gated non-workspace switches only for matching access flags", () => {
-  const nonOwnerContext = createPlacementContext({
-    workspace: {
-      id: 1,
-      slug: "acme"
-    },
-    workspaces: [
-      {
-        id: 1,
-        slug: "acme"
-      }
-    ],
-    opsOwner: false
-  });
-  const ownerContext = createPlacementContext({
-    workspace: {
-      id: 1,
-      slug: "acme"
-    },
-    workspaces: [
-      {
-        id: 1,
-        slug: "acme"
-      }
-    ],
-    opsOwner: true
-  });
-
-  const nonOwnerLinks = resolveProfileSurfaceMenuLinks({
-    context: nonOwnerContext,
-    surface: "app"
-  });
-  const ownerLinks = resolveProfileSurfaceMenuLinks({
-    context: ownerContext,
-    surface: "app"
-  });
-
-  assert.equal(nonOwnerLinks.some((entry) => entry.id === "surface-switch.ops"), false);
-  assert.equal(ownerLinks.some((entry) => entry.id === "surface-switch.ops"), true);
-});

package/test/surfaceAccessPolicy.test.js

@@ -1,129 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { evaluateSurfaceAccess } from "../src/client/lib/surfaceAccessPolicy.js";
-
-function createContext(overrides = {}) {
-  return {
-    auth: {
-      authenticated: true
-    },
-    workspaces: [
-      {
-        id: 1,
-        slug: "acme"
-      }
-    ],
-    permissions: [],
-    surfaceAccess: {
-      opsowner: false
-    },
-    surfaceAccessPolicies: {
-      public: {},
-      workspace_member: {
-        requireAuth: true,
-        requireWorkspaceMembership: true
-      },
-      ops_owner: {
-        requireAuth: true,
-        requireFlagsAll: ["ops_owner"]
-      }
-    },
-    surfaceConfig: {
-      defaultSurfaceId: "home",
-      enabledSurfaceIds: ["home", "app", "ops"],
-      surfacesById: {
-        home: {
-          id: "home",
-          enabled: true,
-          routeBase: "/home",
-          requiresWorkspace: false,
-          accessPolicyId: "public"
-        },
-        app: {
-          id: "app",
-          enabled: true,
-          routeBase: "/w/:workspaceSlug",
-          requiresWorkspace: true,
-          accessPolicyId: "workspace_member"
-        },
-        ops: {
-          id: "ops",
-          enabled: true,
-          routeBase: "/ops",
-          requiresWorkspace: false,
-          accessPolicyId: "ops_owner"
-        }
-      }
-    },
-    ...overrides
-  };
-}
-
-test("evaluateSurfaceAccess allows workspace member surfaces for accessible workspace", () => {
-  const decision = evaluateSurfaceAccess({
-    context: createContext(),
-    surfaceId: "app",
-    workspaceSlug: "acme"
-  });
-
-  assert.equal(decision.allowed, true);
-});
-
-test("evaluateSurfaceAccess denies workspace member surfaces for inaccessible workspace", () => {
-  const decision = evaluateSurfaceAccess({
-    context: createContext(),
-    surfaceId: "app",
-    workspaceSlug: "missing"
-  });
-
-  assert.equal(decision.allowed, false);
-  assert.equal(decision.reason, "surface-access-workspace-membership-required");
-});
-
-test("evaluateSurfaceAccess allows unknown workspace membership when allowOnUnknown=true", () => {
-  const context = createContext();
-  delete context.workspaces;
-
-  const decision = evaluateSurfaceAccess({
-    context,
-    surfaceId: "app",
-    workspaceSlug: "acme",
-    allowOnUnknown: true
-  });
-
-  assert.equal(decision.allowed, true);
-  assert.equal(decision.pending, true);
-});
-
-test("evaluateSurfaceAccess enforces bootstrap surface access flags", () => {
-  const deniedDecision = evaluateSurfaceAccess({
-    context: createContext(),
-    surfaceId: "ops"
-  });
-  assert.equal(deniedDecision.allowed, false);
-
-  const allowedDecision = evaluateSurfaceAccess({
-    context: createContext({
-      surfaceAccess: {
-        opsowner: true
-      }
-    }),
-    surfaceId: "ops"
-  });
-  assert.equal(allowedDecision.allowed, true);
-});
-
-test("evaluateSurfaceAccess denies workspace route with not_found status", () => {
-  const decision = evaluateSurfaceAccess({
-    context: createContext({
-      workspaceBootstrapStatuses: {
-        acme: "not_found"
-      }
-    }),
-    surfaceId: "app",
-    workspaceSlug: "acme"
-  });
-
-  assert.equal(decision.allowed, false);
-  assert.equal(decision.reason, "surface-access-workspace-not-found");
-});

package/test/workspaceLinkResolver.test.js

@@ -1,61 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { resolveWorkspaceShellLinkPath } from "../src/client/lib/workspaceLinkResolver.js";
-
-function createContext({ defaultSurfaceId = "dashboard", enabledSurfaceIds = ["dashboard"], surfacesById = {} } = {}) {
-  return {
-    surfaceConfig: {
-      defaultSurfaceId,
-      enabledSurfaceIds,
-      surfacesById
-    }
-  };
-}
-
-test("resolveWorkspaceShellLinkPath resolves workspace path for known workspace surfaces", () => {
-  const context = {
-    surfaceConfig: {
-      defaultSurfaceId: "dashboard",
-      enabledSurfaceIds: ["dashboard"],
-      surfacesById: {
-        dashboard: {
-          routeBase: "/dashboard",
-          requiresWorkspace: true
-        }
-      }
-    }
-  };
-
-  const path = resolveWorkspaceShellLinkPath({
-    context,
-    surface: "dashboard",
-    mode: "workspace",
-    workspaceSlug: "acme"
-  });
-
-  assert.equal(path, "/w/acme");
-});
-
-test("resolveWorkspaceShellLinkPath returns empty path for unknown non-default workspace surface", () => {
-  const context = createContext();
-  const path = resolveWorkspaceShellLinkPath({
-    context,
-    surface: "admin",
-    mode: "workspace",
-    workspaceSlug: "acme"
-  });
-
-  assert.equal(path, "");
-});
-
-test("resolveWorkspaceShellLinkPath returns empty path for unknown non-workspace surface ids", () => {
-  const context = createContext();
-  const path = resolveWorkspaceShellLinkPath({
-    context,
-    surface: "ops",
-    mode: "workspace",
-    workspaceSlug: "acme"
-  });
-
-  assert.equal(path, "");
-});

package/test/workspaceSurfacePaths.test.js

@@ -1,39 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  resolveAccountSettingsPathFromPlacementContext,
-  resolveSurfaceWorkspacePathFromPlacementContext
-} from "../src/client/lib/workspaceSurfacePaths.js";
-
-test("resolveSurfaceWorkspacePathFromPlacementContext returns empty path without workspace slug", () => {
-  const context = {
-    surfaceConfig: {
-      defaultSurfaceId: "home",
-      enabledSurfaceIds: ["home", "app", "admin", "ops"],
-      surfacesById: {
-        home: { id: "home", routeBase: "/home", requiresWorkspace: false },
-        app: { id: "app", routeBase: "/w/:workspaceSlug", requiresWorkspace: true },
-        admin: { id: "admin", routeBase: "/w/:workspaceSlug/admin", requiresWorkspace: true },
-        ops: { id: "ops", routeBase: "/ops", requiresWorkspace: false }
-      }
-    }
-  };
-
-  assert.equal(resolveSurfaceWorkspacePathFromPlacementContext(context, "app", "", "/"), "");
-});
-
-test("resolveAccountSettingsPathFromPlacementContext uses account surface route when available", () => {
-  const context = {
-    surfaceConfig: {
-      defaultSurfaceId: "home",
-      enabledSurfaceIds: ["home", "account"],
-      surfacesById: {
-        home: { id: "home", routeBase: "/home", requiresWorkspace: false },
-        account: { id: "account", routeBase: "/profile", requiresWorkspace: false }
-      }
-    }
-  };
-
-  assert.equal(resolveAccountSettingsPathFromPlacementContext(context), "/profile");
-});