deno.land / x / deno@v1.28.2 / runtime / js / 30_fs.js
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license."use strict";
((window) => { const core = window.Deno.core; const ops = core.ops; const { Date, DatePrototype, MathTrunc, ObjectPrototypeIsPrototypeOf, SymbolAsyncIterator, SymbolIterator, Function, ObjectEntries, Uint32Array, } = window.__bootstrap.primordials; const { pathFromURL } = window.__bootstrap.util; const build = window.__bootstrap.build.build;
function chmodSync(path, mode) { ops.op_chmod_sync(pathFromURL(path), mode); }
async function chmod(path, mode) { await core.opAsync("op_chmod_async", pathFromURL(path), mode); }
function chownSync( path, uid, gid, ) { ops.op_chown_sync(pathFromURL(path), uid, gid); }
async function chown( path, uid, gid, ) { await core.opAsync( "op_chown_async", pathFromURL(path), uid, gid, ); }
function copyFileSync( fromPath, toPath, ) { ops.op_copy_file_sync( pathFromURL(fromPath), pathFromURL(toPath), ); }
async function copyFile( fromPath, toPath, ) { await core.opAsync( "op_copy_file_async", pathFromURL(fromPath), pathFromURL(toPath), ); }
function cwd() { return ops.op_cwd(); }
function chdir(directory) { ops.op_chdir(pathFromURL(directory)); }
function makeTempDirSync(options = {}) { return ops.op_make_temp_dir_sync(options); }
function makeTempDir(options = {}) { return core.opAsync("op_make_temp_dir_async", options); }
function makeTempFileSync(options = {}) { return ops.op_make_temp_file_sync(options); }
function makeTempFile(options = {}) { return core.opAsync("op_make_temp_file_async", options); }
function mkdirArgs(path, options) { const args = { path: pathFromURL(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) { ops.op_mkdir_sync(mkdirArgs(path, options)); }
async function mkdir( path, options, ) { await core.opAsync("op_mkdir_async", mkdirArgs(path, options)); }
function readDirSync(path) { return ops.op_read_dir_sync(pathFromURL(path))[ SymbolIterator ](); }
function readDir(path) { const array = core.opAsync( "op_read_dir_async", pathFromURL(path), ); return { async *[SymbolAsyncIterator]() { yield* await array; }, }; }
function readLinkSync(path) { return ops.op_read_link_sync(pathFromURL(path)); }
function readLink(path) { return core.opAsync("op_read_link_async", pathFromURL(path)); }
function realPathSync(path) { return ops.op_realpath_sync(pathFromURL(path)); }
function realPath(path) { return core.opAsync("op_realpath_async", pathFromURL(path)); }
function removeSync( path, options = {}, ) { ops.op_remove_sync( pathFromURL(path), !!options.recursive, ); }
async function remove( path, options = {}, ) { await core.opAsync( "op_remove_async", pathFromURL(path), !!options.recursive, ); }
function renameSync(oldpath, newpath) { ops.op_rename_sync( pathFromURL(oldpath), pathFromURL(newpath), ); }
async function rename(oldpath, newpath) { await core.opAsync( "op_rename_async", pathFromURL(oldpath), pathFromURL(newpath), ); }
// Extract the FsStat object from the encoded buffer. // See `runtime/ops/fs.rs` for the encoder. // // This is not a general purpose decoder. There are 4 types: // // 1. date // offset += 4 // 1/0 | extra padding | high u32 | low u32 // if date[0] == 1, new Date(u64) else null // // 2. bool // offset += 2 // 1/0 | extra padding // // 3. u64 // offset += 2 // high u32 | low u32 // // 4. ?u64 converts a zero u64 value to JS null on Windows. function createByteStruct(types) { // types can be "date", "bool" or "u64". // `?` prefix means optional on windows. let offset = 0; let str = 'const unix = Deno.build.os === "darwin" || Deno.build.os === "linux"; return {'; for (let [name, type] of ObjectEntries(types)) { const optional = type.startsWith("?"); if (optional) type = type.slice(1);
if (type == "u64") { if (!optional) { str += `${name}: view[${offset}] + view[${offset + 1}] * 2**32,`; } else { str += `${name}: (unix ? (view[${offset}] + view[${ offset + 1 }] * 2**32) : (view[${offset}] + view[${ offset + 1 }] * 2**32) || null),`; } } else if (type == "date") { str += `${name}: view[${offset}] === 0 ? null : new Date(view[${ offset + 2 }] + view[${offset + 3}] * 2**32),`; offset += 2; } else { str += `${name}: !!(view[${offset}] + view[${offset + 1}] * 2**32),`; } offset += 2; } str += "};"; // ...so you don't like eval huh? don't worry, it only executes during snapshot :) return [new Function("view", str), new Uint32Array(offset)]; }
const [statStruct, statBuf] = createByteStruct({ isFile: "bool", isDirectory: "bool", isSymlink: "bool", size: "u64", mtime: "date", atime: "date", birthtime: "date", dev: "?u64", ino: "?u64", mode: "?u64", nlink: "?u64", uid: "?u64", gid: "?u64", rdev: "?u64", blksize: "?u64", blocks: "?u64", });
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.mtimeSet !== null ? new Date(response.mtime) : null, atime: response.atimeSet !== null ? new Date(response.atime) : null, birthtime: response.birthtimeSet !== 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) { ops.op_fstat_sync(rid, statBuf); return statStruct(statBuf); }
async function fstat(rid) { return parseFileInfo(await core.opAsync("op_fstat_async", rid)); }
async function lstat(path) { const res = await core.opAsync("op_stat_async", { path: pathFromURL(path), lstat: true, }); return parseFileInfo(res); }
function lstatSync(path) { ops.op_stat_sync( pathFromURL(path), true, statBuf, ); return statStruct(statBuf); }
async function stat(path) { const res = await core.opAsync("op_stat_async", { path: pathFromURL(path), lstat: false, }); return parseFileInfo(res); }
function statSync(path) { ops.op_stat_sync( pathFromURL(path), false, statBuf, ); return statStruct(statBuf); }
function coerceLen(len) { if (len == null || len < 0) { return 0; }
return len; }
function ftruncateSync(rid, len) { ops.op_ftruncate_sync(rid, coerceLen(len)); }
async function ftruncate(rid, len) { await core.opAsync("op_ftruncate_async", rid, coerceLen(len)); }
function truncateSync(path, len) { ops.op_truncate_sync(path, coerceLen(len)); }
async function truncate(path, len) { await core.opAsync("op_truncate_async", path, coerceLen(len)); }
function umask(mask) { return ops.op_umask(mask); }
function linkSync(oldpath, newpath) { ops.op_link_sync(oldpath, newpath); }
async function link(oldpath, newpath) { await core.opAsync("op_link_async", oldpath, newpath); }
function toUnixTimeFromEpoch(value) { if (ObjectPrototypeIsPrototypeOf(DatePrototype, value)) { const time = value.valueOf(); const seconds = MathTrunc(time / 1e3); const nanoseconds = MathTrunc(time - (seconds * 1e3)) * 1e6;
return [ seconds, nanoseconds, ]; }
const seconds = value; const nanoseconds = 0;
return [ seconds, nanoseconds, ]; }
function futimeSync( rid, atime, mtime, ) { const [atimeSec, atimeNsec] = toUnixTimeFromEpoch(atime); const [mtimeSec, mtimeNsec] = toUnixTimeFromEpoch(mtime); ops.op_futime_sync(rid, atimeSec, atimeNsec, mtimeSec, mtimeNsec); }
async function futime( rid, atime, mtime, ) { const [atimeSec, atimeNsec] = toUnixTimeFromEpoch(atime); const [mtimeSec, mtimeNsec] = toUnixTimeFromEpoch(mtime); await core.opAsync( "op_futime_async", rid, atimeSec, atimeNsec, mtimeSec, mtimeNsec, ); }
function utimeSync( path, atime, mtime, ) { const [atimeSec, atimeNsec] = toUnixTimeFromEpoch(atime); const [mtimeSec, mtimeNsec] = toUnixTimeFromEpoch(mtime); ops.op_utime_sync( pathFromURL(path), atimeSec, atimeNsec, mtimeSec, mtimeNsec, ); }
async function utime( path, atime, mtime, ) { const [atimeSec, atimeNsec] = toUnixTimeFromEpoch(atime); const [mtimeSec, mtimeNsec] = toUnixTimeFromEpoch(mtime); await core.opAsync( "op_utime_async", pathFromURL(path), atimeSec, atimeNsec, mtimeSec, mtimeNsec, ); }
function symlinkSync( oldpath, newpath, options, ) { ops.op_symlink_sync( pathFromURL(oldpath), pathFromURL(newpath), options?.type, ); }
async function symlink( oldpath, newpath, options, ) { await core.opAsync( "op_symlink_async", pathFromURL(oldpath), pathFromURL(newpath), options?.type, ); }
function fdatasyncSync(rid) { ops.op_fdatasync_sync(rid); }
async function fdatasync(rid) { await core.opAsync("op_fdatasync_async", rid); }
function fsyncSync(rid) { ops.op_fsync_sync(rid); }
async function fsync(rid) { await core.opAsync("op_fsync_async", rid); }
function flockSync(rid, exclusive) { ops.op_flock_sync(rid, exclusive === true); }
async function flock(rid, exclusive) { await core.opAsync("op_flock_async", rid, exclusive === true); }
function funlockSync(rid) { ops.op_funlock_sync(rid); }
async function funlock(rid) { await core.opAsync("op_funlock_async", 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, lstat, lstatSync, stat, statSync, ftruncate, ftruncateSync, truncate, truncateSync, umask, link, linkSync, fstatSync, fstat, futime, futimeSync, utime, utimeSync, symlink, symlinkSync, fdatasync, fdatasyncSync, fsync, fsyncSync, flock, flockSync, funlock, funlockSync, };})(this);
deno
Version Info
a year ago
