armory3d.armortools/base/Sources/file.ts

///if krom_windows
let file_cmd_mkdir: string = "mkdir";
let file_cmd_copy: string = "copy";
///else
let file_cmd_mkdir: string = "mkdir -p";
let file_cmd_copy: string = "cp";
///end

let file_cloud: map_t<string, string[]> = null;
let file_cloud_sizes: map_t<string, i32> = null;

// ///if krom_android
// let let file_internal: map_t<string, string[]> = null; // .apk contents
// ///end

function file_read_directory(path: string, folders_only: bool = false): string[] {
	if (starts_with(path, "cloud")) {
		let files: string[] = file_cloud != null ? map_get(file_cloud, string_replace_all(path, "\\", "/")) : null;
		return files != null ? files : [];
	}
	// ///if krom_android
	// path = string_replace_all(path, "//", "/");
	// if (file_internal == null) {
	// 	file_internal = [];
	// 	map_set(file_internal, "/data/plugins", BuildMacros.readDirectory("krom/data/plugins"));
	// 	map_set(file_internal, "/data/export_presets", BuildMacros.readDirectory("krom/data/export_presets"));
	// 	map_set(file_internal, "/data/keymap_presets", BuildMacros.readDirectory("krom/data/keymap_presets"));
	// 	map_set(file_internal, "/data/locale", BuildMacros.readDirectory("krom/data/locale"));
	// 	map_set(file_internal, "/data/meshes", BuildMacros.readDirectory("krom/data/meshes"));
	// 	map_set(file_internal, "/data/themes", BuildMacros.readDirectory("krom/data/themes"));
	// }
	// if (file_internal.exists(path)) return map_get(file_internal, path);
	// ///end
	return string_split(krom_read_directory(path, folders_only), "\n");
}

function file_create_directory(path: string) {
	krom_sys_command(file_cmd_mkdir + " \"" + path + "\"");
}

function file_copy(srcPath: string, dst_path: string) {
	krom_sys_command(file_cmd_copy + " \"" + srcPath + "\" \"" + dst_path + "\"");
}

function file_start(path: string) {
	///if krom_windows
	krom_sys_command("start \"\" \"" + path + "\"");
	///elseif krom_linux
	krom_sys_command("xdg-open \"" + path + "\"");
	///else
	krom_sys_command("open \"" + path + "\"");
	///end
}

function file_load_url(url: string) {
	krom_load_url(url);
}

function file_delete(path: string) {
	krom_delete_file(path);
}

function file_exists(path: string): bool {
	return krom_file_exists(path);
}

type file_download_data_t = {
	dst_path: string;
	done: (url: string)=>void;
};

let _file_download_map: map_t<string, file_download_data_t> = map_create();

function file_download(url: string, dst_path: string, done: (url: string)=>void, size: i32 = 0) {
	///if (krom_windows || krom_darwin || krom_ios || krom_android)
	let fdd: file_download_data_t = { dst_path: dst_path, done: done };
	map_set(_file_download_map, url, fdd);
	krom_http_request(url, size, function (url: string, ab: buffer_t) {
		let fdd: file_download_data_t = map_get(_file_download_map, url);
		if (ab != null) {
			krom_file_save_bytes(fdd.dst_path, ab);
		}
		fdd.done(url);
	});
	///elseif krom_linux
	krom_sys_command("wget -O \"" + dst_path + "\" \"" + url + "\"");
	done(url);
	///else
	krom_sys_command("curl -L " + url + " -o \"" + dst_path + "\"");
	done(url);
	///end
}

type file_download_bytes_data_t = {
	url: string;
	save: string;
	done: (url: string, ab: buffer_t)=>void;
};

let _file_download_bytes_map: map_t<string, file_download_bytes_data_t> = map_create();

function file_download_bytes(url: string, done: (url: string, ab: buffer_t)=>void) {
	let save: string = (path_is_protected() ? krom_save_path() : path_data() + path_sep) + "download.bin";
	let fdbd: file_download_bytes_data_t = { url: url, save: save, done: done };
	map_set(_file_download_bytes_map, url, fdbd);
	file_download(url, save, function (url: string) {
		let fdbd: file_download_bytes_data_t = map_get(_file_download_bytes_map, url);
		let buffer: buffer_t = krom_load_blob(fdbd.save);
		fdbd.done(fdbd.url, buffer);
	});
}

type file_cache_cloud_data_t = {
	dest: string;
	path: string;
	done: (dest: string)=>void;
};

let _file_cache_cloud_map: map_t<string, file_cache_cloud_data_t> = map_create();

function file_cache_cloud(path: string, done: (s: string)=>void) {
	///if krom_ios
	let path2: string = string_replace_all(path, "/", "_"); // Cache everything into root folder
	///else
	let path2: string = path;
	///end
	let dest: string = (path_is_protected() ? krom_save_path() : krom_get_files_location() + path_sep) + path2;
	if (file_exists(dest)) {
		///if (krom_darwin || krom_ios)
		done(dest);
		///else
		done((path_is_protected() ? krom_save_path() : path_working_dir() + path_sep) + path);
		///end
		return;
	}

	let file_dir: string = substring(dest, 0, string_last_index_of(dest, path_sep));
	if (file_read_directory(file_dir)[0] == "") {
		file_create_directory(file_dir);
	}
	///if krom_windows
	path = string_replace_all(path, "\\", "/");
	///end
	let url: string = config_raw.server + "/" + path;

	let fccd: file_cache_cloud_data_t = { dest: dest, path: path, done: done };
	map_set(_file_cache_cloud_map, url, fccd);

	file_download(url, dest, function (url: string) {
		let fccd: file_cache_cloud_data_t = map_get(_file_cache_cloud_map, url);
		if (!file_exists(dest)) {
			console_error(strings_error5());
			fccd.done(null);
			return;
		}
		///if (krom_darwin || krom_ios)
		fccd.done(fccd.dest);
		///else
		fccd.done((path_is_protected() ? krom_save_path() : path_working_dir() + path_sep) + fccd.path);
		///end
	}, map_get(file_cloud_sizes, path));
}

let _file_init_cloud_bytes_done: ()=>void;

function file_init_cloud_bytes(done: ()=>void, append: string = "") {
	_file_init_cloud_bytes_done = done;
	file_download_bytes(config_raw.server + "/?list-type=2" + append, function (url: string, buffer: buffer_t) {
		if (buffer == null) {
			map_set(file_cloud, "cloud", []);
			console_error(strings_error5());
			return;
		}
		let files: string[] = [];
		let sizes: i32[] = [];

		let str: string = sys_buffer_to_string(buffer);
		let pos_start: i32 = 0;
		let pos_end: i32 = 0;

		while (true) {
			pos_start = string_index_of_pos(str, "<Key>", pos_start);
			if (pos_start == -1) {
				break;
			}
			pos_start += 5; // <Key>
			pos_end = string_index_of_pos(str, "</Key>", pos_start);

			array_push(files, substring(str, pos_start, pos_end));

			pos_start = string_index_of_pos(str, "<Size>", pos_end);
			pos_start += 6; //<Size>
			pos_end = string_index_of_pos(str, "</Size>", pos_start);

			array_push(sizes, Number(substring(str, pos_start, pos_end)));
		}

		for (let i: i32 = 0; i < files.length; ++i) {
			let file: string = files[i];
			if (path_is_folder(file)) {
				map_set(file_cloud, substring(file, 0, file.length - 1), []);
			}
		}
		for (let i: i32 = 0; i < files.length; ++i) {
			let file: string = files[i];
			let nested: bool = string_index_of(file, "/") != string_last_index_of(file, "/");
			if (nested) {
				let delim: i32 = path_is_folder(file) ? string_last_index_of(substring(file, 0, file.length - 1), "/") : string_last_index_of(file, "/");
				let parent: string = substring(file, 0, delim);
				let child: string = path_is_folder(file) ? substring(file, delim + 1, file.length - 1) : substring(file, delim + 1, file.length);
				array_push(map_get(file_cloud, parent), child);
				if (!path_is_folder(file)) {
					map_set(file_cloud_sizes, file, sizes[i]);
				}
			}
		}

		let is_truncated: bool = string_index_of(str, "<IsTruncated>true") > -1;
		if (is_truncated) {
			let pos_start: i32 = string_index_of(str, "<NextContinuationToken>");
			pos_start += 23;
			let pos_end: i32 = string_index_of_pos(str, "</NextContinuationToken>", pos_start);
			file_init_cloud_bytes(_file_init_cloud_bytes_done, "&start-after=" + substring(str, pos_start, pos_end));
		}
		else {
			_file_init_cloud_bytes_done();
		}
	});
}

function file_init_cloud(done: ()=>void) {
	file_cloud = map_create();
	file_cloud_sizes = map_create();
	file_init_cloud_bytes(done);
}