@tuturuuu/utils 0.0.2 → 0.6.0

package/src/plan-helpers.test.ts

@@ -0,0 +1,188 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  createAdminClientMock,
+  createClientMock,
+  getUserMock,
+  verifyWorkspaceMembershipTypeMock,
+} = vi.hoisted(() => ({
+  createAdminClientMock: vi.fn(),
+  createClientMock: vi.fn(),
+  getUserMock: vi.fn(),
+  verifyWorkspaceMembershipTypeMock: vi.fn(),
+}));
+
+vi.mock('@tuturuuu/supabase/next/server', () => ({
+  createAdminClient: createAdminClientMock,
+  createClient: createClientMock,
+}));
+
+vi.mock('./workspace-helper', () => ({
+  verifyWorkspaceMembershipType: verifyWorkspaceMembershipTypeMock,
+}));
+
+import { getPlan, normalizeMeetTogetherPlanId } from './plan-helpers';
+
+function createPlanClient(result: { data: unknown; error: unknown }) {
+  const eqCalls: Array<[string, unknown]> = [];
+  const query = {
+    eq: vi.fn((column: string, value: unknown) => {
+      eqCalls.push([column, value]);
+      return query;
+    }),
+    maybeSingle: vi.fn(async () => result),
+    select: vi.fn(() => query),
+  };
+  const client = {
+    from: vi.fn((table: string) => {
+      if (table !== 'meet_together_plans') {
+        throw new Error(`unexpected table ${table}`);
+      }
+
+      return query;
+    }),
+  };
+
+  return {
+    client,
+    eqCalls,
+    query,
+  };
+}
+
+describe('meet plan helpers', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    createClientMock.mockResolvedValue({
+      auth: {
+        getUser: getUserMock,
+      },
+    });
+    getUserMock.mockResolvedValue({
+      data: { user: null },
+    });
+    verifyWorkspaceMembershipTypeMock.mockResolvedValue({ ok: true });
+  });
+
+  it('normalizes compact legacy plan IDs', () => {
+    expect(
+      normalizeMeetTogetherPlanId('0123456789abcdef0123456789abcdef')
+    ).toBe('01234567-89ab-cdef-0123-456789abcdef');
+    expect(
+      normalizeMeetTogetherPlanId('01234567-89ab-cdef-0123-456789abcdef')
+    ).toBe('01234567-89ab-cdef-0123-456789abcdef');
+  });
+
+  it('allows anonymous reads for public non-workspace plans', async () => {
+    const plan = {
+      id: 'plan-1',
+      is_public: true,
+      ws_id: null,
+    };
+    const mocks = createPlanClient({
+      data: plan,
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+
+    await expect(getPlan('plan-1', { actorUserId: null })).resolves.toBe(plan);
+
+    expect(verifyWorkspaceMembershipTypeMock).not.toHaveBeenCalled();
+  });
+
+  it('rejects anonymous reads for public workspace plans', async () => {
+    const mocks = createPlanClient({
+      data: {
+        id: 'plan-1',
+        is_public: true,
+        ws_id: 'ws-1',
+      },
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+
+    await expect(getPlan('plan-1', { actorUserId: null })).resolves.toBeNull();
+
+    expect(verifyWorkspaceMembershipTypeMock).not.toHaveBeenCalled();
+  });
+
+  it('allows workspace members to read public workspace plans', async () => {
+    const plan = {
+      creator_id: 'creator-1',
+      id: 'plan-1',
+      is_public: true,
+      ws_id: 'ws-1',
+    };
+    const mocks = createPlanClient({
+      data: plan,
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+
+    await expect(getPlan('plan-1', { actorUserId: 'member-1' })).resolves.toBe(
+      plan
+    );
+
+    expect(verifyWorkspaceMembershipTypeMock).toHaveBeenCalledWith({
+      requiredType: 'MEMBER',
+      supabase: mocks.client,
+      userId: 'member-1',
+      wsId: 'ws-1',
+    });
+  });
+
+  it('rejects private workspace plans for non-creator members', async () => {
+    const mocks = createPlanClient({
+      data: {
+        creator_id: 'creator-1',
+        id: 'plan-1',
+        is_public: false,
+        ws_id: 'ws-1',
+      },
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+
+    await expect(
+      getPlan('plan-1', { actorUserId: 'member-1' })
+    ).resolves.toBeNull();
+  });
+
+  it('allows private workspace plans for creator members', async () => {
+    const plan = {
+      creator_id: 'creator-1',
+      id: 'plan-1',
+      is_public: false,
+      ws_id: 'ws-1',
+    };
+    const mocks = createPlanClient({
+      data: plan,
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+
+    await expect(getPlan('plan-1', { actorUserId: 'creator-1' })).resolves.toBe(
+      plan
+    );
+  });
+
+  it('falls back to the current Supabase user when no actor is provided', async () => {
+    const plan = {
+      creator_id: 'creator-1',
+      id: 'plan-1',
+      is_public: false,
+      ws_id: null,
+    };
+    const mocks = createPlanClient({
+      data: plan,
+      error: null,
+    });
+    createAdminClientMock.mockResolvedValue(mocks.client);
+    getUserMock.mockResolvedValue({
+      data: { user: { id: 'creator-1' } },
+    });
+
+    await expect(getPlan('plan-1')).resolves.toBe(plan);
+    expect(createClientMock).toHaveBeenCalled();
+  });
+});

package/src/plan-helpers.ts

@@ -0,0 +1,80 @@
+import {
+  createAdminClient,
+  createClient,
+} from '@tuturuuu/supabase/next/server';
+import type { MeetTogetherPlan } from '@tuturuuu/types/primitives/MeetTogetherPlan';
+import { verifyWorkspaceMembershipType } from './workspace-helper';
+
+interface GetPlanOptions {
+  actorUserId?: string | null;
+}
+
+export function normalizeMeetTogetherPlanId(planId: string) {
+  const trimmed = planId.trim();
+
+  return trimmed.replace(
+    /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/iu,
+    '$1-$2-$3-$4-$5'
+  );
+}
+
+async function getCurrentSupabaseUserId() {
+  const supabase = await createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  return user?.id ?? null;
+}
+
+export async function getPlan(planId: string, options: GetPlanOptions = {}) {
+  const sbAdmin = await createAdminClient();
+  const normalizedPlanId = normalizeMeetTogetherPlanId(planId);
+
+  const { data, error } = await sbAdmin
+    .from('meet_together_plans')
+    .select('*')
+    .eq('id', normalizedPlanId)
+    .maybeSingle();
+
+  if (error || !data) {
+    console.error(error);
+    return null;
+  }
+
+  const plan = data as MeetTogetherPlan;
+
+  if (plan.is_public && !plan.ws_id) {
+    return plan;
+  }
+
+  const actorUserId =
+    options.actorUserId === undefined
+      ? await getCurrentSupabaseUserId()
+      : options.actorUserId;
+
+  if (!actorUserId) {
+    return null;
+  }
+
+  if (!plan.ws_id) {
+    return plan.creator_id === actorUserId ? plan : null;
+  }
+
+  const membership = await verifyWorkspaceMembershipType({
+    requiredType: 'MEMBER',
+    supabase: sbAdmin,
+    userId: actorUserId,
+    wsId: plan.ws_id,
+  });
+
+  if (!membership.ok) {
+    return null;
+  }
+
+  if (plan.is_public || plan.creator_id === actorUserId) {
+    return plan;
+  }
+
+  return null;
+}

package/src/platform-release.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getPlatformReleaseInfo,
+  normalizePlatformBuildMetadata,
+  TUTURUUU_PLATFORM_VERSION,
+} from './platform-release';
+
+describe('platform release metadata', () => {
+  it('uses the centralized shared browser app version', () => {
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.8.0'); // x-release-please-version
+  });
+
+  it('normalizes generated metadata and derives a short hash', () => {
+    expect(
+      normalizePlatformBuildMetadata({
+        builtAt: '2026-05-27T10:00:00.000Z',
+        commitHash: 'abcdef1234567890',
+        commitMessage: 'feat: ship version badge',
+        deploymentStamp: 'deploy-2026-05-27',
+        deploymentUrl: 'https://apps.tuturuuu.com',
+        environment: 'production',
+        refName: 'production',
+      })
+    ).toEqual({
+      builtAt: '2026-05-27T10:00:00.000Z',
+      commitHash: 'abcdef1234567890',
+      commitMessage: 'feat: ship version badge',
+      deploymentStamp: 'deploy-2026-05-27',
+      deploymentUrl: 'https://apps.tuturuuu.com',
+      environment: 'production',
+      refName: 'production',
+      shortCommitHash: 'abcdef1',
+    });
+  });
+
+  it('keeps local metadata stable when build values are missing', () => {
+    expect(normalizePlatformBuildMetadata({})).toMatchObject({
+      builtAt: 'local',
+      commitHash: 'local',
+      commitMessage: 'Unknown',
+      deploymentStamp: null,
+      deploymentUrl: null,
+      environment: 'local',
+      refName: 'local',
+      shortCommitHash: 'local',
+    });
+  });
+
+  it('prefers explicit runtime platform build metadata over generated fallback values', () => {
+    expect(
+      getPlatformReleaseInfo('Tuturuuu', {
+        PLATFORM_BUILD_BUILT_AT: '2026-05-28T06:00:00.000Z',
+        PLATFORM_BUILD_COMMIT_HASH: '1234567890abcdef',
+        PLATFORM_BUILD_COMMIT_MESSAGE: 'fix(web): infer blue green metadata',
+        PLATFORM_BUILD_COMMIT_SHORT_HASH: '1234567',
+        PLATFORM_BUILD_DEPLOYMENT_STAMP: '2026-05-28T06-00-00Z',
+        PLATFORM_BUILD_DEPLOYMENT_URL: 'tuturuuu.com',
+        PLATFORM_BUILD_ENVIRONMENT: 'production',
+        PLATFORM_BUILD_REF_NAME: 'production',
+      })
+    ).toMatchObject({
+      appName: 'Tuturuuu',
+      builtAt: '2026-05-28T06:00:00.000Z',
+      commitHash: '1234567890abcdef',
+      commitMessage: 'fix(web): infer blue green metadata',
+      deploymentStamp: '2026-05-28T06-00-00Z',
+      deploymentUrl: 'https://tuturuuu.com',
+      environment: 'production',
+      refName: 'production',
+      shortCommitHash: '1234567',
+      version: TUTURUUU_PLATFORM_VERSION,
+    });
+  });
+});

package/src/platform-release.ts

@@ -0,0 +1,155 @@
+import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
+
+export const TUTURUUU_PLATFORM_VERSION = '0.8.0'; // x-release-please-version
+
+export type PlatformBuildMetadataInput = {
+  builtAt?: string | null;
+  commitHash?: string | null;
+  commitMessage?: string | null;
+  deploymentStamp?: string | null;
+  deploymentUrl?: string | null;
+  environment?: string | null;
+  refName?: string | null;
+  shortCommitHash?: string | null;
+};
+
+export type PlatformBuildMetadata = {
+  builtAt: string;
+  commitHash: string;
+  commitMessage: string;
+  deploymentStamp: string | null;
+  deploymentUrl: string | null;
+  environment: string;
+  refName: string;
+  shortCommitHash: string;
+};
+
+export type PlatformReleaseInfo = PlatformBuildMetadata & {
+  appName: string;
+  version: string;
+};
+
+export type PlatformBuildRuntimeEnv = Partial<
+  Record<
+    | 'PLATFORM_BUILD_BUILT_AT'
+    | 'PLATFORM_BUILD_COMMIT_HASH'
+    | 'PLATFORM_BUILD_COMMIT_MESSAGE'
+    | 'PLATFORM_BUILD_COMMIT_SHORT_HASH'
+    | 'PLATFORM_BUILD_DEPLOYMENT_STAMP'
+    | 'PLATFORM_BUILD_DEPLOYMENT_URL'
+    | 'PLATFORM_BUILD_ENVIRONMENT'
+    | 'PLATFORM_BUILD_REF_NAME',
+    string | null | undefined
+  >
+>;
+
+function cleanString(value: string | null | undefined) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function normalizeOptionalString(value: string | null | undefined) {
+  return cleanString(value);
+}
+
+function normalizeUrl(value: string | null | undefined) {
+  const url = cleanString(value);
+
+  if (!url) {
+    return null;
+  }
+
+  return /^https?:\/\//iu.test(url) ? url : `https://${url}`;
+}
+
+function readRuntimePlatformBuildMetadata(
+  env: PlatformBuildRuntimeEnv
+): PlatformBuildMetadataInput {
+  return {
+    builtAt: cleanString(env.PLATFORM_BUILD_BUILT_AT),
+    commitHash: cleanString(env.PLATFORM_BUILD_COMMIT_HASH),
+    commitMessage: cleanString(env.PLATFORM_BUILD_COMMIT_MESSAGE),
+    deploymentStamp: cleanString(env.PLATFORM_BUILD_DEPLOYMENT_STAMP),
+    deploymentUrl: normalizeUrl(env.PLATFORM_BUILD_DEPLOYMENT_URL),
+    environment: cleanString(env.PLATFORM_BUILD_ENVIRONMENT),
+    refName: cleanString(env.PLATFORM_BUILD_REF_NAME),
+    shortCommitHash: cleanString(env.PLATFORM_BUILD_COMMIT_SHORT_HASH),
+  };
+}
+
+function getRuntimeEnv(): PlatformBuildRuntimeEnv {
+  if (typeof process === 'undefined') {
+    return {};
+  }
+
+  return {
+    PLATFORM_BUILD_BUILT_AT: process.env.PLATFORM_BUILD_BUILT_AT,
+    PLATFORM_BUILD_COMMIT_HASH: process.env.PLATFORM_BUILD_COMMIT_HASH,
+    PLATFORM_BUILD_COMMIT_MESSAGE: process.env.PLATFORM_BUILD_COMMIT_MESSAGE,
+    PLATFORM_BUILD_COMMIT_SHORT_HASH:
+      process.env.PLATFORM_BUILD_COMMIT_SHORT_HASH,
+    PLATFORM_BUILD_DEPLOYMENT_STAMP:
+      process.env.PLATFORM_BUILD_DEPLOYMENT_STAMP,
+    PLATFORM_BUILD_DEPLOYMENT_URL: process.env.PLATFORM_BUILD_DEPLOYMENT_URL,
+    PLATFORM_BUILD_ENVIRONMENT: process.env.PLATFORM_BUILD_ENVIRONMENT,
+    PLATFORM_BUILD_REF_NAME: process.env.PLATFORM_BUILD_REF_NAME,
+  };
+}
+
+function mergePlatformBuildMetadata(
+  generated: PlatformBuildMetadataInput,
+  runtime: PlatformBuildMetadataInput
+): PlatformBuildMetadataInput {
+  return {
+    builtAt: runtime.builtAt ?? generated.builtAt,
+    commitHash: runtime.commitHash ?? generated.commitHash,
+    commitMessage: runtime.commitMessage ?? generated.commitMessage,
+    deploymentStamp: runtime.deploymentStamp ?? generated.deploymentStamp,
+    deploymentUrl: runtime.deploymentUrl ?? generated.deploymentUrl,
+    environment: runtime.environment ?? generated.environment,
+    refName: runtime.refName ?? generated.refName,
+    shortCommitHash: runtime.shortCommitHash ?? generated.shortCommitHash,
+  };
+}
+
+export function normalizePlatformBuildMetadata(
+  input: PlatformBuildMetadataInput
+): PlatformBuildMetadata {
+  const commitHash = cleanString(input.commitHash) ?? 'local';
+  const shortCommitHash =
+    cleanString(input.shortCommitHash) ??
+    (commitHash === 'local' ? 'local' : commitHash.slice(0, 7));
+
+  return {
+    builtAt: cleanString(input.builtAt) ?? 'local',
+    commitHash,
+    commitMessage: cleanString(input.commitMessage) ?? 'Unknown',
+    deploymentStamp: normalizeOptionalString(input.deploymentStamp),
+    deploymentUrl: normalizeUrl(input.deploymentUrl),
+    environment: cleanString(input.environment) ?? 'local',
+    refName: cleanString(input.refName) ?? 'local',
+    shortCommitHash,
+  };
+}
+
+export const TUTURUUU_PLATFORM_BUILD_METADATA = normalizePlatformBuildMetadata(
+  PLATFORM_BUILD_METADATA
+);
+
+export function getPlatformReleaseInfo(
+  appName: string,
+  env: PlatformBuildRuntimeEnv = getRuntimeEnv()
+): PlatformReleaseInfo {
+  const metadata = normalizePlatformBuildMetadata(
+    mergePlatformBuildMetadata(
+      PLATFORM_BUILD_METADATA,
+      readRuntimePlatformBuildMetadata(env)
+    )
+  );
+
+  return {
+    ...metadata,
+    appName,
+    version: TUTURUUU_PLATFORM_VERSION,
+  };
+}

package/src/portless.ts

@@ -0,0 +1,124 @@
+export const TUTURUUU_PORTLESS_ROOT_HOST = 'tuturuuu.localhost';
+export const TUTURUUU_PORTLESS_ROOT_ORIGIN = `https://${TUTURUUU_PORTLESS_ROOT_HOST}`;
+export const TUTURUUU_PORTLESS_ALLOWED_DEV_ORIGINS = [
+  TUTURUUU_PORTLESS_ROOT_HOST,
+  `*.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+] as const;
+
+export const TUTURUUU_PORTLESS_APP_ORIGINS = {
+  apps: `https://apps.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  calendar: `https://calendar.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  chat: `https://chat.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  cms: `https://cms.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  drive: `https://drive.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  external: `https://external.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  finance: `https://finance.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  hive: `https://hive.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  'hive-realtime': `https://realtime.hive.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  inventory: `https://inventory.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  learn: `https://learn.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  mail: `https://mail.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  meet: `https://meet.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  mind: `https://mind.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  nova: `https://nova.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  platform: TUTURUUU_PORTLESS_ROOT_ORIGIN,
+  playground: `https://playground.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  qr: `https://qr.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  rewise: `https://rewise.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  shortener: `https://shortener.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  storefront: `https://storefront.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  tasks: `https://tasks.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  teach: `https://teach.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+  track: `https://track.${TUTURUUU_PORTLESS_ROOT_HOST}`,
+} as const;
+
+export type TuturuuuPortlessAppName =
+  keyof typeof TUTURUUU_PORTLESS_APP_ORIGINS;
+
+export const TUTURUUU_PORTLESS_APP_HOSTS = Object.fromEntries(
+  Object.entries(TUTURUUU_PORTLESS_APP_ORIGINS).map(([appName, origin]) => [
+    appName,
+    new URL(origin).hostname,
+  ])
+) as {
+  [K in TuturuuuPortlessAppName]: string;
+};
+
+function getPortlessWorktreePrefix(portlessUrl?: string) {
+  if (!portlessUrl) {
+    return null;
+  }
+
+  let hostname: string;
+
+  try {
+    hostname = new URL(portlessUrl).hostname;
+  } catch {
+    return null;
+  }
+
+  for (const baseHost of Object.values(TUTURUUU_PORTLESS_APP_HOSTS).sort(
+    (a, b) => b.length - a.length
+  )) {
+    if (hostname === baseHost) {
+      return null;
+    }
+
+    const suffix = `.${baseHost}`;
+
+    if (!hostname.endsWith(suffix)) {
+      continue;
+    }
+
+    const prefix = hostname.slice(0, -suffix.length);
+
+    if (prefix && !prefix.includes('.')) {
+      return prefix;
+    }
+  }
+
+  return null;
+}
+
+function getPortlessHostname(portlessUrl?: string) {
+  if (!portlessUrl) {
+    return null;
+  }
+
+  try {
+    return new URL(portlessUrl).hostname;
+  } catch {
+    return null;
+  }
+}
+
+export function getTuturuuuPortlessAllowedDevOrigins(
+  portlessUrl = process.env.PORTLESS_URL
+) {
+  const portlessHostname = getPortlessHostname(portlessUrl);
+  const origins: string[] = [...TUTURUUU_PORTLESS_ALLOWED_DEV_ORIGINS];
+
+  if (
+    portlessHostname &&
+    (portlessHostname === TUTURUUU_PORTLESS_ROOT_HOST ||
+      portlessHostname.endsWith(`.${TUTURUUU_PORTLESS_ROOT_HOST}`))
+  ) {
+    origins.push(portlessHostname);
+  }
+
+  return Array.from(new Set(origins));
+}
+
+export function getTuturuuuPortlessAppOrigin(
+  appName: TuturuuuPortlessAppName,
+  options: {
+    portlessUrl?: string;
+  } = {}
+) {
+  const host = TUTURUUU_PORTLESS_APP_HOSTS[appName];
+  const prefix = getPortlessWorktreePrefix(
+    options.portlessUrl ?? process.env.PORTLESS_URL
+  );
+
+  return `https://${prefix ? `${prefix}.${host}` : host}`;
+}

package/src/priority-styles.ts

@@ -0,0 +1,42 @@
+/**
+ * Priority styling utilities for task priority badges and labels.
+ * Provides consistent styling and user-friendly labels across the application.
+ */
+
+/**
+ * Get Tailwind CSS classes for priority badge styling.
+ * Returns appropriate background and text color classes based on priority level.
+ *
+ * @param priority - Priority level (0-3: None, Low, Medium, High)
+ * @returns Tailwind CSS class string for badge styling
+ */
+export function getPriorityBadgeStyles(priority: number): string {
+  switch (priority) {
+    case 1:
+      return 'bg-dynamic-blue/10 text-dynamic-blue';
+    case 2:
+      return 'bg-dynamic-yellow/10 text-dynamic-yellow';
+    case 3:
+      return 'bg-dynamic-red/10 text-dynamic-red';
+    default:
+      return 'bg-foreground/10 text-foreground/80';
+  }
+}
+
+/**
+ * Get user-friendly label for priority level.
+ * Provides localized (or localizable) labels for each priority.
+ *
+ * @param priority - Priority level (0-3)
+ * @param t - Translation function (optional, for i18n support)
+ * @returns User-friendly priority label
+ */
+export function getPriorityLabel(
+  priority: number,
+  t?: (key: string) => string
+): string {
+  const labels = ['None', 'Low', 'Medium', 'High'];
+  return t
+    ? t(`priority.${labels[priority]?.toLowerCase() || 'none'}`)
+    : labels[priority] || 'None';
+}