@controleonline/ui-default 1.0.270 → 1.0.273

package/src/react/components/upload/DefaultUploadManagerModal.js

@@ -0,0 +1,247 @@
+import React from 'react';
+import {
+  ActivityIndicator,
+  ScrollView,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  View,
+} from 'react-native';
+import {MaterialCommunityIcons} from '@expo/vector-icons';
+import AnimatedModal from '@controleonline/ui-common/src/react/components/AnimatedModal';
+import DefaultFile from '@controleonline/ui-default/src/react/components/files/DefaultFile';
+import {extractFileId} from './fileUpload';
+import {
+  getFileName,
+  getFileExtension,
+  getContextLabel,
+  isPreviewableImage,
+  getGenericFileIcon,
+} from './defaultUploadHelpers';
+import {defaultUploadStyles as styles} from './DefaultUpload.styles';
+
+function FileThumb({file, preferImage = false, company = null}) {
+  const fileId = extractFileId(file);
+  // people_media / image uploads often arrive as {id} without extension metadata
+  if (fileId && (preferImage || isPreviewableImage(file))) {
+    return (
+      <DefaultFile
+        file={file}
+        company={company}
+        resizeMode="cover"
+        style={styles.fileImage}
+      />
+    );
+  }
+  const ext = getFileExtension(file);
+  return (
+    <View style={styles.fileThumbFallback}>
+      <MaterialCommunityIcons name={getGenericFileIcon(file)} size={36} color="#475569" />
+      <Text style={styles.fileExtBadge}>{ext ? ext.toUpperCase() : 'FILE'}</Text>
+    </View>
+  );
+}
+
+export default function DefaultUploadManagerModal(props) {
+  const {
+    visible,
+    onClose,
+    managerTitle,
+    context,
+    buttonPalette,
+    librarySearch,
+    setLibrarySearch,
+    searchPlaceholder,
+    handleUpload,
+    uploading,
+    uploadButtonLabel,
+    libraryLoading,
+    loadLibrary,
+    attachLabel,
+    savingFileId,
+    loadingText,
+    libraryError,
+    filteredLibraryFiles,
+    attachedFileIds,
+    handleAttachExisting,
+    attachmentRows = [],
+    emptyLibraryLabel,
+    emptyAttachmentsLabel,
+    status,
+    error,
+    fileType = 'image',
+    company = null,
+    coverId = null,
+    handleSetCover = null,
+    handleRemove = null,
+  } = props;
+  const preferImage =
+    String(fileType || '').toLowerCase() === 'image' ||
+    String(context || '').toLowerCase() === 'people_media';
+
+  return (
+    <AnimatedModal visible={visible} onRequestClose={onClose}>
+      <View style={styles.modalContainer}>
+        <View style={styles.modalHeader}>
+          <View>
+            <Text style={styles.modalTitle}>{managerTitle}</Text>
+          </View>
+          <TouchableOpacity onPress={onClose} style={styles.iconButton}>
+            <MaterialCommunityIcons name="close" size={22} color={buttonPalette.buttonIconSecondary} />
+          </TouchableOpacity>
+        </View>
+
+        <View style={styles.toolbar}>
+          <View style={styles.searchBox}>
+            <MaterialCommunityIcons name="magnify" size={18} color="#94A3B8" />
+            <TextInput
+              value={librarySearch}
+              onChangeText={setLibrarySearch}
+              placeholder={searchPlaceholder}
+              placeholderTextColor="#94A3B8"
+              style={styles.searchInput}
+            />
+            {!!librarySearch && (
+              <TouchableOpacity onPress={() => setLibrarySearch('')}>
+                <MaterialCommunityIcons name="close-circle" size={18} color="#94A3B8" />
+              </TouchableOpacity>
+            )}
+          </View>
+          <TouchableOpacity
+            onPress={handleUpload}
+            disabled={uploading}
+            style={[
+              styles.uploadButton,
+              {backgroundColor: buttonPalette.buttonBackground, borderColor: buttonPalette.buttonBorder, borderWidth: 1},
+              uploading && styles.disabledButton,
+            ]}>
+            {uploading ? (
+              <ActivityIndicator size="small" color={buttonPalette.buttonIcon} />
+            ) : (
+              <MaterialCommunityIcons name="cloud-upload-outline" size={18} color={buttonPalette.buttonIcon} />
+            )}
+            <Text style={[styles.uploadButtonText, {color: buttonPalette.buttonText}]}>
+              {uploading ? 'Enviando' : uploadButtonLabel}
+            </Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            onPress={loadLibrary}
+            disabled={libraryLoading}
+            style={[
+              styles.refreshButton,
+              {backgroundColor: buttonPalette.buttonBackgroundSecondary, borderColor: buttonPalette.buttonBorderSecondary},
+            ]}>
+            <MaterialCommunityIcons name="refresh" size={19} color={buttonPalette.buttonIconSecondary} />
+          </TouchableOpacity>
+        </View>
+
+        {!!libraryError && <Text style={styles.modalError}>{libraryError}</Text>}
+
+        {libraryLoading ? (
+          <View style={styles.loadingState}>
+            <ActivityIndicator size="small" color="#0F172A" />
+            <Text style={styles.loadingText}>{loadingText}</Text>
+          </View>
+        ) : filteredLibraryFiles.length === 0 ? (
+          <View style={styles.emptyState}>
+            <MaterialCommunityIcons name="file-search-outline" size={34} color="#CBD5E1" />
+            <Text style={styles.emptyText}>{emptyLibraryLabel}</Text>
+          </View>
+        ) : (
+          <ScrollView style={styles.modalList} showsVerticalScrollIndicator={false}>
+            <View style={styles.libraryGrid}>
+              {filteredLibraryFiles.map(file => {
+                const fileId = extractFileId(file);
+                const isAttached = fileId && attachedFileIds.has(String(fileId));
+                const isSaving = String(savingFileId || '') === String(fileId || getFileName(file));
+                return (
+                  <View key={fileId || getFileName(file)} style={[styles.fileCard, isAttached && styles.fileCardAttached]}>
+                    <View style={styles.fileThumb}>
+                      <FileThumb file={file} preferImage={preferImage} company={company} />
+                    </View>
+                    <View style={{flexDirection: 'row', gap: 6, position: 'absolute', top: 8, right: 8, zIndex: 2}}>
+                      {isAttached ? (
+                        <>
+                          <TouchableOpacity
+                            onPress={() => {
+                              const row = (attachmentRows || []).find(
+                                item => String(extractFileId(item?.file)) === String(fileId),
+                              );
+                              if (row) handleSetCover?.(row);
+                            }}
+                            style={styles.fileAction}
+                            accessibilityLabel="Definir como principal">
+                            <MaterialCommunityIcons
+                              name={
+                                (attachmentRows || []).some(
+                                  item =>
+                                    String(item?.id) === String(coverId) &&
+                                    String(extractFileId(item?.file)) === String(fileId),
+                                )
+                                  ? 'star'
+                                  : 'star-outline'
+                              }
+                              size={18}
+                              color="#0F172A"
+                            />
+                          </TouchableOpacity>
+                          <TouchableOpacity
+                            onPress={() => {
+                              const row = (attachmentRows || []).find(
+                                item => String(extractFileId(item?.file)) === String(fileId),
+                              );
+                              if (row) handleRemove?.(row);
+                            }}
+                            style={styles.fileAction}
+                            accessibilityLabel="Remover">
+                            <MaterialCommunityIcons name="trash-can-outline" size={18} color="#B91C1C" />
+                          </TouchableOpacity>
+                        </>
+                      ) : (
+                        <TouchableOpacity
+                          onPress={() => handleAttachExisting(file)}
+                          disabled={isSaving}
+                          style={styles.fileAction}>
+                          {isSaving ? (
+                            <ActivityIndicator size="small" color="#0F172A" />
+                          ) : (
+                            <MaterialCommunityIcons name="plus" size={18} color="#0F172A" />
+                          )}
+                        </TouchableOpacity>
+                      )}
+                    </View>
+                    <View style={styles.fileInfo}>
+                      <Text numberOfLines={2} style={styles.fileName}>{getFileName(file)}</Text>
+                      {Array.isArray(file?.mediaTypesUsed) && file.mediaTypesUsed.length > 0 ? (
+                        <Text numberOfLines={2} style={styles.mediaTypesLine}>
+                          {file.mediaTypesUsed.join(', ')}
+                        </Text>
+                      ) : null}
+                      <View style={styles.fileMetaRow}>
+                        {(() => {
+                          const label = getContextLabel(file?.context ?? file);
+                          // Hide internal store contexts from end users
+                          if (!label || label === 'sem contexto' || /^[a-z0-9]+(?:_[a-z0-9]+)+$/.test(label)) {
+                            return null;
+                          }
+                          return <Text style={styles.contextBadge}>{label}</Text>;
+                        })()}
+                        {isAttached && <Text style={styles.attachedBadge}>{attachLabel}</Text>}
+                      </View>
+                    </View>
+                  </View>
+                );
+              })}
+            </View>
+          </ScrollView>
+        )}
+
+        {attachmentRows.length === 0 && (
+          <Text style={styles.emptyText}>{emptyAttachmentsLabel}</Text>
+        )}
+        {!!status && <Text style={styles.attachmentsStatus}>{status}</Text>}
+        {!!error && <Text style={styles.attachmentsError}>{error}</Text>}
+      </View>
+    </AnimatedModal>
+  );
+}

package/src/react/components/upload/defaultUploadHelpers.js

@@ -0,0 +1,108 @@
+/**
+ * Pure helpers for DefaultUpload (app-community#296 modularization).
+ * task-432: getContextLabel accepts file object or context string.
+ */
+const {extractFileId} = require('./fileUpload');
+
+const DEFAULT_LIBRARY_CONTEXTS = ['products', 'products-category'];
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp|svg)$/i;
+
+const normalizeCollection = response => {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.member)) return response.member;
+  if (Array.isArray(response?.['hydra:member'])) return response['hydra:member'];
+  return [];
+};
+
+const getEntityId = relation => {
+  const value =
+    relation?.id ||
+    relation?.['@id'] ||
+    relation?.mediaId ||
+    relation?.media?.id ||
+    relation?.media?.['@id'] ||
+    relation?.peopleMedia?.id ||
+    relation?.peopleMedia?.['@id'] ||
+    relation;
+  const match = String(value || '').match(/(\d+)$/);
+  return match ? match[1] : null;
+};
+
+const normalizeAttachmentRelation = relation => {
+  const relationId = getEntityId(relation);
+  if (!relation || typeof relation !== 'object' || relation?.id || !relationId) {
+    return relation;
+  }
+  return {...relation, id: relationId};
+};
+
+const getRelationFileId = relation => extractFileId(relation?.file);
+
+const getFileName = file => {
+  const id = extractFileId(file);
+  return file?.fileName || file?.name || file?.originalName || (id ? `Arquivo ${id}` : 'Arquivo');
+};
+
+const getFileExtension = file => {
+  const fromField = String(file?.extension || '').replace(/^\./, '').trim().toLowerCase();
+  if (fromField) return fromField;
+  const name = getFileName(file);
+  const match = String(name).match(/\.([a-z0-9]+)$/i);
+  return match ? match[1].toLowerCase() : '';
+};
+
+const isPreviewableImage = file => {
+  const type = String(file?.fileType || file?.mimeType || file?.type || '').toLowerCase();
+  if (type.startsWith('image/')) return true;
+  if (type === 'image') return true;
+  const ext = getFileExtension(file);
+  return IMAGE_EXT.test(`.${ext}`) || IMAGE_EXT.test(getFileName(file));
+};
+
+const getGenericFileIcon = file => {
+  const ext = getFileExtension(file);
+  if (['pfx', 'p12', 'cer', 'crt'].includes(ext)) return 'file-certificate-outline';
+  if (['pdf'].includes(ext)) return 'file-pdf-box';
+  if (['xml', 'zip'].includes(ext)) return 'folder-zip-outline';
+  return 'file-outline';
+};
+
+const getContextLabel = contextOrFile => {
+  if (contextOrFile == null || contextOrFile === '') return 'sem contexto';
+  if (typeof contextOrFile === 'object' && !Array.isArray(contextOrFile)) {
+    const fromFile =
+      contextOrFile.context ??
+      contextOrFile.fileContext ??
+      contextOrFile.file_context ??
+      '';
+    if (fromFile != null && fromFile !== '' && typeof fromFile !== 'object') {
+      return String(fromFile).trim() || 'sem contexto';
+    }
+    return 'sem contexto';
+  }
+  return String(contextOrFile).trim() || 'sem contexto';
+};
+
+const dedupeFiles = files => {
+  const seen = new Set();
+  return files.filter(file => {
+    const id = extractFileId(file);
+    if (!id || seen.has(String(id))) return false;
+    seen.add(String(id));
+    return true;
+  });
+};
+
+module.exports = {
+  DEFAULT_LIBRARY_CONTEXTS,
+  normalizeCollection,
+  getEntityId,
+  normalizeAttachmentRelation,
+  getRelationFileId,
+  getFileName,
+  getFileExtension,
+  isPreviewableImage,
+  getGenericFileIcon,
+  getContextLabel,
+  dedupeFiles,
+};

package/src/react/components/upload/defaultUploadLibrary.js

@@ -0,0 +1,248 @@
+/**
+ * Library fetch helpers for DefaultUpload (app-community#296 / #433 / #670).
+ *
+ * Always send itemsPerPage so the API does not default to a tiny page size.
+ * Also hydrate known file ids (certificates are public=false and may not
+ * appear in the collection filter).
+ */
+const DEFAULT_LIBRARY_CONTEXTS = ['products', 'products-category'];
+
+const normalizeCollection = response => {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.member)) return response.member;
+  if (Array.isArray(response?.['hydra:member'])) return response['hydra:member'];
+  return [];
+};
+
+const getEntityId = relation => {
+  const value = relation?.id || relation?.['@id'] || relation;
+  const match = String(value || '').match(/(\d+)$/);
+  return match ? match[1] : null;
+};
+
+const extractFileIdLocal = value => {
+  if (!value && value !== 0) return null;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'object') {
+    return extractFileIdLocal(value.id || value['@id'] || value.fileId);
+  }
+  const match = String(value).match(/(\d+)$/);
+  return match ? parseInt(match[1], 10) : null;
+};
+
+const dedupeFiles = files => {
+  const seen = new Set();
+  return files.filter(file => {
+    const id = extractFileIdLocal(file);
+    if (!id || seen.has(String(id))) return false;
+    seen.add(String(id));
+    return true;
+  });
+};
+
+function resolvePeopleMediaTypeLabel(relation) {
+  const mediaType = relation?.mediaType;
+  if (!mediaType) return '';
+  if (typeof mediaType === 'string') {
+    // Prefer last path segment only when it looks like a label, not a numeric id
+    const segment = String(mediaType).split('/').filter(Boolean).pop() || '';
+    if (segment && !/^\d+$/.test(segment)) return segment.trim();
+    return '';
+  }
+  return String(
+    mediaType.type || mediaType.name || mediaType.label || mediaType.code || '',
+  ).trim();
+}
+
+function filesFromPeopleMediaRelations(relations) {
+  if (!Array.isArray(relations)) return [];
+  // Group by file id and collect media_types where the image is used (#814)
+  const byFileId = new Map();
+  for (const relation of relations) {
+    const file = relation?.file;
+    if (!file) continue;
+    const id = extractFileIdLocal(file);
+    if (!id) continue;
+    const typeLabel = resolvePeopleMediaTypeLabel(relation);
+    const key = String(id);
+    const existing = byFileId.get(key);
+    if (existing) {
+      if (typeLabel && !existing.mediaTypesUsed.includes(typeLabel)) {
+        existing.mediaTypesUsed.push(typeLabel);
+      }
+      continue;
+    }
+    // Always tag people_media library entries so the manager can preview as image
+    // even when API returns a bare IRI / minimal File payload.
+    const base =
+      typeof file === 'object'
+        ? {
+            ...file,
+            id: file.id || id,
+            '@id': file['@id'] || `/files/${id}`,
+            context: file.context || 'people_media',
+            fileType: file.fileType || file.mimeType || 'image',
+            fileName: file.fileName || file.name || file.originalName || `Arquivo ${id}`,
+          }
+        : {
+            id,
+            '@id': `/files/${id}`,
+            context: 'people_media',
+            fileType: 'image',
+            fileName: `Arquivo ${id}`,
+          };
+    byFileId.set(key, {
+      ...base,
+      mediaTypesUsed: typeLabel ? [typeLabel] : [],
+    });
+  }
+  return Array.from(byFileId.values()).map(file => ({
+    ...file,
+    mediaTypesUsed: Array.isArray(file.mediaTypesUsed)
+      ? [...file.mediaTypesUsed].sort((a, b) =>
+          String(a).localeCompare(String(b), 'pt-BR', {sensitivity: 'base'}),
+        )
+      : [],
+  }));
+}
+
+async function fetchPeopleMediaFiles({peopleActions, peopleIri}) {
+  if (!peopleIri || typeof peopleActions?.getPeopleMedia !== 'function') {
+    return [];
+  }
+  const pageSize = 100;
+  const maxPages = 10;
+  const collected = [];
+  for (let page = 1; page <= maxPages; page += 1) {
+    const response = await peopleActions.getPeopleMedia({
+      people: peopleIri,
+      page,
+      itemsPerPage: pageSize,
+      'order[id]': 'DESC',
+    });
+    const pageItems = normalizeCollection(response);
+    collected.push(...pageItems);
+    if (pageItems.length < pageSize) break;
+  }
+  return filesFromPeopleMediaRelations(collected);
+}
+
+async function fetchKnownFiles({fileActions, knownFileIds = []}) {
+  if (typeof fileActions?.get !== 'function') return [];
+  const ids = [...new Set(knownFileIds.map(extractFileIdLocal).filter(Boolean))];
+  const files = [];
+  for (const id of ids) {
+    try {
+      const item = await fileActions.get(id);
+      if (item && typeof item === 'object') files.push(item);
+    } catch (_) {
+      // item GET is best-effort so a missing id does not empty the library
+    }
+  }
+  return files;
+}
+
+function synthesizeKnownImageFiles(knownFileIds = [], fileType = 'image', context = 'people_media') {
+  const preferImage = String(fileType || '').toLowerCase() === 'image';
+  return knownFileIds
+    .map(extractFileIdLocal)
+    .filter(Boolean)
+    .map(id => ({
+      id,
+      '@id': `/files/${id}`,
+      context,
+      fileType: preferImage ? 'image' : fileType || undefined,
+      fileName: `Arquivo ${id}`,
+    }));
+}
+
+async function fetchLibraryFiles({
+  fileActions,
+  companyId,
+  fileType,
+  libraryContexts,
+  peopleActions = null,
+  knownFileIds = [],
+}) {
+  const peopleIri = getEntityId(companyId) ? `/people/${getEntityId(companyId)}` : null;
+  const contexts = Array.isArray(libraryContexts) && libraryContexts.length
+    ? libraryContexts
+    : DEFAULT_LIBRARY_CONTEXTS;
+  const includesPeopleMedia = contexts.some(
+    c => String(c || '').trim().toLowerCase() === 'people_media',
+  );
+
+  // people_media is company-scoped via /people_media — never GET /files collection/item
+  // (those endpoints 404 for private company media while /download still works).
+  if (includesPeopleMedia) {
+    let files = [];
+    if (peopleIri) {
+      try {
+        files = await fetchPeopleMediaFiles({peopleActions, peopleIri});
+      } catch (_) {
+        files = [];
+      }
+    }
+    const existing = new Set(
+      files.map(file => String(extractFileIdLocal(file) || '')).filter(Boolean),
+    );
+    const stubs = synthesizeKnownImageFiles(knownFileIds, fileType, 'people_media').filter(
+      file => !existing.has(String(file.id)),
+    );
+    return dedupeFiles(files.concat(stubs));
+  }
+
+  if (typeof fileActions?.getItems !== 'function') {
+    return fetchKnownFiles({fileActions, knownFileIds});
+  }
+
+  const pageSize = 500;
+  const maxPages = 10;
+
+  const fetchContextFiles = async fileContext => {
+    const contextFiles = [];
+    for (let page = 1; page <= maxPages; page += 1) {
+      const params = {
+        context: fileContext,
+        page,
+        itemsPerPage: pageSize,
+      };
+      if (fileType) params.fileType = fileType;
+      if (peopleIri) params.people = peopleIri;
+      try {
+        const response = await fileActions.getItems(params);
+        const pageItems = normalizeCollection(response);
+        contextFiles.push(...pageItems);
+        if (pageItems.length < pageSize) break;
+      } catch (_) {
+        // Collection filter may 404 for some contexts — skip page
+        break;
+      }
+    }
+    return contextFiles;
+  };
+
+  const batches = await Promise.all(contexts.map(fetchContextFiles));
+  let files = batches.flat();
+
+  if (knownFileIds.length) {
+    // Prefer stubs over GET /files/{id} when item endpoint 404s for private files
+    const knownFiles = await fetchKnownFiles({fileActions, knownFileIds});
+    if (knownFiles.length) {
+      files = knownFiles.concat(files);
+    } else {
+      files = synthesizeKnownImageFiles(knownFileIds, fileType, contexts[0]).concat(files);
+    }
+  }
+
+  return dedupeFiles(files);
+}
+
+module.exports = {
+  fetchLibraryFiles,
+  filesFromPeopleMediaRelations,
+  resolvePeopleMediaTypeLabel,
+  fetchPeopleMediaFiles,
+  fetchKnownFiles,
+  synthesizeKnownImageFiles,
+};

package/src/react/components/upload/fileUpload.js

@@ -0,0 +1,93 @@
+import {Platform} from 'react-native';
+import * as DocumentPicker from 'expo-document-picker';
+import {env as APP_ENV} from '@env';
+
+const extractId = value => {
+  if (!value && value !== 0) return null;
+  if (typeof value === 'number') return value;
+
+  const raw = typeof value === 'string' ? value : value?.id || value?.['@id'];
+  if (!raw) return null;
+
+  const match = String(raw).match(/(\d+)$/);
+  return match ? parseInt(match[1], 10) : null;
+};
+
+export const uploadFileToApi = async ({file, context = 'products', peopleId, entityId}) => {
+  const session = JSON.parse(localStorage.getItem('session') || '{}');
+  const token = session?.api_key || session?.token;
+  if (!token) throw new Error('Sessao invalida para upload.');
+
+  const apiEntryPoint = String(APP_ENV?.API_ENTRYPOINT || '').replace(/\/$/, '');
+  const host = APP_ENV?.DOMAIN || (typeof location !== 'undefined' ? location.host : '');
+  if (!apiEntryPoint) throw new Error('API_ENTRYPOINT nao configurado.');
+
+  const formData = new FormData();
+
+  if (Platform.OS === 'web') {
+    formData.append('file', file);
+  } else {
+    formData.append('file', {
+      uri: file.uri,
+      name: file.name || 'imagem.jpg',
+      type: file.mimeType || file.type || 'image/jpeg',
+    });
+  }
+
+  formData.append('context', context);
+  if (peopleId) formData.append('people', String(extractId(peopleId)));
+  if (entityId) formData.append('id', String(extractId(entityId)));
+
+  const response = await fetch(`${apiEntryPoint}/files/upload`, {
+    method: 'POST',
+    headers: {
+      'API-TOKEN': token,
+      'App-Domain': host,
+      Accept: 'application/json',
+    },
+    body: formData,
+  });
+
+  const result = await response.json().catch(() => ({}));
+  if (!response.ok || result?.['@type'] === 'Error') {
+    throw new Error(result?.description || result?.message || 'Falha no upload do arquivo.');
+  }
+
+  return result;
+};
+
+export const selectFile = async (acceptedTypes = '*/*') => {
+  if (Platform.OS === 'web' && typeof document !== 'undefined') {
+    return new Promise(resolve => {
+      const input = document.createElement('input');
+      input.type = 'file';
+      if (acceptedTypes) {
+        input.accept = acceptedTypes;
+      }
+      input.onchange = event => resolve(event?.target?.files?.[0] || null);
+      input.click();
+    });
+  }
+
+  const result = await DocumentPicker.getDocumentAsync({
+    type: acceptedTypes || '*/*',
+    copyToCacheDirectory: true,
+    multiple: false,
+  });
+
+  if (result?.canceled) {
+    return null;
+  }
+
+  return result?.assets?.[0] || null;
+};
+
+export const toFileIri = fileObj => {
+  const iri = fileObj?.['@id'];
+  if (iri) return iri;
+
+  const id = extractId(fileObj?.id || fileObj);
+  return id ? `/files/${id}` : null;
+};
+
+export const extractFileId = extractId;