Function bodies 942 total

function normalizeRunnerLanguage(language: string): string | null {
  const normalizedLanguage = language.trim().toLowerCase();
  return RUNNABLE_LANGUAGE_MAP[normalizedLanguage] ?? null;
}

function pickNumber(source: RunCodeResponse, keys: string[]): number | null {
  for (const key of keys) {
    const value = source[key];

    if (typeof value === 'number' && Number.isFinite(value)) {
      return value;
    }
  }

  return null;
}

function pickString(source: RunCodeResponse, keys: string[]): string | null {
  for (const key of keys) {
    const value = source[key];

    if (typeof value === 'string' && value.trim().length > 0) {
      return value.trim();
    }
  }

  return null;
}

function formatBytes(bytes: number): string {
  if (bytes < 1024) {
    return `${bytes} B`;
  }

  const units = ['KB', 'MB', 'GB'];
  let value = bytes / 1024;
  let unitIndex = 0;

  while (value >= 1024 && unitIndex < units.length - 1) {
    value /= 1024;
    unitIndex += 1;
  }

  return `${value.toFixed(value >= 100 ? 0 : 1)} ${units[unitIndex]}`;
}

function formatDuration(response: RunCodeResponse | null): string {
  if (!response) {
    return '--';
  }

  const numericDuration = pickNumber(response, [
    'executionTimeMs',
    'timeMs',
    'durationMs',
    'runtimeMs',
  ]);

  if (numericDuration !== null) {
    return `${numericDuration} ms`;
  }

  return pickString(response, ['executionTime', 'duration', 'runtime']) ?? '--';
}

function formatMemory(response: RunCodeResponse | null): string {
  if (!response) {
    return '--';
  }

  const memoryBytes = pickNumber(response, ['memoryBytes', 'memoryUsedBytes']);

  if (memoryBytes !== null) {
    return formatBytes(memoryBytes);
  }

  const memoryKb = pickNumber(response, ['memoryKb', 'memoryKB', 'memoryUsedKb']);

  if (memoryKb !== null) {
    return `${memoryKb} KB`;
  }

  const memoryMb = pickNumber(response, ['memoryMb', 'memoryMB', 'memoryUsedMb']);

  if (memoryMb !== null) {
    return `${memoryMb} MB`;
  }

  return pickString(response, ['memory', 'memoryUsed']) ?? '--';
}

function resolveRunnerStatus(response: RunCodeResponse): RunnerStatus {
  const status = typeof response.status === 'string' ? response.status.toLowerCase() : '';

  if (status.includes('timeout')) {
    return 'timeout';
  }

  if (status.includes('error') || status.includes('fail')) {
    return 'error';
  }

  if (typeof response.stderr === 'string' && response.stderr.trim().length > 0) {
    return 'error';
  }

  return 'success';
}

function getStatusLabel(status: RunnerStatus): string {
  switch (status) {
    case 'running':
      return 'Running';
    case 'success':
      return 'Success';
    case 'error':
      return 'Error';
    case 'timeout':
      return 'Timeout';
    default:
      return 'Idle';
  }
}

function getStatusColor(status: RunnerStatus): 'default' | 'success' | 'danger' | 'warning' | 'accent' {
  switch (status) {
    case 'running':
      return 'accent';
    case 'success':
      return 'success';
    case 'timeout':
      return 'warning';
    case 'error':
      return 'danger';
    default:
      return 'default';
  }
}

export function CodeRunnerPanel({
  isOpen,
  language,
  sourceCode,
  onOpenChange,
  onStatusChange,
}: CodeRunnerPanelProps) {
  const { showSidebar } = useDeviceType();
  const { typography } = useAppTheme();

  const [stdinExpanded, setStdinExpanded] = useState(false);
  const [stdin, setStdin] = useState('');
  const [status, setStatus] = useState<RunnerStatus>('idle');
  const [result, setResult] = useState<RunCodeResponse | null>(null);
  const [fontSize, setFontSize] = useState<number>(DEFAULT_CODE_FONT_SIZE);

  useEffect(() => {
    let isMounted = true;

    void getStoredCodeFontSize().then(value => {
      if (isMounted) {
        setFontSize(value);
      }
    });

    return () => {
      isMounted = false;
    };
  }, []);

  useEffect(() => {
    onStatusChange?.(status);
  }, [onStatusChange, status]);

  const resolvedLanguage = useMemo(() => normalizeRunnerLanguage(language), [language]);
  const stdout = typeof result?.stdout === 'string' ? result.stdout.trim() 

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return translateLiteral(error.message);
  }

  return fallback;
}

function toEditableTitle(title: string): string {
  return title === '无标题笔记' ? '' : title;
}

function toStoredTitle(title: string): string {
  const normalizedTitle = title.trim();
  return normalizedTitle.length > 0 ? normalizedTitle : '无标题笔记';
}

function normalizeLanguage(language: string): string {
  const normalizedLanguage = language.trim();
  return normalizedLanguage.length > 0 ? normalizedLanguage : 'markdown';
}

function toStoredLanguage(language: string): string | null {
  const normalizedLanguage = normalizeLanguage(language).toLowerCase();
  return normalizedLanguage === 'markdown' ? null : normalizedLanguage;
}

function formatEditorLanguageLabel(language: string): string {
  const normalizedLanguage = normalizeLanguage(language).toLowerCase();

  switch (normalizedLanguage) {
    case 'markdown':
      return 'MD';
    case 'plaintext':
      return 'TXT';
    case 'javascript':
      return 'JS';
    case 'typescript':
      return 'TS';
    case 'python':
      return 'PY';
    case 'kotlin':
      return 'KT';
    case 'cpp':
      return 'CPP';
    default:
      return normalizedLanguage.toUpperCase();
  }
}

function areStringArraysEqual(left: string[], right: string[]): boolean {
  if (left.length !== right.length) {
    return false;
  }

  return left.every((value, index) => value === right[index]);
}

function getActivityHelperText(
  runnerStatus: RunnerStatus,
  aiBusy: boolean,
  saving: boolean,
  isPending: boolean,
  t: (text: string) => string,
): string {
  if (aiBusy) {
    return t('AI 正在处理中');
  }

  if (runnerStatus === 'running') {
    return t('代码正在沙盒中运行');
  }

  if (saving) {
    return t('保存中...');
  }

  if (isPending) {
    return t('自动保存将在 2 秒后触发');
  }

  return t('已同步到本地');
}

function mergeGeneratedContent(currentContent: string, generatedContent: string): string {
  const trimmedGenerated = generatedContent.trim();

  if (trimmedGenerated.length === 0) {
    return currentContent;
  }

  if (currentContent.trim().length === 0) {
    return trimmedGenerated;
  }

  return `${currentContent.replace(/\s+$/, '')}\n\n${trimmedGenerated}`;
}

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return translateLiteral(error.message);
  }

  return fallback;
}

function formatLanguage(language: string | null): string | null {
  if (!language) {
    return null;
  }

  return language.trim().toUpperCase();
}

function formatNoteType(language: string | null): string {
  const normalizedLanguage = (language ?? 'markdown').trim().toLowerCase();

  switch (normalizedLanguage) {
    case 'markdown':
      return 'MD';
    case 'plaintext':
      return 'TXT';
    case 'javascript':
      return 'JS';
    case 'typescript':
      return 'TS';
    case 'python':
      return 'PY';
    case 'kotlin':
      return 'KT';
    case 'cpp':
      return 'CPP';
    default:
      return formatLanguage(normalizedLanguage) ?? 'NOTE';
  }
}

function getUtf8ByteLength(value: string): number {
  let byteLength = 0;

  for (let index = 0; index < value.length; index += 1) {
    const codePoint = value.charCodeAt(index);

    if (codePoint <= 0x7f) {
      byteLength += 1;
      continue;
    }

    if (codePoint <= 0x7ff) {
      byteLength += 2;
      continue;
    }

    if (codePoint >= 0xd800 && codePoint <= 0xdbff) {
      byteLength += 4;
      index += 1;
      continue;
    }

    byteLength += 3;
  }

  return byteLength;
}

function formatFileSize(bytes: number): string {
  if (bytes < 1024) {
    return `${bytes} B`;
  }

  if (bytes < 1024 * 1024) {
    return `${(bytes / 1024).toFixed(bytes >= 10 * 1024 ? 0 : 1)} KB`;
  }

  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
}

function formatSyncMeta(
  updatedAt: string,
  syncStatus: Note['syncStatus'],
  language: AppLanguage,
  t: (text: string) => string,
): string {
  if (syncStatus === 'created') {
    return t('待首次同步');
  }

  if (syncStatus === 'updated') {
    return t('待同步');
  }

  if (syncStatus === 'deleted') {
    return t('已删除');
  }

  return formatRelativeTime(updatedAt, language);
}

export function NoteListItem({ note, isSelected, onPress }: NoteListItemProps) {
  const { palette, typography } = useAppTheme();
  const { language, t } = useI18n();

  const { activeView, toggleStar, updateNote, deleteNote, restoreNote, permanentDeleteNote } = useNoteStore(useShallow(state => ({
    activeView: state.activeView,
    toggleStar: state.toggleStar,
    updateNote: state.updateNote,
    deleteNote: state.deleteNote,
    restoreNote: state.restoreNote,
    permanentDeleteNote: state.permanentDeleteNote,
  })));

  const folders = useFolderStore(state => state.folders);

  const [isMenuOpen, setIsMenuOpen] = useState(false);
  const [isMoveDialogOpen, setIsMoveDialogOpen] = useState(false);
  const [submitting, setSubmitting] = useState(false);
  const [errorMessage, setErrorMessage] = useState<string | null>(null);

  const noteTypeLabel = useMemo(() => formatNoteType(note.primaryLanguage), [note.primaryLanguage]);
  const fileSizeLabel = useMemo(() => formatFileSize(getU

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return translateLiteral(error.message);
  }

  return fallback;
}

function resolveCreateFolderId(
  activeFolderId: string | null,
  folders: ReturnType<typeof useFolderStore.getState>['folders'],
): string | null {
  if (activeFolderId && folders.some(folder => folder.id === activeFolderId)) {
    return activeFolderId;
  }

  return folders.find(folder => folder.isDefault)?.id ?? folders[0]?.id ?? null;
}

export function NoteList({ showSearchHeader = true }: { showSearchHeader?: boolean }) {
  const navigation = useNavigation<any>();
  const { showSidebar } = useDeviceType();
  const { palette, typography } = useAppTheme();
  const { t } = useI18n();

  const { folders, activeFolderId, fetchFolders } = useFolderStore(useShallow(state => ({
    folders: state.folders,
    activeFolderId: state.activeFolderId,
    fetchFolders: state.fetchFolders,
  })));

  const { allNotes, loading, activeView, searchQuery, activeTagId } = useNoteStore(useShallow(state => ({
    allNotes: state.notes,
    loading: state.loading,
    activeView: state.activeView,
    searchQuery: state.searchQuery,
    activeTagId: state.activeTagId,
  })));

  const notes = useMemo(
    () => applyFilters(allNotes, searchQuery, activeTagId),
    [allNotes, searchQuery, activeTagId],
  );
  const { selectedNoteId, setSearchQuery, fetchNotes, fetchTags, createNote, selectNote } = useNoteStore(useShallow(state => ({
    se

function getRuntimeEnv(): Record<string, string | undefined> {
  const runtime = globalThis as typeof globalThis & { process?: RuntimeProcess };
  return runtime.process?.env ?? {};
}

function resolveWebBaseUrl(): string {
  const env = getRuntimeEnv();
  const configuredBaseUrl =
    env.SNIPXN_WEB_BASE_URL ?? env.WEB_BASE_URL ?? env.REACT_NATIVE_WEB_BASE_URL;

  if (configuredBaseUrl && configuredBaseUrl.trim().length > 0) {
    return configuredBaseUrl.replace(/\/+$/, '');
  }

  return API_BASE_URL.replace(/\/api\/v1\/?$/, '');
}

function buildShareUrl(shareToken: string): string {
  return `${resolveWebBaseUrl()}/share/${shareToken}`;
}

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return translateLiteral(error.message);
  }

  return fallback;
}

function findTagById(tags: Tag[], tagId: string): Tag | undefined {
  return tags.find(tag => tag.id === tagId);
}

function toggleTagId(tagIds: string[], tagId: string): string[] {
  if (tagIds.includes(tagId)) {
    return tagIds.filter(id => id !== tagId);
  }

  return [...tagIds, tagId];
}

function formatToolbarLanguageLabel(language: string): string {
  const normalizedLanguage = language.trim().toLowerCase();

  switch (normalizedLanguage) {
    case 'markdown':
      return 'MD';
    case 'plaintext':
      return 'TXT';
    case 'javascript':
      return 'JS';
    case 'typescript':
      return 'TS';
    case 'python':
      return 'PY';
    case 'kotlin':
      return 'KT';
    case 'cpp':
      return 'CPP';
    case 'json':
      return 'JSON';
    case 'yaml':
      return 'YAML';
    case 'sql':
      return 'SQL';
    case 'bash':
      return 'BASH';
    case 'go':
      return 'GO';
    case 'rust':
      return 'RUST';
    case 'java':
      return 'JAVA';
    default:
      return normalizedLanguage.length > 0 ? normalizedLanguage.toUpperCase() : 'MD';
  }
}

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return error.message;
  }

  return fallback;
}

function formatFolderIcon(icon: string): string {
  return icon === 'folder' ? '📁' : icon;
}

function isFolderEmojiIcon(icon: string): boolean {
  const trimmedIcon = icon.trim();

  return (
    trimmedIcon.length > 0 &&
    trimmedIcon.length <= 4 &&
    !/[A-Za-z0-9]/.test(trimmedIcon) &&
    !/\s/.test(trimmedIcon)
  );
}

function renderFolderGlyph(
  icon: string,
  color: string,
  iconSize = SIDEBAR_LIST_ICON_SIZE,
  emojiSize = SIDEBAR_EMOJI_SIZE,
) {
  if (icon === 'folder' || !isFolderEmojiIcon(icon)) {
    return <AppIcon color={color} name="folder" size={iconSize} strokeWidth={2} />;
  }

  return (
    <Text
      style={{
        color,
        fontSize: emojiSize,
        fontWeight: '600',
        lineHeight: emojiSize + 1,
      }}>
      {formatFolderIcon(icon)}
    </Text>
  );
}

function buildMovedFolderIds(folderId: string, folders: Folder[], direction: -1 | 1): string[] {
  const nextFolders = [...folders];
  const currentIndex = nextFolders.findIndex(folder => folder.id === folderId);
  const targetIndex = currentIndex + direction;

  if (currentIndex < 0 || targetIndex < 0 || targetIndex >= nextFolders.length) {
    return folders.map(folder => folder.id);
  }

  const [folder] = nextFolders.splice(currentIndex, 1);
  nextFolders.splice(targetIndex, 0, folder);

  return nextFolders.map(item => item.id);
}

function resolveAvatarUri(avatar: string | null): string | null {
  if (!avatar) {
    return null;
  }

  if (/^https?:\/\//i.test(avatar)) {
    return avatar;
  }

function getAvatarFallback(nickname: string | null | undefined, email: string | undefined): string {
  const source = nickname?.trim() || email?.trim() || 'S';
  return source.slice(0, 1).toUpperCase();
}

function formatBytes(bytes: number): string {
  if (bytes < 1024) {
    return `${bytes} B`;
  }

  const units = ['KB', 'MB', 'GB', 'TB'];
  let value = bytes / 1024;
  let unitIndex = 0;

  while (value >= 1024 && unitIndex < units.length - 1) {
    value /= 1024;
    unitIndex += 1;
  }

  return `${value.toFixed(value >= 100 ? 0 : 1)} ${units[unitIndex]}`;
}

function SidebarSectionTitle({
  title,
  collapsed,
}: {
  title: string;
  collapsed: boolean;
}) {
  const { palette, typography } = useAppTheme();

  if (collapsed) {
    return null;
  }

  return (
    <Animated.View entering={APP_FADE_IN} exiting={APP_FADE_OUT}>
      <Text className={typography.caption} style={{ color: palette.textSoft }}>
        {title}
      </Text>
    </Animated.View>
  );
}

function getErrorMessage(error: unknown, fallback: string): string {
  if (
    typeof error === 'object' &&
    error !== null &&
    'message' in error &&
    typeof error.message === 'string'
  ) {
    return error.message;
  }

  return fallback;
}

function resolveTagColor(color: string | null): string {
  if (color && HEX_COLOR_PATTERN.test(color)) {
    return color;
  }

  return FALLBACK_TAG_COLOR;
}

function buildTagColorOptions(selectedColor: string) {
  const resolvedColor = resolveTagColor(selectedColor || null);

  if (TAG_COLOR_OPTIONS.some(option => option.value === resolvedColor)) {
    return TAG_COLOR_OPTIONS;
  }

  return [{ label: '当前', value: resolvedColor }, ...TAG_COLOR_OPTIONS];
}

export function TagList() {
  const navigation = useNavigation<any>();
  const { palette, typography } = useAppTheme();

  const { tags, activeTagId, createTag, updateTag, deleteTag, fetchNotes, setActiveTagId, setActiveView } = useNoteStore(useShallow(state => ({
    tags: state.tags,
    activeTagId: state.activeTagId,
    createTag: state.createTag,
    updateTag: state.updateTag,
    deleteTag: state.deleteTag,
    fetchNotes: state.fetchNotes,
    setActiveTagId: state.setActiveTagId,
    setActiveView: state.setActiveView,
  })));

  const [dialogMode, setDialogMode] = useState<TagDialogMode>(null);
  const [menuTag, setMenuTag] = useState<Tag | null>(null);
  const [editingTag, setEditingTag] = useState<Tag | null>(null);
  const [nameInput, setNameInput] = useState('');
  const [colorInput, setColorInput] = useState<string>(TAG_COLOR_OPTIONS[0].value);
  const [nameTouched, setNameTouched] = useState(false);
  const [submitting, setSubmitting] = useState(false);
  const [errorM

export function getOAuthRedirectUri(): string {
  return OAUTH_REDIRECT_URI;
}