Page MenuHomePhabricator
Differential D11116

[scripts] Remove flow annotation
ClosedPublic
Actions

Authored by inka on Feb 20 2024, 3:13 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 17, 7:04 AM
Unknown Object (File)
Thu, Apr 17, 3:53 AM
Unknown Object (File)
Thu, Apr 17, 12:29 AM
Unknown Object (File)
Wed, Apr 16, 1:26 AM
Unknown Object (File)
Mon, Apr 14, 11:55 AM
Unknown Object (File)
Sun, Apr 6, 9:08 AM
Unknown Object (File)
Mar 20 2025, 4:42 AM
Unknown Object (File)
Mar 9 2025, 1:46 AM
View All 72 Files
Subscribers
None

Details

Reviewers
ashoat
tomek
michal
Commits
rCOMM467af97c2dd5: [scripts] Remove flow annotation
Summary

Removing flow annotations, since the files aren't relly flow files

Test Plan

flow

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 37510

View Options

scripts/generate-phab-tag-removal-script.js

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass InputStateContainer extends React.PureComponent<Props, State> {
} }
static completedMessageIDs(state: State): Set<string> { static completedMessageIDs(state: State): Set<string> {
const completed = new Map<string, boolean>(); const completed = new Map<string, boolean>();
for (const threadID in state.pendingUploads) { for (const threadID in state.pendingUploads) {
const pendingUploads = state.pendingUploads[threadID]; const pendingUploads = state.pendingUploads[threadID];
for (const localUploadID in pendingUploads) { for (const localUploadID in pendingUploads) {
const upload = pendingUploads[localUploadID]; const upload = pendingUploads[localUploadID];
const { messageID, serverID, failed } = upload; const { messageID, canBeSent, failed } = upload;
if (!messageID || !messageID.startsWith(localIDPrefix)) { if (!messageID || !messageID.startsWith(localIDPrefix)) {
continue; continue;
} }
if (!serverID || failed) { if (!canBeSent || failed) {
completed.set(messageID, false); completed.set(messageID, false);
continue; continue;
} }
if (completed.get(messageID) === undefined) { if (completed.get(messageID) === undefined) {
completed.set(messageID, true); completed.set(messageID, true);
} }
} }
} }
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines return {
messageID: null, messageID: null,
failed: false, failed: false,
file: encryptionResult?.file ?? fixedFile, file: encryptionResult?.file ?? fixedFile,
mediaType: encryptionResult ? 'encrypted_photo' : mediaType, mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
dimensions, dimensions,
uri: encryptionResult?.uri ?? uri, uri: encryptionResult?.uri ?? uri,
loop: false, loop: false,
uriIsReal: false, uriIsReal: false,
canBeSent: false,
blobHolder: null, blobHolder: null,
blobHash: encryptionResult?.sha256Hash, blobHash: encryptionResult?.sha256Hash,
encryptionKey: encryptionResult?.encryptionKey, encryptionKey: encryptionResult?.encryptionKey,
thumbHash, thumbHash,
progressPercent: 0, progressPercent: 0,
abort: null, abort: null,
steps, steps,
selectTime, selectTime,
Show All 10 Lines ): Promise<mixed> {
return Promise.all( return Promise.all(
uploads.map(upload => this.uploadFile(threadInfo, upload)), uploads.map(upload => this.uploadFile(threadInfo, upload)),
); );
} }
async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) { async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const { selectTime, localID, encryptionKey } = upload; const { selectTime, localID, encryptionKey } = upload;
const threadID = threadInfo.id; const threadID = threadInfo.id;
const isThickThread = threadTypeIsThick(threadInfo.type);
const isEncrypted = const isEncrypted =
!!encryptionKey && !!encryptionKey &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video'); upload.mediaType === 'encrypted_video');
const steps = [...upload.steps]; const steps = [...upload.steps];
let userTime; let userTime;
Show All 25 Lines async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const uploadStart = Date.now(); const uploadStart = Date.now();
try { try {
const callbacks = { const callbacks = {
onProgress: (percent: number) => onProgress: (percent: number) =>
this.setProgress(threadID, localID, percent), this.setProgress(threadID, localID, percent),
abortHandler: (abort: () => void) => abortHandler: (abort: () => void) =>
this.handleAbortCallback(threadID, localID, abort), this.handleAbortCallback(threadID, localID, abort),
}; };
const isThickThread = threadTypeIsThick(threadInfo.type);
const useBlobService = isThickThread || this.useBlobServiceUploads; const useBlobService = isThickThread || this.useBlobServiceUploads;
if ( if (
useBlobService && useBlobService &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video') upload.mediaType === 'encrypted_video')
) { ) {
const { blobHash, dimensions, thumbHash } = upload; const { blobHash, dimensions, thumbHash } = upload;
invariant( invariant(
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
serverID: result.id, serverID: result.id,
blobHolder: result.blobHolder, blobHolder: result.blobHolder,
abort: null, abort: null,
// For thin threads we can send message right after serverID
// is present, but for thick threads we need to wait until
// a "real" Blob URI is assigned to the message.
canBeSent: !isThickThread,
}, },
}, },
}, },
}; };
}); });
if (encryptionKey) { if (encryptionKey) {
const authMetadata = await identityContext.getAuthMetadata(); const authMetadata = await identityContext.getAuthMetadata();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
uri: result.uri, uri: result.uri,
mediaType: outputMediaType, mediaType: outputMediaType,
dimensions: result.dimensions, dimensions: result.dimensions,
uriIsReal: true,
loop: result.loop, loop: result.loop,
uriIsReal: true,
canBeSent: true,
}, },
}, },
}, },
}; };
}); });
} }
handleAbortCallback( handleAbortCallback(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines
View Options

scripts/get-cargo-path.js

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass InputStateContainer extends React.PureComponent<Props, State> {
} }
static completedMessageIDs(state: State): Set<string> { static completedMessageIDs(state: State): Set<string> {
const completed = new Map<string, boolean>(); const completed = new Map<string, boolean>();
for (const threadID in state.pendingUploads) { for (const threadID in state.pendingUploads) {
const pendingUploads = state.pendingUploads[threadID]; const pendingUploads = state.pendingUploads[threadID];
for (const localUploadID in pendingUploads) { for (const localUploadID in pendingUploads) {
const upload = pendingUploads[localUploadID]; const upload = pendingUploads[localUploadID];
const { messageID, serverID, failed } = upload; const { messageID, canBeSent, failed } = upload;
if (!messageID || !messageID.startsWith(localIDPrefix)) { if (!messageID || !messageID.startsWith(localIDPrefix)) {
continue; continue;
} }
if (!serverID || failed) { if (!canBeSent || failed) {
completed.set(messageID, false); completed.set(messageID, false);
continue; continue;
} }
if (completed.get(messageID) === undefined) { if (completed.get(messageID) === undefined) {
completed.set(messageID, true); completed.set(messageID, true);
} }
} }
} }
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines return {
messageID: null, messageID: null,
failed: false, failed: false,
file: encryptionResult?.file ?? fixedFile, file: encryptionResult?.file ?? fixedFile,
mediaType: encryptionResult ? 'encrypted_photo' : mediaType, mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
dimensions, dimensions,
uri: encryptionResult?.uri ?? uri, uri: encryptionResult?.uri ?? uri,
loop: false, loop: false,
uriIsReal: false, uriIsReal: false,
canBeSent: false,
blobHolder: null, blobHolder: null,
blobHash: encryptionResult?.sha256Hash, blobHash: encryptionResult?.sha256Hash,
encryptionKey: encryptionResult?.encryptionKey, encryptionKey: encryptionResult?.encryptionKey,
thumbHash, thumbHash,
progressPercent: 0, progressPercent: 0,
abort: null, abort: null,
steps, steps,
selectTime, selectTime,
Show All 10 Lines ): Promise<mixed> {
return Promise.all( return Promise.all(
uploads.map(upload => this.uploadFile(threadInfo, upload)), uploads.map(upload => this.uploadFile(threadInfo, upload)),
); );
} }
async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) { async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const { selectTime, localID, encryptionKey } = upload; const { selectTime, localID, encryptionKey } = upload;
const threadID = threadInfo.id; const threadID = threadInfo.id;
const isThickThread = threadTypeIsThick(threadInfo.type);
const isEncrypted = const isEncrypted =
!!encryptionKey && !!encryptionKey &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video'); upload.mediaType === 'encrypted_video');
const steps = [...upload.steps]; const steps = [...upload.steps];
let userTime; let userTime;
Show All 25 Lines async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const uploadStart = Date.now(); const uploadStart = Date.now();
try { try {
const callbacks = { const callbacks = {
onProgress: (percent: number) => onProgress: (percent: number) =>
this.setProgress(threadID, localID, percent), this.setProgress(threadID, localID, percent),
abortHandler: (abort: () => void) => abortHandler: (abort: () => void) =>
this.handleAbortCallback(threadID, localID, abort), this.handleAbortCallback(threadID, localID, abort),
}; };
const isThickThread = threadTypeIsThick(threadInfo.type);
const useBlobService = isThickThread || this.useBlobServiceUploads; const useBlobService = isThickThread || this.useBlobServiceUploads;
if ( if (
useBlobService && useBlobService &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video') upload.mediaType === 'encrypted_video')
) { ) {
const { blobHash, dimensions, thumbHash } = upload; const { blobHash, dimensions, thumbHash } = upload;
invariant( invariant(
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
serverID: result.id, serverID: result.id,
blobHolder: result.blobHolder, blobHolder: result.blobHolder,
abort: null, abort: null,
// For thin threads we can send message right after serverID
// is present, but for thick threads we need to wait until
// a "real" Blob URI is assigned to the message.
canBeSent: !isThickThread,
}, },
}, },
}, },
}; };
}); });
if (encryptionKey) { if (encryptionKey) {
const authMetadata = await identityContext.getAuthMetadata(); const authMetadata = await identityContext.getAuthMetadata();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
uri: result.uri, uri: result.uri,
mediaType: outputMediaType, mediaType: outputMediaType,
dimensions: result.dimensions, dimensions: result.dimensions,
uriIsReal: true,
loop: result.loop, loop: result.loop,
uriIsReal: true,
canBeSent: true,
}, },
}, },
}, },
}; };
}); });
} }
handleAbortCallback( handleAbortCallback(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines
View Options

scripts/get-clang-paths-cli.js

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass InputStateContainer extends React.PureComponent<Props, State> {
} }
static completedMessageIDs(state: State): Set<string> { static completedMessageIDs(state: State): Set<string> {
const completed = new Map<string, boolean>(); const completed = new Map<string, boolean>();
for (const threadID in state.pendingUploads) { for (const threadID in state.pendingUploads) {
const pendingUploads = state.pendingUploads[threadID]; const pendingUploads = state.pendingUploads[threadID];
for (const localUploadID in pendingUploads) { for (const localUploadID in pendingUploads) {
const upload = pendingUploads[localUploadID]; const upload = pendingUploads[localUploadID];
const { messageID, serverID, failed } = upload; const { messageID, canBeSent, failed } = upload;
if (!messageID || !messageID.startsWith(localIDPrefix)) { if (!messageID || !messageID.startsWith(localIDPrefix)) {
continue; continue;
} }
if (!serverID || failed) { if (!canBeSent || failed) {
completed.set(messageID, false); completed.set(messageID, false);
continue; continue;
} }
if (completed.get(messageID) === undefined) { if (completed.get(messageID) === undefined) {
completed.set(messageID, true); completed.set(messageID, true);
} }
} }
} }
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines return {
messageID: null, messageID: null,
failed: false, failed: false,
file: encryptionResult?.file ?? fixedFile, file: encryptionResult?.file ?? fixedFile,
mediaType: encryptionResult ? 'encrypted_photo' : mediaType, mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
dimensions, dimensions,
uri: encryptionResult?.uri ?? uri, uri: encryptionResult?.uri ?? uri,
loop: false, loop: false,
uriIsReal: false, uriIsReal: false,
canBeSent: false,
blobHolder: null, blobHolder: null,
blobHash: encryptionResult?.sha256Hash, blobHash: encryptionResult?.sha256Hash,
encryptionKey: encryptionResult?.encryptionKey, encryptionKey: encryptionResult?.encryptionKey,
thumbHash, thumbHash,
progressPercent: 0, progressPercent: 0,
abort: null, abort: null,
steps, steps,
selectTime, selectTime,
Show All 10 Lines ): Promise<mixed> {
return Promise.all( return Promise.all(
uploads.map(upload => this.uploadFile(threadInfo, upload)), uploads.map(upload => this.uploadFile(threadInfo, upload)),
); );
} }
async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) { async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const { selectTime, localID, encryptionKey } = upload; const { selectTime, localID, encryptionKey } = upload;
const threadID = threadInfo.id; const threadID = threadInfo.id;
const isThickThread = threadTypeIsThick(threadInfo.type);
const isEncrypted = const isEncrypted =
!!encryptionKey && !!encryptionKey &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video'); upload.mediaType === 'encrypted_video');
const steps = [...upload.steps]; const steps = [...upload.steps];
let userTime; let userTime;
Show All 25 Lines async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const uploadStart = Date.now(); const uploadStart = Date.now();
try { try {
const callbacks = { const callbacks = {
onProgress: (percent: number) => onProgress: (percent: number) =>
this.setProgress(threadID, localID, percent), this.setProgress(threadID, localID, percent),
abortHandler: (abort: () => void) => abortHandler: (abort: () => void) =>
this.handleAbortCallback(threadID, localID, abort), this.handleAbortCallback(threadID, localID, abort),
}; };
const isThickThread = threadTypeIsThick(threadInfo.type);
const useBlobService = isThickThread || this.useBlobServiceUploads; const useBlobService = isThickThread || this.useBlobServiceUploads;
if ( if (
useBlobService && useBlobService &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video') upload.mediaType === 'encrypted_video')
) { ) {
const { blobHash, dimensions, thumbHash } = upload; const { blobHash, dimensions, thumbHash } = upload;
invariant( invariant(
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
serverID: result.id, serverID: result.id,
blobHolder: result.blobHolder, blobHolder: result.blobHolder,
abort: null, abort: null,
// For thin threads we can send message right after serverID
// is present, but for thick threads we need to wait until
// a "real" Blob URI is assigned to the message.
canBeSent: !isThickThread,
}, },
}, },
}, },
}; };
}); });
if (encryptionKey) { if (encryptionKey) {
const authMetadata = await identityContext.getAuthMetadata(); const authMetadata = await identityContext.getAuthMetadata();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
uri: result.uri, uri: result.uri,
mediaType: outputMediaType, mediaType: outputMediaType,
dimensions: result.dimensions, dimensions: result.dimensions,
uriIsReal: true,
loop: result.loop, loop: result.loop,
uriIsReal: true,
canBeSent: true,
}, },
}, },
}, },
}; };
}); });
} }
handleAbortCallback( handleAbortCallback(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines
View Options

scripts/get-clang-paths.js

Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Linesclass InputStateContainer extends React.PureComponent<Props, State> {
} }
static completedMessageIDs(state: State): Set<string> { static completedMessageIDs(state: State): Set<string> {
const completed = new Map<string, boolean>(); const completed = new Map<string, boolean>();
for (const threadID in state.pendingUploads) { for (const threadID in state.pendingUploads) {
const pendingUploads = state.pendingUploads[threadID]; const pendingUploads = state.pendingUploads[threadID];
for (const localUploadID in pendingUploads) { for (const localUploadID in pendingUploads) {
const upload = pendingUploads[localUploadID]; const upload = pendingUploads[localUploadID];
const { messageID, serverID, failed } = upload; const { messageID, canBeSent, failed } = upload;
if (!messageID || !messageID.startsWith(localIDPrefix)) { if (!messageID || !messageID.startsWith(localIDPrefix)) {
continue; continue;
} }
if (!serverID || failed) { if (!canBeSent || failed) {
completed.set(messageID, false); completed.set(messageID, false);
continue; continue;
} }
if (completed.get(messageID) === undefined) { if (completed.get(messageID) === undefined) {
completed.set(messageID, true); completed.set(messageID, true);
} }
} }
} }
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines return {
messageID: null, messageID: null,
failed: false, failed: false,
file: encryptionResult?.file ?? fixedFile, file: encryptionResult?.file ?? fixedFile,
mediaType: encryptionResult ? 'encrypted_photo' : mediaType, mediaType: encryptionResult ? 'encrypted_photo' : mediaType,
dimensions, dimensions,
uri: encryptionResult?.uri ?? uri, uri: encryptionResult?.uri ?? uri,
loop: false, loop: false,
uriIsReal: false, uriIsReal: false,
canBeSent: false,
blobHolder: null, blobHolder: null,
blobHash: encryptionResult?.sha256Hash, blobHash: encryptionResult?.sha256Hash,
encryptionKey: encryptionResult?.encryptionKey, encryptionKey: encryptionResult?.encryptionKey,
thumbHash, thumbHash,
progressPercent: 0, progressPercent: 0,
abort: null, abort: null,
steps, steps,
selectTime, selectTime,
Show All 10 Lines ): Promise<mixed> {
return Promise.all( return Promise.all(
uploads.map(upload => this.uploadFile(threadInfo, upload)), uploads.map(upload => this.uploadFile(threadInfo, upload)),
); );
} }
async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) { async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const { selectTime, localID, encryptionKey } = upload; const { selectTime, localID, encryptionKey } = upload;
const threadID = threadInfo.id; const threadID = threadInfo.id;
const isThickThread = threadTypeIsThick(threadInfo.type);
const isEncrypted = const isEncrypted =
!!encryptionKey && !!encryptionKey &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video'); upload.mediaType === 'encrypted_video');
const steps = [...upload.steps]; const steps = [...upload.steps];
let userTime; let userTime;
Show All 25 Lines async uploadFile(threadInfo: ThreadInfo, upload: PendingMultimediaUpload) {
const uploadStart = Date.now(); const uploadStart = Date.now();
try { try {
const callbacks = { const callbacks = {
onProgress: (percent: number) => onProgress: (percent: number) =>
this.setProgress(threadID, localID, percent), this.setProgress(threadID, localID, percent),
abortHandler: (abort: () => void) => abortHandler: (abort: () => void) =>
this.handleAbortCallback(threadID, localID, abort), this.handleAbortCallback(threadID, localID, abort),
}; };
const isThickThread = threadTypeIsThick(threadInfo.type);
const useBlobService = isThickThread || this.useBlobServiceUploads; const useBlobService = isThickThread || this.useBlobServiceUploads;
if ( if (
useBlobService && useBlobService &&
(upload.mediaType === 'encrypted_photo' || (upload.mediaType === 'encrypted_photo' ||
upload.mediaType === 'encrypted_video') upload.mediaType === 'encrypted_video')
) { ) {
const { blobHash, dimensions, thumbHash } = upload; const { blobHash, dimensions, thumbHash } = upload;
invariant( invariant(
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
serverID: result.id, serverID: result.id,
blobHolder: result.blobHolder, blobHolder: result.blobHolder,
abort: null, abort: null,
// For thin threads we can send message right after serverID
// is present, but for thick threads we need to wait until
// a "real" Blob URI is assigned to the message.
canBeSent: !isThickThread,
}, },
}, },
}, },
}; };
}); });
if (encryptionKey) { if (encryptionKey) {
const authMetadata = await identityContext.getAuthMetadata(); const authMetadata = await identityContext.getAuthMetadata();
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines this.setState(prevState => {
...prevState.pendingUploads, ...prevState.pendingUploads,
[newThreadID]: { [newThreadID]: {
...uploads, ...uploads,
[localID]: { [localID]: {
...currentUpload, ...currentUpload,
uri: result.uri, uri: result.uri,
mediaType: outputMediaType, mediaType: outputMediaType,
dimensions: result.dimensions, dimensions: result.dimensions,
uriIsReal: true,
loop: result.loop, loop: result.loop,
uriIsReal: true,
canBeSent: true,
}, },
}, },
}, },
}; };
}); });
} }
handleAbortCallback( handleAbortCallback(
▲ Show 20 Lines • Show All 624 Lines • Show Last 20 Lines