@tuturuuu/utils 0.0.3 → 0.6.0

package/src/finance/transform-invoice-results.ts

@@ -0,0 +1,219 @@
+import type { Invoice } from '@tuturuuu/types/primitives/Invoice';
+
+/**
+ * Type definitions for the raw data structures returned from Supabase queries
+ */
+
+export interface SearchInvoiceRpcResult {
+  id: string;
+  ws_id: string;
+  customer_id: string;
+  notice?: string | null;
+  note?: string | null;
+  price: number;
+  total_diff?: number | null;
+  created_at: string;
+  creator_id: string;
+  platform_creator_id?: string | null;
+  transaction_id?: string | null;
+  customer_full_name?: string | null;
+  customer_avatar_url?: string | null;
+  total_count: number;
+}
+
+export interface FullInvoiceData {
+  id: string;
+  ws_id: string;
+  customer_id: string | null;
+  notice?: string | null;
+  note?: string | null;
+  price: number;
+  total_diff?: number | null;
+  created_at: string | null;
+  creator_id: string | null;
+  platform_creator_id?: string | null;
+  transaction_id?: string | null;
+  customer?: {
+    full_name: string | null;
+    avatar_url: string | null;
+  } | null;
+  legacy_creator: LegacyCreator | null;
+  platform_creator: PlatformCreator | null;
+  wallet_transactions: WalletTransaction | null;
+}
+
+export interface LegacyCreator {
+  id: string;
+  display_name?: string | null;
+  full_name?: string | null;
+  email?: string | null;
+  avatar_url?: string | null;
+}
+
+export interface PlatformCreator {
+  id: string;
+  display_name: string | null;
+  avatar_url: string | null;
+  user_private_details: {
+    full_name: string | null;
+    email: string | null;
+  } | null;
+}
+
+export interface WalletTransaction {
+  wallet_id?: string | null;
+  wallet?: {
+    name: string | null;
+  } | null;
+}
+
+/**
+ * Normalizes creator data from either platform or legacy creator sources
+ * Resolves display_name, full_name, email, and avatar_url with proper fallback chain
+ *
+ * @param platformCreator Platform creator object (preferred source)
+ * @param legacyCreator Legacy creator object (fallback source)
+ * @returns Normalized creator object for Invoice type
+ */
+function normalizeCreator(
+  platformCreator: PlatformCreator | null,
+  legacyCreator: LegacyCreator | null
+): Invoice['creator'] {
+  return {
+    id: platformCreator?.id ?? legacyCreator?.id ?? '',
+    display_name:
+      platformCreator?.display_name ??
+      legacyCreator?.display_name ??
+      platformCreator?.user_private_details?.email ??
+      null,
+    full_name:
+      platformCreator?.user_private_details?.full_name ??
+      legacyCreator?.full_name ??
+      null,
+    email:
+      platformCreator?.user_private_details?.email ??
+      legacyCreator?.email ??
+      null,
+    avatar_url:
+      platformCreator?.avatar_url ?? legacyCreator?.avatar_url ?? null,
+  };
+}
+
+/**
+ * Extracts wallet information from wallet transaction data
+ *
+ * @param walletTransactions Wallet transaction object containing wallet relation
+ * @returns Normalized wallet object for Invoice type, or null if no wallet present
+ */
+function normalizeWallet(
+  walletTransactions: WalletTransaction | null
+): { name: string | null } | null {
+  return walletTransactions?.wallet
+    ? { name: walletTransactions.wallet.name }
+    : null;
+}
+
+/**
+ * Intermediate type for merged search results
+ * Combines SearchInvoiceRpcResult with additional creator and wallet data
+ */
+interface MergedSearchInvoiceData
+  extends Omit<
+    SearchInvoiceRpcResult,
+    'customer_full_name' | 'customer_avatar_url'
+  > {
+  customer: {
+    full_name: string | null;
+    avatar_url: string | null;
+  };
+  legacy_creator: LegacyCreator | null;
+  platform_creator: PlatformCreator | null;
+  wallet_transactions: WalletTransaction | null;
+}
+
+/**
+ * Transforms and merges search results from RPC with full invoice data from follow-up query
+ * Handles creator resolution (platform_creator vs legacy_creator) and wallet mapping
+ *
+ * @param searchResults Raw results from the search_finance_invoices RPC function
+ * @param fullInvoices Full invoice data fetched from finance_invoices table with relations
+ * @returns Normalized Invoice[] array ready for UI consumption
+ */
+export function transformInvoiceSearchResults(
+  searchResults: SearchInvoiceRpcResult[],
+  fullInvoices: FullInvoiceData[]
+): Invoice[] {
+  // Create an index map for O(1) lookup instead of O(n) find operations
+  const fullInvoiceMap = new Map(fullInvoices?.map((fi) => [fi.id, fi]) ?? []);
+
+  // First merge: combine search results with full invoice data
+  const rawData = searchResults.map((searchRow) => {
+    const fullInvoice = fullInvoiceMap.get(searchRow.id);
+    return {
+      ...searchRow,
+      customer: {
+        full_name: searchRow.customer_full_name,
+        avatar_url: searchRow.customer_avatar_url,
+      },
+      legacy_creator: fullInvoice?.legacy_creator || null,
+      platform_creator: fullInvoice?.platform_creator || null,
+      wallet_transactions: fullInvoice?.wallet_transactions || null,
+    };
+  }) as MergedSearchInvoiceData[];
+
+  // Second transform: normalize creator data and shape into Invoice type
+  return rawData.map(
+    ({
+      customer,
+      legacy_creator,
+      platform_creator,
+      wallet_transactions,
+      ...rest
+    }: MergedSearchInvoiceData) => {
+      const creator = normalizeCreator(
+        platform_creator as PlatformCreator | null,
+        legacy_creator as LegacyCreator | null
+      );
+      const wallet = normalizeWallet(wallet_transactions);
+
+      return {
+        ...rest,
+        customer,
+        creator,
+        wallet,
+      } as Invoice;
+    }
+  );
+}
+
+/**
+ * Transforms direct query results (non-search path) into Invoice format
+ * Used when no search query is present and we fetch via standard query builder
+ *
+ * @param rawData Array of raw invoice data with creator and wallet relations
+ * @returns Normalized Invoice[] array ready for UI consumption
+ */
+export function transformInvoiceData(rawData: FullInvoiceData[]): Invoice[] {
+  return rawData.map(
+    ({
+      customer,
+      legacy_creator,
+      platform_creator,
+      wallet_transactions,
+      ...rest
+    }: FullInvoiceData) => {
+      const creator = normalizeCreator(
+        platform_creator as PlatformCreator | null,
+        legacy_creator as LegacyCreator | null
+      );
+      const wallet = normalizeWallet(wallet_transactions);
+
+      return {
+        ...rest,
+        customer,
+        creator,
+        wallet,
+      } as Invoice;
+    }
+  );
+}

package/src/finance/wallet-permissions.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it } from 'vitest';
+import {
+  CHANGE_FINANCE_WALLETS_PERMISSION,
+  canChangeLinkedFinanceWallets,
+  canReassignFinanceWallet,
+  canSetAnyFinanceWalletOnCreate,
+  canUseRequestedFinanceWalletOnCreate,
+  SET_FINANCE_WALLETS_ON_CREATE_PERMISSION,
+  shouldLockFinanceWalletSelectionOnCreate,
+} from './wallet-permissions';
+
+function createPermissions(granted: string[]) {
+  const grantedSet = new Set(granted);
+
+  return {
+    withoutPermission: (permission: string) => !grantedSet.has(permission),
+  };
+}
+
+describe('finance wallet permissions', () => {
+  it('allows non-default wallet selection on create with either create-only or full wallet permission', () => {
+    const noWalletPermissions = createPermissions([]);
+    const createOnlyPermissions = createPermissions([
+      SET_FINANCE_WALLETS_ON_CREATE_PERMISSION,
+    ]);
+    const fullPermissions = createPermissions([
+      CHANGE_FINANCE_WALLETS_PERMISSION,
+    ]);
+
+    expect(
+      canUseRequestedFinanceWalletOnCreate({
+        permissions: noWalletPermissions,
+        defaultWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(false);
+
+    expect(
+      canUseRequestedFinanceWalletOnCreate({
+        permissions: createOnlyPermissions,
+        defaultWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(true);
+
+    expect(
+      canUseRequestedFinanceWalletOnCreate({
+        permissions: fullPermissions,
+        defaultWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(true);
+  });
+
+  it('allows create flows when no override is needed', () => {
+    const noWalletPermissions = createPermissions([]);
+
+    expect(
+      canUseRequestedFinanceWalletOnCreate({
+        permissions: noWalletPermissions,
+        defaultWalletId: undefined,
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(true);
+
+    expect(
+      canUseRequestedFinanceWalletOnCreate({
+        permissions: noWalletPermissions,
+        defaultWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-default',
+      })
+    ).toBe(true);
+  });
+
+  it('keeps reassignment restricted to the full wallet-change permission', () => {
+    const createOnlyPermissions = createPermissions([
+      SET_FINANCE_WALLETS_ON_CREATE_PERMISSION,
+    ]);
+    const fullPermissions = createPermissions([
+      CHANGE_FINANCE_WALLETS_PERMISSION,
+    ]);
+
+    expect(
+      canReassignFinanceWallet({
+        permissions: createOnlyPermissions,
+        currentWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(false);
+
+    expect(
+      canReassignFinanceWallet({
+        permissions: fullPermissions,
+        currentWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-alt',
+      })
+    ).toBe(true);
+  });
+
+  it('treats unchanged or omitted wallet updates as allowed', () => {
+    const noWalletPermissions = createPermissions([]);
+
+    expect(
+      canReassignFinanceWallet({
+        permissions: noWalletPermissions,
+        currentWalletId: 'wallet-default',
+        requestedWalletId: 'wallet-default',
+      })
+    ).toBe(true);
+
+    expect(
+      canReassignFinanceWallet({
+        permissions: noWalletPermissions,
+        currentWalletId: 'wallet-default',
+        requestedWalletId: undefined,
+      })
+    ).toBe(true);
+  });
+
+  it('surfaces helper booleans for create-only and full wallet access', () => {
+    expect(canChangeLinkedFinanceWallets(createPermissions([]))).toBe(false);
+    expect(
+      canChangeLinkedFinanceWallets(
+        createPermissions([CHANGE_FINANCE_WALLETS_PERMISSION])
+      )
+    ).toBe(true);
+
+    expect(canSetAnyFinanceWalletOnCreate(createPermissions([]))).toBe(false);
+    expect(
+      canSetAnyFinanceWalletOnCreate(
+        createPermissions([SET_FINANCE_WALLETS_ON_CREATE_PERMISSION])
+      )
+    ).toBe(true);
+  });
+
+  it('locks create-form wallet selection only when neither wallet override permission is present', () => {
+    expect(
+      shouldLockFinanceWalletSelectionOnCreate({
+        defaultWalletId: 'wallet-default',
+        canChangeFinanceWallets: false,
+        canSetFinanceWalletsOnCreate: false,
+      })
+    ).toBe(true);
+
+    expect(
+      shouldLockFinanceWalletSelectionOnCreate({
+        defaultWalletId: 'wallet-default',
+        canChangeFinanceWallets: false,
+        canSetFinanceWalletsOnCreate: true,
+      })
+    ).toBe(false);
+
+    expect(
+      shouldLockFinanceWalletSelectionOnCreate({
+        defaultWalletId: 'wallet-default',
+        canChangeFinanceWallets: true,
+        canSetFinanceWalletsOnCreate: false,
+      })
+    ).toBe(false);
+
+    expect(
+      shouldLockFinanceWalletSelectionOnCreate({
+        defaultWalletId: undefined,
+        canChangeFinanceWallets: false,
+        canSetFinanceWalletsOnCreate: false,
+      })
+    ).toBe(false);
+  });
+});

package/src/finance/wallet-permissions.ts

@@ -0,0 +1,82 @@
+import type { PermissionId } from '@tuturuuu/types/db';
+
+export const CHANGE_FINANCE_WALLETS_PERMISSION =
+  'change_finance_wallets' as const;
+export const SET_FINANCE_WALLETS_ON_CREATE_PERMISSION =
+  'set_finance_wallets_on_create' as const;
+
+type FinanceWalletPermissionLookup = {
+  withoutPermission: (permission: PermissionId) => boolean;
+};
+
+interface FinanceWalletCreateAccessOptions {
+  permissions: FinanceWalletPermissionLookup;
+  defaultWalletId?: string | null;
+  requestedWalletId?: string | null;
+}
+
+interface FinanceWalletReassignmentOptions {
+  permissions: FinanceWalletPermissionLookup;
+  currentWalletId?: string | null;
+  requestedWalletId?: string | null;
+}
+
+interface FinanceWalletCreateLockOptions {
+  defaultWalletId?: string | null;
+  canChangeFinanceWallets?: boolean;
+  canSetFinanceWalletsOnCreate?: boolean;
+}
+
+export function canChangeLinkedFinanceWallets(
+  permissions: FinanceWalletPermissionLookup
+) {
+  return !permissions.withoutPermission(CHANGE_FINANCE_WALLETS_PERMISSION);
+}
+
+export function canSetAnyFinanceWalletOnCreate(
+  permissions: FinanceWalletPermissionLookup
+) {
+  return (
+    canChangeLinkedFinanceWallets(permissions) ||
+    !permissions.withoutPermission(SET_FINANCE_WALLETS_ON_CREATE_PERMISSION)
+  );
+}
+
+export function canUseRequestedFinanceWalletOnCreate({
+  permissions,
+  defaultWalletId,
+  requestedWalletId,
+}: FinanceWalletCreateAccessOptions) {
+  if (!defaultWalletId || requestedWalletId === defaultWalletId) {
+    return true;
+  }
+
+  return canSetAnyFinanceWalletOnCreate(permissions);
+}
+
+export function canReassignFinanceWallet({
+  permissions,
+  currentWalletId,
+  requestedWalletId,
+}: FinanceWalletReassignmentOptions) {
+  if (
+    requestedWalletId === undefined ||
+    requestedWalletId === currentWalletId
+  ) {
+    return true;
+  }
+
+  return canChangeLinkedFinanceWallets(permissions);
+}
+
+export function shouldLockFinanceWalletSelectionOnCreate({
+  defaultWalletId,
+  canChangeFinanceWallets = false,
+  canSetFinanceWalletsOnCreate = false,
+}: FinanceWalletCreateLockOptions) {
+  return (
+    !!defaultWalletId &&
+    !canChangeFinanceWallets &&
+    !canSetFinanceWalletsOnCreate
+  );
+}

package/src/format.ts

@@ -1,6 +1,8 @@
 import { type ClassValue, clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 
+import { getCurrencyLocale as getCurrencyLocaleFromConfig } from './currencies';
+
 export function cn(...inputs: ClassValue[]): string {
   return twMerge(clsx(inputs));
 }
@@ -25,9 +27,126 @@ export function formatBytes(
   const accurateSizes = ['Bytes', 'KiB', 'MiB', 'GiB', 'TiB'];
   if (bytes === 0) return '0 Byte';
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return `${(bytes / Math.pow(1024, i)).toFixed(decimals)} ${
+  return `${(bytes / 1024 ** i).toFixed(decimals)} ${
     sizeType === 'accurate'
       ? (accurateSizes[i] ?? 'Bytest')
       : (sizes[i] ?? 'Bytes')
   }`;
 }
+
+export function formatDuration(seconds: number): string {
+  if (seconds < 60) {
+    return `${seconds} seconds`;
+  }
+
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const remainingSeconds = seconds % 60;
+
+  const parts = [];
+  if (hours > 0) {
+    parts.push(`${hours} ${hours === 1 ? 'hour' : 'hours'}`);
+  }
+  if (minutes > 0) {
+    parts.push(`${minutes} ${minutes === 1 ? 'minute' : 'minutes'}`);
+  }
+  if (remainingSeconds > 0 && hours === 0) {
+    // Only show seconds if less than 1 hour
+    parts.push(
+      `${remainingSeconds} ${remainingSeconds === 1 ? 'second' : 'seconds'}`
+    );
+  }
+
+  return parts.join(' ');
+}
+
+/**
+ * Validates if a URL is a safe blob URL
+ */
+export function isValidBlobUrl(url: string | null | undefined): boolean {
+  if (typeof url !== 'string') return false;
+  const s = url.trim();
+  return s.toLowerCase().startsWith('blob:');
+}
+
+/**
+ * Validates if a URL is a safe HTTP or HTTPS URL
+ */
+export function isValidHttpUrl(url: string | null | undefined): boolean {
+  if (typeof url !== 'string') return false;
+  const s = url.trim();
+  try {
+    const parsedUrl = new URL(s);
+    const protocol = parsedUrl.protocol.toLowerCase();
+    // Require a hostname to avoid odd cases like "http:/foo"
+    return (
+      (protocol === 'http:' || protocol === 'https:') && !!parsedUrl.hostname
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Format a number in compact notation (e.g., 1.2K, 125K, 3.4M).
+ * Numbers below `threshold` are returned as-is with locale grouping.
+ *
+ * @param value - The number to format
+ * @param opts - Options for formatting
+ * @param opts.threshold - Minimum value to trigger compact notation (default: 1000)
+ * @param opts.maximumFractionDigits - Max decimal places in compact form (default: 1)
+ * @param opts.locale - Locale for Intl formatting (default: 'en')
+ * @returns Formatted string (e.g., "999", "1.2K", "3.4M")
+ */
+export function formatCompactNumber(
+  value: number,
+  opts: {
+    threshold?: number;
+    maximumFractionDigits?: number;
+    locale?: string;
+  } = {}
+): string {
+  const { threshold = 1000, maximumFractionDigits = 1, locale = 'en' } = opts;
+
+  if (Math.abs(value) < threshold) {
+    return value.toLocaleString(locale);
+  }
+
+  return new Intl.NumberFormat(locale, {
+    notation: 'compact',
+    maximumFractionDigits,
+  }).format(value);
+}
+
+/**
+ * Get the locale for a specific currency.
+ * Re-exported from currencies module for backward compatibility.
+ *
+ * @param currency - The currency code
+ * @returns The locale string
+ */
+export const getCurrencyLocale = getCurrencyLocaleFromConfig;
+
+/**
+ * Format a number as currency with locale-specific formatting
+ * @param amount - The amount to format
+ * @param currency - The currency code (default: 'VND')
+ * @param locale - The locale to use (optional, derived from currency if not provided)
+ * @param options - Additional Intl.NumberFormat options
+ * @returns Formatted currency string
+ */
+export function formatCurrency(
+  amount: number,
+  currency = 'VND',
+  locale?: string,
+  options?: Partial<Intl.NumberFormatOptions>
+): string {
+  const { signDisplay = 'auto', ...rest } = options || {};
+  const effectiveLocale = locale || getCurrencyLocale(currency);
+  return new Intl.NumberFormat(effectiveLocale, {
+    style: 'currency',
+    currency,
+    signDisplay,
+    ...rest,
+  }).format(amount);
+}

package/src/generated/platform-build-metadata.ts

@@ -0,0 +1,11 @@
+import type { PlatformBuildMetadataInput } from '../platform-release';
+
+export const PLATFORM_BUILD_METADATA: PlatformBuildMetadataInput = {
+  builtAt: 'local',
+  commitHash: 'local',
+  commitMessage: 'Unknown',
+  deploymentStamp: null,
+  deploymentUrl: null,
+  environment: 'local',
+  refName: 'local',
+};

package/src/hooks/use-platform.ts

@@ -0,0 +1,64 @@
+'use client';
+
+import { useSyncExternalStore } from 'react';
+
+/**
+ * Detect if the current platform is Mac
+ * This runs synchronously to avoid hydration mismatch
+ */
+function getIsMac(): boolean {
+  if (typeof window === 'undefined') return false;
+
+  // Modern API: navigator.userAgentData (Chromium-based browsers)
+  if ('userAgentData' in navigator && navigator.userAgentData) {
+    const platform = (navigator.userAgentData as { platform?: string })
+      .platform;
+    return platform?.toLowerCase().includes('mac') ?? false;
+  }
+
+  // Fallback: navigator.platform (deprecated but widely supported)
+  return /Mac|iPhone|iPad|iPod/.test(navigator.platform);
+}
+
+// Cache the result since it won't change during session
+let cachedIsMac: boolean | null = null;
+
+function subscribe() {
+  // Platform doesn't change, so no-op
+  return () => {};
+}
+
+function getSnapshot(): boolean {
+  if (cachedIsMac === null) {
+    cachedIsMac = getIsMac();
+  }
+  return cachedIsMac;
+}
+
+function getServerSnapshot(): boolean {
+  // On server, default to false (non-Mac)
+  // The client will hydrate with the correct value
+  return false;
+}
+
+/**
+ * Hook to detect the user's platform (Mac vs non-Mac)
+ * Uses useSyncExternalStore for proper SSR/hydration handling
+ */
+export function usePlatform() {
+  const isMac = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+
+  return {
+    isMac,
+    modKey: isMac ? '⌘' : 'Ctrl',
+    modKeyAlt: isMac ? '⌥' : 'Alt',
+  };
+}
+
+/**
+ * Get platform-aware modifier key for SSR-safe contexts
+ * Returns a default and should be used with the hook for client-side rendering
+ */
+export function getModifierKeyLabel(isMac: boolean) {
+  return isMac ? '⌘' : 'Ctrl';
+}