xref: /third_party/node/lib/fs.js

376  *   } | string} [options]
383 function readFile(path, options, callback) {
384   callback = maybeCallback(callback || options);
385   options = getOptions(options, { flag: 'r' });
387   const context = new ReadFileContext(callback, options.encoding);
390   if (options.signal) {
391     context.signal = options.signal;
400   if (checkAborted(options.signal, callback))
403   const flagsNumber = stringToFlags(options.flag, 'options.flag');
458  *   }} [options]
461 function readFileSync(path, options) {
462   options = getOptions(options, { flag: 'r' });
464   const fd = isUserFd ? path : fs.openSync(path, options.flag, 0o666);
508   if (options.encoding) buffer = buffer.toString(options.encoding);
621       // This is fs.read(fd, buffer, options, callback)
622       validateObject(offsetOrOptions, 'options', { nullable: true });
707     // Assume fs.readSync(fd, buffer, options)
708     const options = offset || kEmptyObject;
714     } = options);
1156  *   }} [options]
1160 function rmdir(path, options, callback) {
1161   if (typeof options === 'function') {
1162     callback = options;
1163     options = undefined;
1169   if (options?.recursive) {
1173       { ...options, force: false },
1175       (err, options) => {
1186         rimraf(path, options, callback);
1189     validateRmdirOptions(options);
1203  *   }} [options]
1206 function rmdirSync(path, options) {
1209   if (options?.recursive) {
1211     options = validateRmOptionsSync(path, { ...options, force: false }, true);
1212     if (options !== false) {
1214       return rimrafSync(pathModule.toNamespacedPath(path), options);
1217     validateRmdirOptions(options);
1234  *   }} [options]
1238 function rm(path, options, callback) {
1239   if (typeof options === 'function') {
1240     callback = options;
1241     options = undefined;
1245   validateRmOptions(path, options, false, (err, options) => {
1250     return rimraf(pathModule.toNamespacedPath(path), options, callback);
1263  *   }} [options]
1266 function rmSync(path, options) {
1268   options = validateRmOptionsSync(path, options, false);
1271   return rimrafSync(pathModule.toNamespacedPath(path), options);
1336  *   } | number} [options]
1340 function mkdir(path, options, callback) {
1343   if (typeof options === 'function') {
1344     callback = options;
1345   } else if (typeof options === 'number' || typeof options === 'string') {
1346     mode = options;
1347   } else if (options) {
1348     if (options.recursive !== undefined)
1349       recursive = options.recursive;
1350     if (options.mode !== undefined)
1351       mode = options.mode;
1356   validateBoolean(recursive, 'options.recursive');
1370  *   } | number} [options]
1373 function mkdirSync(path, options) {
1376   if (typeof options === 'number' || typeof options === 'string') {
1377     mode = options;
1378   } else if (options) {
1379     if (options.recursive !== undefined)
1380       recursive = options.recursive;
1381     if (options.mode !== undefined)
1382       mode = options.mode;
1385   validateBoolean(recursive, 'options.recursive');
1402  * @param {{ encoding: string, withFileTypes: boolean }} options
1405 function readdirSyncRecursive(basePath, options) {
1406   const withFileTypes = Boolean(options.withFileTypes);
1407   const encoding = options.encoding;
1464  *   }} [options]
1471 function readdir(path, options, callback) {
1472   callback = makeCallback(typeof options === 'function' ? options : callback);
1473   options = getOptions(options);
1475   if (options.recursive != null) {
1476     validateBoolean(options.recursive, 'options.recursive');
1479   if (options.recursive) {
1480     callback(null, readdirSyncRecursive(path, options));
1485   if (!options.withFileTypes) {
1496   binding.readdir(pathModule.toNamespacedPath(path), options.encoding,
1497                   !!options.withFileTypes, req);
1507  *   }} [options]
1510 function readdirSync(path, options) {
1511   options = getOptions(options);
1513   if (options.recursive != null) {
1514     validateBoolean(options.recursive, 'options.recursive');
1517   if (options.recursive) {
1518     return readdirSyncRecursive(path, options);
1523                                  options.encoding, !!options.withFileTypes,
1526   return options.withFileTypes ? getDirents(path, result) : result;
1533  * @param {{ bigint?: boolean; }} [options]
1540 function fstat(fd, options = { bigint: false }, callback) {
1541   if (typeof options === 'function') {
1542     callback = options;
1543     options = kEmptyObject;
1548   const req = new FSReqCallback(options.bigint);
1550   binding.fstat(fd, options.bigint, req);
1557  * @param {{ bigint?: boolean; }} [options]
1564 function lstat(path, options = { bigint: false }, callback) {
1565   if (typeof options === 'function') {
1566     callback = options;
1567     options = kEmptyObject;
1572   const req = new FSReqCallback(options.bigint);
1574   binding.lstat(pathModule.toNamespacedPath(path), options.bigint, req);
1580  * @param {{ bigint?: boolean; }} [options]
1587 function stat(path, options = { bigint: false }, callback) {
1588   if (typeof options === 'function') {
1589     callback = options;
1590     options = kEmptyObject;
1595   const req = new FSReqCallback(options.bigint);
1597   binding.stat(pathModule.toNamespacedPath(path), options.bigint, req);
1600 function statfs(path, options = { bigint: false }, callback) {
1601   if (typeof options === 'function') {
1602     callback = options;
1603     options = kEmptyObject;
1607   const req = new FSReqCallback(options.bigint);
1615   binding.statfs(pathModule.toNamespacedPath(path), options.bigint, req);
1637  *   }} [options]
1640 function fstatSync(fd, options = { bigint: false }) {
1643   const stats = binding.fstat(fd, options.bigint, undefined, ctx);
1655  *   }} [options]
1658 function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
1662                               options.bigint, undefined, ctx);
1663   if (options.throwIfNoEntry === false && hasNoEntryError(ctx)) {
1677  *   }} [options]
1680 function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
1684                              options.bigint, undefined, ctx);
1685   if (options.throwIfNoEntry === false && hasNoEntryError(ctx)) {
1692 function statfsSync(path, options = { bigint: false }) {
1696                                options.bigint, undefined, ctx);
1705  * @param {{ encoding?: string; } | string} [options]
1712 function readlink(path, options, callback) {
1713   callback = makeCallback(typeof options === 'function' ? options : callback);
1714   options = getOptions(options);
1718   binding.readlink(pathModule.toNamespacedPath(path), options.encoding, req);
1725  * @param {{ encoding?: string; } | string} [options]
1728 function readlinkSync(path, options) {
1729   options = getOptions(options);
1733                                   options.encoding, undefined, ctx);
2259  *   } | string} [options]
2263 function writeFile(path, data, options, callback) {
2264   callback = maybeCallback(callback || options);
2265   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
2266   const flag = options.flag || 'w';
2273     data = Buffer.from(String(data), options.encoding || 'utf8');
2278     const signal = options.signal;
2283   if (checkAborted(options.signal, callback))
2286   fs.open(path, flag, options.mode, (openErr, fd) => {
2291       const signal = options.signal;
2305  *   } | string} [options]
2308 function writeFileSync(path, data, options) {
2309   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'w' });
2316     data = Buffer.from(String(data), options.encoding || 'utf8');
2319   const flag = options.flag || 'w';
2322   const fd = isUserFd ? path : fs.openSync(path, flag, options.mode);
2345  *   } | string} [options]
2349 function appendFile(path, data, options, callback) {
2350   callback = maybeCallback(callback || options);
2351   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'a' });
2353   // Don't make changes directly on options object
2354   options = copyObject(options);
2357   if (!options.flag || isFd(path))
2358     options.flag = 'a';
2360   fs.writeFile(path, data, options, callback);
2371  *   } | string} [options]
2374 function appendFileSync(path, data, options) {
2375   options = getOptions(options, { encoding: 'utf8', mode: 0o666, flag: 'a' });
2377   // Don't make changes directly on options object
2378   options = copyObject(options);
2381   if (!options.flag || isFd(path))
2382     options.flag = 'a';
2384   fs.writeFileSync(path, data, options);
2395  *   }} [options]
2402 function watch(filename, options, listener) {
2403   if (typeof options === 'function') {
2404     listener = options;
2406   options = getOptions(options);
2408   // Don't make changes directly on options object
2409   options = copyObject(options);
2411   if (options.persistent === undefined) options.persistent = true;
2412   if (options.recursive === undefined) options.recursive = false;
2413   if (options.recursive && !(isOSX || isWindows))
2419                                   options.persistent,
2420                                   options.recursive,
2421                                   options.encoding);
2425   if (options.signal) {
2426     if (options.signal.aborted) {
2431       options.signal.addEventListener('abort', listener, { __proto__: null, [kResistStopPropagation]: true });
2433         options.signal.removeEventListener('abort', listener);
2451  *   }} [options]
2458 function watchFile(filename, options, listener) {
2463   if (options === null || typeof options !== 'object') {
2464     listener = options;
2465     options = null;
2468   options = {
2474     ...options,
2482     stat = new watchers.StatWatcher(options.bigint);
2484                                        options.persistent, options.interval);
2542 function encodeRealpathResult(result, options) {
2543   if (!options || !options.encoding || options.encoding === 'utf8')
2546   if (options.encoding === 'buffer') {
2549   return asBuffer.toString(options.encoding);
2574  * @param {string | { encoding?: string | null; }} [options]
2577 function realpathSync(p, options) {
2578   options = getOptions(options);
2586   const cache = options[realpathCacheKey];
2705   return encodeRealpathResult(p, options);
2711  * @param {string | { encoding?: string; }} [options]
2714 realpathSync.native = (path, options) => {
2715   options = getOptions(options);
2718   const result = binding.realpath(pathModule.toNamespacedPath(path), options.encoding, undefined, ctx);
2727  * @param {string | { encoding?: string; }} [options]
2734 function realpath(p, options, callback) {
2735   callback = typeof options === 'function' ? options : maybeCallback(callback);
2736   options = getOptions(options);
2776       return callback(null, encodeRealpathResult(p, options));
2797         return callback(null, encodeRealpathResult(p, options));
2865  * @param {string | { encoding?: string; }} [options]
2872 realpath.native = (path, options, callback) => {
2873   callback = makeCallback(callback || options);
2874   options = getOptions(options);
2878   return binding.realpath(pathModule.toNamespacedPath(path), options.encoding, req);
2884  * @param {string | { encoding?: string; }} [options]
2891 function mkdtemp(prefix, options, callback) {
2892   callback = makeCallback(typeof options === 'function' ? options : callback);
2893   options = getOptions(options);
2907   binding.mkdtemp(path, options.encoding, req);
2913  * @param {string | { encoding?: string; }} [options]
2916 function mkdtempSync(prefix, options) {
2917   options = getOptions(options);
2930   const result = binding.mkdtemp(path, options.encoding,
2990  * @param {object} [options]
2994 function cp(src, dest, options, callback) {
2995   if (typeof options === 'function') {
2996     callback = options;
2997     options = undefined;
3000   options = validateCpOptions(options);
3004   cpFn(src, dest, options, callback);
3012  * @param {object} [options]
3015 function cpSync(src, dest, options) {
3016   options = validateCpOptions(options);
3020   cpSyncFn(src, dest, options);
3046  *   }} [options]
3049 function createReadStream(path, options) {
3051   return new ReadStream(path, options);
3066  *   }} [options]
3069 function createWriteStream(path, options) {
3071   return new WriteStream(path, options);

Indexes created Thu Nov 07 10:32:03 CST 2024