@csntgao/uni-base 0.1.0

package/packages/web-components/src/application-switcher-transport.ts

@@ -0,0 +1,243 @@
+export interface ApplicationEntry {
+  id: string
+  name: string
+  url: string
+  iconUrl?: string
+  description?: string
+  /** @deprecated Applications always open in a new window. */
+  openMode?: 'self' | 'blank'
+}
+
+export interface OrganizationEntry {
+  id: string
+  name: string
+}
+
+export interface OrganizationListResult {
+  organizations: readonly OrganizationEntry[]
+  currentOrganizationId: string
+}
+
+export interface ApplicationLaunchResult {
+  url: string
+}
+
+export interface ApplicationSwitcherTransport {
+  listApplications(accessToken: string): Promise<readonly ApplicationEntry[]>
+  listOrganizations?(accessToken: string): Promise<OrganizationListResult>
+  switchOrganization?(accessToken: string, organizationId: string): Promise<void>
+  switchApplication?(
+    accessToken: string,
+    applicationId: string,
+  ): Promise<ApplicationLaunchResult | void>
+}
+
+export interface ApplicationSwitcherConfig {
+  getAccessToken(): Promise<string>
+  transport?: ApplicationSwitcherTransport
+  /**
+   * `embedded` renders only the application panel so another component can own
+   * the launcher and floating-panel lifecycle.
+   */
+  presentation?: 'standalone' | 'embedded'
+  /** Defaults to false for embedded presentation and true otherwise. */
+  showOrganizationSelector?: boolean
+}
+
+export interface HttpApplicationSwitcherTransportOptions {
+  endpoint: string
+  organizationsEndpoint?: string
+  switchOrganizationEndpoint?: string
+  fetch?: typeof fetch
+}
+
+export const MOCK_APPLICATION_ENTRIES: readonly ApplicationEntry[] = [
+  { id: 'ai-employee', name: '数字员工', url: '/apps/ai-employee' },
+  { id: 'enterprise-admin', name: '企业管理', url: '/apps/enterprise-admin' },
+  { id: 'platform-admin', name: '平台管理', url: '/apps/platform-admin' },
+  { id: 'recruitment', name: '招聘工作台', url: '/apps/recruitment' },
+  { id: 'data-space', name: '数据空间', url: '/apps/data-space' },
+  { id: 'toolbox', name: '工具箱', url: '/apps/toolbox' },
+  { id: 'service-center', name: '服务中心', url: '/apps/service-center' },
+  { id: 'knowledge-base', name: '知识库', url: '/apps/knowledge-base' },
+  { id: 'kanban', name: '任务看板', url: '/apps/kanban' },
+]
+
+export const MOCK_ORGANIZATIONS: readonly OrganizationEntry[] = [
+  { id: 'uniplat-group', name: 'Uniplat 集团' },
+  { id: 'shanghai-branch', name: '上海分公司' },
+  { id: 'hangzhou-rd', name: '杭州研发中心' },
+]
+
+export function createMockApplicationSwitcherTransport(): ApplicationSwitcherTransport {
+  let currentOrganizationId = MOCK_ORGANIZATIONS[0]?.id ?? ''
+
+  return {
+    async listApplications(accessToken) {
+      requireAccessToken(accessToken)
+      return MOCK_APPLICATION_ENTRIES.map((entry) => ({ ...entry }))
+    },
+    async listOrganizations(accessToken) {
+      requireAccessToken(accessToken)
+      return {
+        organizations: MOCK_ORGANIZATIONS.map((organization) => ({ ...organization })),
+        currentOrganizationId,
+      }
+    },
+    async switchOrganization(accessToken, organizationId) {
+      requireAccessToken(accessToken)
+      const normalizedId = organizationId.trim()
+      if (!MOCK_ORGANIZATIONS.some((organization) => organization.id === normalizedId)) {
+        throw new Error('Organization is unavailable')
+      }
+      currentOrganizationId = normalizedId
+    },
+  }
+}
+
+export function createHttpApplicationSwitcherTransport(
+  options: HttpApplicationSwitcherTransportOptions,
+): ApplicationSwitcherTransport {
+  const endpoint = validateEndpoint(options.endpoint, 'Application entry')
+  const organizationsEndpoint = options.organizationsEndpoint
+    ? validateEndpoint(options.organizationsEndpoint, 'Organization list')
+    : ''
+  const switchOrganizationEndpoint = options.switchOrganizationEndpoint
+    ? validateEndpoint(options.switchOrganizationEndpoint, 'Organization switch')
+    : ''
+  const fetchImplementation = options.fetch ?? globalThis.fetch
+
+  const transport: ApplicationSwitcherTransport = {
+    async listApplications(accessToken) {
+      const token = requireAccessToken(accessToken)
+
+      const response = await request(fetchImplementation, endpoint, token, 'GET')
+      if (!response.ok) throw new Error('Application entry request failed')
+      return parseApplicationEntries(await response.json())
+    },
+  }
+
+  if (organizationsEndpoint) {
+    transport.listOrganizations = async (accessToken) => {
+      const token = requireAccessToken(accessToken)
+      const response = await request(fetchImplementation, organizationsEndpoint, token, 'GET')
+      if (!response.ok) throw new Error('Organization list request failed')
+      return parseOrganizations(await response.json())
+    }
+  }
+
+  if (switchOrganizationEndpoint) {
+    transport.switchOrganization = async (accessToken, organizationId) => {
+      const token = requireAccessToken(accessToken)
+      const normalizedId = organizationId.trim()
+      if (!normalizedId) throw new Error('Organization is required')
+      if (!fetchImplementation) throw new Error('Fetch is unavailable')
+
+      const response = await fetchImplementation(switchOrganizationEndpoint, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+          accept: 'application/json',
+          authorization: `Bearer ${token}`,
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({ organizationId: normalizedId }),
+      })
+      if (!response.ok) throw new Error('Organization switch request failed')
+    }
+  }
+
+  return transport
+}
+
+async function request(
+  fetchImplementation: typeof fetch | undefined,
+  endpoint: string,
+  accessToken: string,
+  method: 'GET',
+): Promise<Response> {
+  if (!fetchImplementation) throw new Error('Fetch is unavailable')
+  return fetchImplementation(endpoint, {
+    method,
+    credentials: 'include',
+    headers: {
+      accept: 'application/json',
+      authorization: `Bearer ${accessToken}`,
+    },
+  })
+}
+
+function parseApplicationEntries(payload: unknown): ApplicationEntry[] {
+  const response = asRecord(payload)
+  if (!Array.isArray(response.entries)) throw new Error('Invalid application entry response')
+
+  const entries: ApplicationEntry[] = []
+  for (const candidate of response.entries) {
+    const entry = asRecord(candidate)
+    const id = text(entry.id).trim()
+    const name = text(entry.name).trim()
+    const url = text(entry.url).trim()
+    if (!id || !name || !url) continue
+
+    const normalized: ApplicationEntry = { id, name, url }
+    const iconUrl = text(entry.iconUrl).trim()
+    const description = text(entry.description).trim()
+    if (iconUrl) normalized.iconUrl = iconUrl
+    if (description) normalized.description = description
+    if (entry.openMode === 'blank') normalized.openMode = 'blank'
+    entries.push(normalized)
+  }
+  return entries
+}
+
+function parseOrganizations(payload: unknown): OrganizationListResult {
+  const response = asRecord(payload)
+  if (!Array.isArray(response.organizations)) throw new Error('Invalid organization response')
+
+  const organizations: OrganizationEntry[] = []
+  for (const candidate of response.organizations) {
+    const organization = asRecord(candidate)
+    const id = text(organization.id).trim()
+    const name = text(organization.name).trim()
+    if (id && name) organizations.push({ id, name })
+  }
+
+  return {
+    organizations,
+    currentOrganizationId: text(response.currentOrganizationId).trim(),
+  }
+}
+
+function requireAccessToken(accessToken: string): string {
+  const token = accessToken.trim()
+  if (!token) throw new Error('Access token is required')
+  return token
+}
+
+function validateEndpoint(rawEndpoint: string, label: string): string {
+  const endpoint = typeof rawEndpoint === 'string' ? rawEndpoint.trim() : ''
+  if (!endpoint) throw new TypeError(`${label} endpoint is required`)
+
+  const baseUrl = typeof document === 'undefined' ? 'https://localhost/' : document.baseURI
+  let parsed: URL
+  try {
+    parsed = new URL(endpoint, baseUrl)
+  } catch {
+    throw new TypeError(`${label} endpoint is invalid`)
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password) {
+    throw new TypeError(`${label} endpoint must use HTTP(S) without user credentials`)
+  }
+  if (parsed.hash) throw new TypeError(`${label} endpoint must not contain a hash`)
+  return parsed.href
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {}
+}
+
+function text(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}