eeprom/scripts/eepromv1a.js/main.js

213 lines
8.4 KiB
JavaScript

#include bytefmt.js
#include xhr.js
const EEPROM = function(appId, endPoint, auth) {
if(typeof appId !== 'string')
appId = (appId || '').toString();
if(typeof endPoint !== 'string')
throw 'endPoint must be a string';
const applyAuth = options => {
if(typeof auth === 'function')
options.headers.Authorization = auth();
else if(typeof auth === 'string')
options.headers.Authorization = auth;
else
options.authed = true;
};
const createUpload = fileInput => {
if(!(fileInput instanceof File))
throw 'fileInput must be an instance of window.File';
let userAborted = false;
let abortHandler, progressHandler;
const reportProgress = ev => {
if(progressHandler !== undefined)
progressHandler({
loaded: ev.loaded,
total: ev.total,
progress: ev.total <= 0 ? 0 : ev.loaded / ev.total,
});
};
const uploadAbortedError = () => {
return {
error: 'eeprom:aborted_error',
aborted: userAborted,
toString: () => 'File upload was aborted manually.',
};
};
const uploadGenericError = () => {
return {
error: 'eeprom:generic_error',
aborted: userAborted,
toString: () => 'File upload failed for unknown reasons.',
};
};
return {
abort: () => {
userAborted = true;
if(abortHandler !== undefined)
abortHandler();
},
onProgress: handler => {
if(typeof handler !== 'function')
throw 'handler must be a function';
progressHandler = handler;
},
start: async () => {
if(userAborted)
throw uploadAbortedError();
const options = {
type: 'json',
headers: {},
upload: reportProgress,
abort: handler => abortHandler = handler,
};
applyAuth(options);
const formData = new FormData;
formData.append('src', appId);
formData.append('file', fileInput);
try {
const result = await EEPXHR.post(`${endPoint}/uploads`, options, formData);
if(result.status !== 201) {
if(result.status === 400)
throw {
error: 'eeprom:request_error',
aborted: userAborted,
toString: () => 'There was an error with the upload request.',
};
if(result.status === 401)
throw {
error: 'eeprom:auth_error',
aborted: userAborted,
toString: () => 'Could not authenticate upload request. If this persists, try refreshing the page.',
};
if(result.status === 403)
throw {
error: 'eeprom:access_error',
aborted: userAborted,
toString: () => 'You are not allowed to upload files.',
};
if(result.status === 404)
throw {
error: 'eeprom:app_error',
aborted: userAborted,
toString: () => 'EEPROM app is not configured properly.',
};
if(result.status === 413) {
const maxSize = parseInt(result.headers().get('x-eeprom-max-size'));
const maxSizeFormatted = EEPFMT.format(maxSize);
throw {
error: 'eeprom:size_error',
maxSize: maxSize,
maxSizeFormatted: maxSizeFormatted,
aborted: userAborted,
toString: () => maxSize < 1 ? 'Uploaded file was too large.' : `Uploads may not be larger than ${maxSizeFormatted}.`,
};
}
if(result.status === 451)
throw {
error: 'eeprom:dmca_error',
aborted: userAborted,
toString: () => 'This file is blocked from being uploaded, possibly for copyright reasons.',
};
if(result.status === 500)
throw {
error: 'eeprom:server_error',
aborted: userAborted,
toString: () => 'An error occurred within the EEPROM server. If this persists, report it to a developer.',
};
if(result.status === 503)
throw {
error: 'eeprom:maintenance_error',
aborted: userAborted,
toString: () => 'EEPROM server is temporarily unavailable for maintenance.',
};
throw uploadGenericError();
}
const fileInfo = result.body();
if(typeof fileInfo.type === 'string') {
fileInfo.isImage = () => fileInfo.type.indexOf('image/') === 0;
fileInfo.isVideo = () => fileInfo.type.indexOf('video/') === 0;
fileInfo.isAudio = () => fileInfo.type === 'application/x-font-gdos' || fileInfo.type.indexOf('audio/') === 0;
} else
fileInfo.isImage = fileInfo.isVideo = fileInfo.isAudio = () => false;
fileInfo.isMedia = () => fileInfo.isImage() || fileInfo.isAudio() || fileInfo.isVideo();
return Object.freeze(fileInfo);
} catch(ex) {
if(!ex.abort) {
console.error(ex);
throw ex;
}
throw uploadAbortedError();
}
},
};
};
const deleteUpload = async fileInfo => {
if(typeof fileInfo !== 'object')
throw 'fileInfo must be an object';
if(typeof fileInfo.urlf !== 'string')
throw 'fileInfo.urlf must be a string';
const options = { headers: {} };
applyAuth(options);
const result = await EEPXHR.delete(fileInfo.urlf, options);
if(result.status !== 204) {
if(result.status === 401)
throw {
error: 'eeprom:auth_error',
toString: () => 'Could not authenticate delete request. If this persists, try refreshing the page.',
};
if(result.status === 403)
throw {
error: 'eeprom:access_error',
toString: () => 'You are not allowed to delete this file.',
};
if(result.status === 404)
throw {
error: 'eeprom:file_error',
toString: () => 'File not found.',
};
if(result.status === 500)
throw {
error: 'eeprom:server_error',
toString: () => 'An error occurred within the EEPROM server. If this persists, report it to a developer.',
};
if(result.status === 503)
throw {
error: 'eeprom:maintenance_error',
toString: () => 'EEPROM server is temporarily unavailable for maintenance.',
};
throw {
error: 'eeprom:generic_error',
toString: () => 'File delete failed for unknown reasons.',
};
}
};
return {
create: createUpload,
delete: deleteUpload,
};
};