mirror of
https://github.com/denoland/deno.git
synced 2024-12-25 08:39:09 -05:00
375 lines
7.7 KiB
JavaScript
375 lines
7.7 KiB
JavaScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
|
|
|
((window) => {
|
|
const { sendSync, sendAsync } = window.__bootstrap.dispatchJson;
|
|
const { pathFromURL } = window.__bootstrap.util;
|
|
const build = window.__bootstrap.build.build;
|
|
|
|
function chmodSync(path, mode) {
|
|
sendSync("op_chmod", { path: pathFromURL(path), mode });
|
|
}
|
|
|
|
async function chmod(path, mode) {
|
|
await sendAsync("op_chmod", { path: pathFromURL(path), mode });
|
|
}
|
|
|
|
function chownSync(
|
|
path,
|
|
uid,
|
|
gid,
|
|
) {
|
|
sendSync("op_chown", { path: pathFromURL(path), uid, gid });
|
|
}
|
|
|
|
async function chown(
|
|
path,
|
|
uid,
|
|
gid,
|
|
) {
|
|
await sendAsync("op_chown", { path: pathFromURL(path), uid, gid });
|
|
}
|
|
|
|
function copyFileSync(
|
|
fromPath,
|
|
toPath,
|
|
) {
|
|
sendSync("op_copy_file", {
|
|
from: pathFromURL(fromPath),
|
|
to: pathFromURL(toPath),
|
|
});
|
|
}
|
|
|
|
async function copyFile(
|
|
fromPath,
|
|
toPath,
|
|
) {
|
|
await sendAsync("op_copy_file", {
|
|
from: pathFromURL(fromPath),
|
|
to: pathFromURL(toPath),
|
|
});
|
|
}
|
|
|
|
function cwd() {
|
|
return sendSync("op_cwd");
|
|
}
|
|
|
|
function chdir(directory) {
|
|
sendSync("op_chdir", { directory });
|
|
}
|
|
|
|
function makeTempDirSync(options = {}) {
|
|
return sendSync("op_make_temp_dir", options);
|
|
}
|
|
|
|
function makeTempDir(options = {}) {
|
|
return sendAsync("op_make_temp_dir", options);
|
|
}
|
|
|
|
function makeTempFileSync(options = {}) {
|
|
return sendSync("op_make_temp_file", options);
|
|
}
|
|
|
|
function makeTempFile(options = {}) {
|
|
return sendAsync("op_make_temp_file", options);
|
|
}
|
|
|
|
function mkdirArgs(path, options) {
|
|
const args = { path, recursive: false };
|
|
if (options != null) {
|
|
if (typeof options.recursive == "boolean") {
|
|
args.recursive = options.recursive;
|
|
}
|
|
if (options.mode) {
|
|
args.mode = options.mode;
|
|
}
|
|
}
|
|
return args;
|
|
}
|
|
|
|
function mkdirSync(path, options) {
|
|
sendSync("op_mkdir", mkdirArgs(path, options));
|
|
}
|
|
|
|
async function mkdir(
|
|
path,
|
|
options,
|
|
) {
|
|
await sendAsync("op_mkdir", mkdirArgs(path, options));
|
|
}
|
|
|
|
function res(response) {
|
|
return response.entries;
|
|
}
|
|
|
|
function readDirSync(path) {
|
|
return res(sendSync("op_read_dir", { path: pathFromURL(path) }))[
|
|
Symbol.iterator
|
|
]();
|
|
}
|
|
|
|
function readDir(path) {
|
|
const array = sendAsync("op_read_dir", { path: pathFromURL(path) }).then(
|
|
res,
|
|
);
|
|
return {
|
|
async *[Symbol.asyncIterator]() {
|
|
yield* await array;
|
|
},
|
|
};
|
|
}
|
|
|
|
function readLinkSync(path) {
|
|
return sendSync("op_read_link", { path });
|
|
}
|
|
|
|
function readLink(path) {
|
|
return sendAsync("op_read_link", { path });
|
|
}
|
|
|
|
function realPathSync(path) {
|
|
return sendSync("op_realpath", { path });
|
|
}
|
|
|
|
function realPath(path) {
|
|
return sendAsync("op_realpath", { path });
|
|
}
|
|
|
|
function removeSync(
|
|
path,
|
|
options = {},
|
|
) {
|
|
sendSync("op_remove", {
|
|
path: pathFromURL(path),
|
|
recursive: !!options.recursive,
|
|
});
|
|
}
|
|
|
|
async function remove(
|
|
path,
|
|
options = {},
|
|
) {
|
|
await sendAsync("op_remove", {
|
|
path: pathFromURL(path),
|
|
recursive: !!options.recursive,
|
|
});
|
|
}
|
|
|
|
function renameSync(oldpath, newpath) {
|
|
sendSync("op_rename", { oldpath, newpath });
|
|
}
|
|
|
|
async function rename(oldpath, newpath) {
|
|
await sendAsync("op_rename", { oldpath, newpath });
|
|
}
|
|
|
|
function parseFileInfo(response) {
|
|
const unix = build.os === "darwin" || build.os === "linux";
|
|
return {
|
|
isFile: response.isFile,
|
|
isDirectory: response.isDirectory,
|
|
isSymlink: response.isSymlink,
|
|
size: response.size,
|
|
mtime: response.mtime != null ? new Date(response.mtime) : null,
|
|
atime: response.atime != null ? new Date(response.atime) : null,
|
|
birthtime: response.birthtime != null
|
|
? new Date(response.birthtime)
|
|
: null,
|
|
// Only non-null if on Unix
|
|
dev: unix ? response.dev : null,
|
|
ino: unix ? response.ino : null,
|
|
mode: unix ? response.mode : null,
|
|
nlink: unix ? response.nlink : null,
|
|
uid: unix ? response.uid : null,
|
|
gid: unix ? response.gid : null,
|
|
rdev: unix ? response.rdev : null,
|
|
blksize: unix ? response.blksize : null,
|
|
blocks: unix ? response.blocks : null,
|
|
};
|
|
}
|
|
|
|
function fstatSync(rid) {
|
|
return parseFileInfo(sendSync("op_fstat", { rid }));
|
|
}
|
|
|
|
async function fstat(rid) {
|
|
return parseFileInfo(await sendAsync("op_fstat", { rid }));
|
|
}
|
|
|
|
async function lstat(path) {
|
|
const res = await sendAsync("op_stat", {
|
|
path: pathFromURL(path),
|
|
lstat: true,
|
|
});
|
|
return parseFileInfo(res);
|
|
}
|
|
|
|
function lstatSync(path) {
|
|
const res = sendSync("op_stat", {
|
|
path: pathFromURL(path),
|
|
lstat: true,
|
|
});
|
|
return parseFileInfo(res);
|
|
}
|
|
|
|
async function stat(path) {
|
|
const res = await sendAsync("op_stat", {
|
|
path: pathFromURL(path),
|
|
lstat: false,
|
|
});
|
|
return parseFileInfo(res);
|
|
}
|
|
|
|
function statSync(path) {
|
|
const res = sendSync("op_stat", {
|
|
path: pathFromURL(path),
|
|
lstat: false,
|
|
});
|
|
return parseFileInfo(res);
|
|
}
|
|
|
|
function coerceLen(len) {
|
|
if (len == null || len < 0) {
|
|
return 0;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
function ftruncateSync(rid, len) {
|
|
sendSync("op_ftruncate", { rid, len: coerceLen(len) });
|
|
}
|
|
|
|
async function ftruncate(rid, len) {
|
|
await sendAsync("op_ftruncate", { rid, len: coerceLen(len) });
|
|
}
|
|
|
|
function truncateSync(path, len) {
|
|
sendSync("op_truncate", { path, len: coerceLen(len) });
|
|
}
|
|
|
|
async function truncate(path, len) {
|
|
await sendAsync("op_truncate", { path, len: coerceLen(len) });
|
|
}
|
|
|
|
function umask(mask) {
|
|
return sendSync("op_umask", { mask });
|
|
}
|
|
|
|
function linkSync(oldpath, newpath) {
|
|
sendSync("op_link", { oldpath, newpath });
|
|
}
|
|
|
|
async function link(oldpath, newpath) {
|
|
await sendAsync("op_link", { oldpath, newpath });
|
|
}
|
|
|
|
function toSecondsFromEpoch(v) {
|
|
return v instanceof Date ? Math.trunc(v.valueOf() / 1000) : v;
|
|
}
|
|
|
|
function utimeSync(
|
|
path,
|
|
atime,
|
|
mtime,
|
|
) {
|
|
sendSync("op_utime", {
|
|
path,
|
|
// TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
|
|
atime: toSecondsFromEpoch(atime),
|
|
mtime: toSecondsFromEpoch(mtime),
|
|
});
|
|
}
|
|
|
|
async function utime(
|
|
path,
|
|
atime,
|
|
mtime,
|
|
) {
|
|
await sendAsync("op_utime", {
|
|
path,
|
|
// TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
|
|
atime: toSecondsFromEpoch(atime),
|
|
mtime: toSecondsFromEpoch(mtime),
|
|
});
|
|
}
|
|
|
|
function symlinkSync(
|
|
oldpath,
|
|
newpath,
|
|
options,
|
|
) {
|
|
sendSync("op_symlink", { oldpath, newpath, options });
|
|
}
|
|
|
|
async function symlink(
|
|
oldpath,
|
|
newpath,
|
|
options,
|
|
) {
|
|
await sendAsync("op_symlink", { oldpath, newpath, options });
|
|
}
|
|
|
|
function fdatasyncSync(rid) {
|
|
sendSync("op_fdatasync", { rid });
|
|
}
|
|
|
|
async function fdatasync(rid) {
|
|
await sendAsync("op_fdatasync", { rid });
|
|
}
|
|
|
|
function fsyncSync(rid) {
|
|
sendSync("op_fsync", { rid });
|
|
}
|
|
|
|
async function fsync(rid) {
|
|
await sendAsync("op_fsync", { rid });
|
|
}
|
|
|
|
window.__bootstrap.fs = {
|
|
cwd,
|
|
chdir,
|
|
chmodSync,
|
|
chmod,
|
|
chown,
|
|
chownSync,
|
|
copyFile,
|
|
copyFileSync,
|
|
makeTempFile,
|
|
makeTempDir,
|
|
makeTempFileSync,
|
|
makeTempDirSync,
|
|
mkdir,
|
|
mkdirSync,
|
|
readDir,
|
|
readDirSync,
|
|
readLinkSync,
|
|
readLink,
|
|
realPathSync,
|
|
realPath,
|
|
remove,
|
|
removeSync,
|
|
renameSync,
|
|
rename,
|
|
fstatSync,
|
|
fstat,
|
|
lstat,
|
|
lstatSync,
|
|
stat,
|
|
statSync,
|
|
ftruncate,
|
|
ftruncateSync,
|
|
truncate,
|
|
truncateSync,
|
|
umask,
|
|
link,
|
|
linkSync,
|
|
utime,
|
|
utimeSync,
|
|
symlink,
|
|
symlinkSync,
|
|
fdatasync,
|
|
fdatasyncSync,
|
|
fsync,
|
|
fsyncSync,
|
|
};
|
|
})(this);
|