cloudflare-dropbox-cdn

This is an output from ac-bundle-app.
You can use the script as Cloudflare worker to use Dropbox as CDN.

``
appConfig = {
cloudflare: {
account: "",
email: "",
auth: ""
},
dropbox: {
link: "https://content.dropboxapi.com/2/files/download",
prefix: "/publish",
accessToken:
""
}
};
var app = {
start: function () {},
indexDynamic: async function (request) {
var url = new URL(request.url);
if (url.pathname.split("/").pop().trim() === "")
url.pathname += "index.html";
var result = await app.api.dropbox.file(url.pathname);
return app.response(await result.arrayBuffer(), {
status: result.status,
headers: {
"Content-Type": app.utils.mime.get(url.pathname)
}
});
}
};
app.startUps = [];
app.callbacks = { static: [] };
app["api"] = {
dropbox: (function () {
var mod = {
fileCallback: async function (callback, errorCallback, path) {
path = appConfig.dropbox.prefix + path;
var result = await fetch(appConfig.dropbox.link, {
method: "POST",
headers: {
Authorization: "Bearer " + appConfig.dropbox.accessToken,
"Dropbox-API-Arg": JSON.stringify({ path: path })
}
});
await callback(result);
}
};
return mod;
})()
};
app["build"] = {};
app["publish"] = {};
app["utils"] = {
mime: (function () {
var mod = {
list: {
aac: "audio/aac",
abw: "application/x-abiword",
ai: "application/postscript",
arc: "application/octet-stream",
avi: "video/x-msvideo",
azw: "application/vnd.amazon.ebook",
bin: "application/octet-stream",
bz: "application/x-bzip",
bz2: "application/x-bzip2",
csh: "application/x-csh",
css: "text/css",
csv: "text/csv",
doc: "application/msword",
dll: "application/octet-stream",
eot: "application/vnd.ms-fontobject",
epub: "application/epub+zip",
gif: "image/gif",
htm: "text/html",
html: "text/html",
ico: "image/x-icon",
ics: "text/calendar",
jar: "application/java-archive",
jpeg: "image/jpeg",
jpg: "image/jpeg",
js: "application/javascript",
json: "application/json",
mid: "audio/midi",
midi: "audio/midi",
mp2: "audio/mpeg",
mp3: "audio/mpeg",
mp4: "video/mp4",
mpa: "video/mpeg",
mpe: "video/mpeg",
mpeg: "video/mpeg",
mpkg: "application/vnd.apple.installer+xml",
odp: "application/vnd.oasis.opendocument.presentation",
ods: "application/vnd.oasis.opendocument.spreadsheet",
odt: "application/vnd.oasis.opendocument.text",
oga: "audio/ogg",
ogv: "video/ogg",
ogx: "application/ogg",
otf: "font/otf",
png: "image/png",
pdf: "application/pdf",
ppt: "application/vnd.ms-powerpoint",
rar: "application/x-rar-compressed",
rtf: "application/rtf",
sh: "application/x-sh",
svg: "image/svg+xml",
swf: "application/x-shockwave-flash",
tar: "application/x-tar",
tif: "image/tiff",
tiff: "image/tiff",
ts: "application/typescript",
ttf: "font/ttf",
txt: "text/plain",
vsd: "application/vnd.visio",
wav: "audio/x-wav",
weba: "audio/webm",
webm: "video/webm",
webp: "image/webp",
woff: "font/woff",
woff2: "font/woff2",
xhtml: "application/xhtml+xml",
xls: "application/vnd.ms-excel",
xlsx: "application/vnd.ms-excel",
xlsx_OLD:
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
xml: "application/xml",
xul: "application/vnd.mozilla.xul+xml",
zip: "application/zip",
"3gp": "video/3gpp",
"3gp_DOES_NOT_CONTAIN_VIDEO": "audio/3gpp",
"3gp2": "video/3gpp2",
"3gp2_DOES_NOT_CONTAIN_VIDEO": "audio/3gpp2",
"7z": "application/x-7z-compressed"
},
get: function (ext) {
ext = ext.split(".").pop().toLowerCase();
return mod.list[ext];
}
};
return mod;
})()
};
var config = app.config;
var modules = app.modules;
app.has = function (value) {
var found = true;
for (var i = 0; i <= arguments.length - 1; i++) {
var value = arguments[i];
if (!(typeof value !== "undefined" && value !== null && value !== ""))
found = false;
}
return found;
};
app.response = function (data, options) {
if (typeof options === "undefined") options = {};
if (typeof options.headers === "undefined") options.headers = {};
options.headers["Access-Control-Allow-Origin"] = "*";
options.headers["Access-Control-Allow-Headers"] = "content-type";
options.headers["Access-Control-Allow-Methods"] =
"HEAD, GET, PUT, DELETE, POST, OPTIONS";
if (typeof Response !== "undefined") {
return new Response(data, options);
} else {
return { data: data, options: options };
}
};
(app.logAndResponse = function (data, options) {
console.log(data);
return app.response(data, options);
}),
(app.camelCase = function camelize(str, capitalFirst) {
if (!app.has(capitalFirst)) capitalFirst = false;
var result = str
.replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
return index === 0 ? word.toLowerCase() : word.toUpperCase();
})
.replace(/\s+/g, "");
if (capitalFirst)
result = result.substr(0, 1).toUpperCase() + result.substr(1, 999);
return result;
});
app.properCase = function (str) {
return str.replace(/\w\S*/g, function (txt) {
return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
});
};
if (app.has(app.api) === true) {
// callbacks
(function () {
var callbackLevel = function (apiLevel) {
if (app.has(apiLevel) && !app.has(apiLevel.length)) {
for (var moduleName in apiLevel) {
if (app.has(apiLevel[moduleName]) === true) {
callbackLevel(apiLevel[moduleName]);
for (var key in apiLevel[moduleName]) {
(function (moduleName, key) {
var func = apiLevel[moduleName][key];
if (
key.split("Callback").length > 1 &&
typeof func === "function"
) {
apiLevel[moduleName][
key.split("Callback").shift() + "Multi"
] = async function (
count,
name,
callback,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9,
arg10,
arg11,
arg12,
arg13,
arg14,
arg15
) {
return new Promise(function (resolve, reject) {
if (!app.has(count)) count = 1;
var rCount = 0;
var resolveCount;
for (var i = 0; i <= count - 1; i++) {
(async function (index) {
var countResult = await apiLevel[moduleName]
key.split("Callback").shift()
{
if (typeof callback === "function") {
var result = await callback(
arg1,
arg2,
arg3,
arg4,
arg5
);
if (result === true && !app.has(resolveCount)) {
console.log("MULTI INDEX:", index);
resolveCount = index;
}
return result;
}
},
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9,
arg10,
arg11,
arg12,
arg13,
arg14,
arg15
);
rCount += 1;
if (resolveCount === index || rCount >= count)
resolve(countResult);
})(i);
}
});
};
apiLevel[moduleName][
key.split("Callback").shift()
] = async function (
name,
callback,
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9,
arg10,
arg11,
arg12,
arg13,
arg14,
arg15
) {
if (typeof callback !== "function") {
arg15 = arg13;
arg14 = arg12;
arg13 = arg11;
arg12 = arg10;
arg11 = arg9;
arg10 = arg8;
arg9 = arg7;
arg8 = arg6;
arg7 = arg5;
arg6 = arg4;
arg5 = arg3;
arg4 = arg2;
arg3 = arg1;
arg2 = callback;
arg1 = name;
}
var output, error;
await apiLevel[moduleName]key {
var result =
typeof callback === "function"
? await callback(data, page)
: undefined;
if (app.has(result) && app.has(result.length)) {
if (!app.has(output)) output = [];
output = output.concat(result);
} else {
output = data;
}
return result;
},
function (err, errorText) {
error = { error: err, errorText };
},
arg1,
arg2,
arg3,
arg4,
arg5,
arg6,
arg7,
arg8,
arg9,
arg10,
arg11,
arg12,
arg13,
arg14,
arg15
);
var obj = {};
if (typeof callback !== "function") return output;
obj[name] = output;
obj.error = error;
return obj;
};
}
})(moduleName, key);
}
}
}
}
};
callbackLevel(app.api);
})();
}
app.handleRequest = async function (request) {
var url = new URL(request.url);
if (request.method === "OPTIONS") return app.response("Ok", { status: 200 });
if (
app.has(config) &&
app.has(config.api) &&
app.has(config.api.authorization)
) {
var authorization = app.has(request.headers)
? app.has(request.headers.get)
? request.headers.get("authorization")
: request.headers.authorization
: "";
if (!app.has(authorization))
authorization = url.searchParams.get("authorization");
if (typeof config.api.authorization === "string") {
if (authorization !== config.api.authorization)
return app.response("Unauthorized.", { status: 400 });
} else {
if (config.api.authorization.indexOf(authorization) < 0)
return app.response("Unauthorized.", { status: 400 });
}
}
var parts = url.pathname.split("/");
parts.shift();
if (parts.length === 1 && parts[0].trim() === "") parts[0] = "index";
if (app.indexMode === true) parts = ["index"];
if (parts.length > 0 && parts[0].trim() !== "") {
var level = app;
for (var i = 0; i <= parts.length - 1; i++) {
var part = app.camelCase(parts[i].trim().split("-").join(" "));
if (
typeof level[part] !== "undefined" ||
typeof level["indexDynamic"] !== "undefined"
) {
level = !(level === app && typeof level["indexDynamic"] !== "undefined")
? level[part]
: level;
if (i === parts.length - 1) {
if (
typeof level === "object" &&
level !== null &&
typeof level["index"] === "function"
) {
if (!app.has(request.headers.get("start-only"))) {
return await level"index";
} else {
level"index";
return app.response("Started.", { status: 200 });
}
}
if (typeof level === "function") {
if (!app.has(request.headers.get("start-only"))) {
return await level(request);
} else {
level(request);
return app.response("Started.", { status: 200 });
}
}
}
if (
typeof level === "object" &&
level !== null &&
typeof level["indexDynamic"] === "function"
) {
if (!app.has(request.headers.get("start-only"))) {
return await level"indexDynamic";
} else {
level"indexDynamic";
return app.response("Started.", { status: 200 });
}
}
}
}
}
if (typeof localMode === "undefined" || localMode !== true)
return app.response("Unknown request: " + url.pathname, { status: 400 });
};
if (
typeof localMode === "undefined" &&
typeof addEventListener !== "undefined"
) {
addEventListener("fetch", (event) => {
event.respondWith(app.handleRequest(event.request));
});
}

// call in the end
if (typeof app.start === "function") {
app.start();
}

for (var i = 0; i <= app.startUps.length - 1; i++) {
if (typeof app.startUps[i] === "function") {
app.startUps[i]();
}
}
for (var i = 0; i <= app.startUps.length - 1; i++) {
if (!(typeof app.startUps[i] === "function")) {
if (
typeof localMode !== "undefined" ||
(typeof appConfig !== "undefined" &&
app.has(appConfig.frontend) &&
appConfig.frontend)
)
setTimeout(app.startUps[i].callback, app.startUps[i].time);
}
}
``