Spaces:
Running
Running
Download node_modules/playwright-core/lib/utils/fileUtils.js from AK51/LunarSpark: direct link, hf CLI and curl.
- Browser
- Download file 6.73 kB
-
https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright-core/lib/utils/fileUtils.js
- Command line
-
hf download hf://spaces/AK51/LunarSpark/node_modules/playwright-core/lib/utils/fileUtils.js
-
curl -L -o fileUtils.js https://huggingface.co/spaces/AK51/LunarSpark/resolve/main/node_modules/playwright-core/lib/utils/fileUtils.js
6.73 kB
| ; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| exports.SerializedFS = void 0; | |
| exports.canAccessFile = canAccessFile; | |
| exports.copyFileAndMakeWritable = copyFileAndMakeWritable; | |
| exports.fileUploadSizeLimit = exports.existsAsync = void 0; | |
| exports.mkdirIfNeeded = mkdirIfNeeded; | |
| exports.removeFolders = removeFolders; | |
| exports.sanitizeForFilePath = sanitizeForFilePath; | |
| exports.toPosixPath = toPosixPath; | |
| var _fs = _interopRequireDefault(require("fs")); | |
| var _path = _interopRequireDefault(require("path")); | |
| var _manualPromise = require("./manualPromise"); | |
| var _zipBundle = require("../zipBundle"); | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| /** | |
| * Copyright (c) Microsoft Corporation. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| const fileUploadSizeLimit = exports.fileUploadSizeLimit = 50 * 1024 * 1024; | |
| const existsAsync = path => new Promise(resolve => _fs.default.stat(path, err => resolve(!err))); | |
| exports.existsAsync = existsAsync; | |
| async function mkdirIfNeeded(filePath) { | |
| // This will harmlessly throw on windows if the dirname is the root directory. | |
| await _fs.default.promises.mkdir(_path.default.dirname(filePath), { | |
| recursive: true | |
| }).catch(() => {}); | |
| } | |
| async function removeFolders(dirs) { | |
| return await Promise.all(dirs.map(dir => _fs.default.promises.rm(dir, { | |
| recursive: true, | |
| force: true, | |
| maxRetries: 10 | |
| }).catch(e => e))); | |
| } | |
| function canAccessFile(file) { | |
| if (!file) return false; | |
| try { | |
| _fs.default.accessSync(file); | |
| return true; | |
| } catch (e) { | |
| return false; | |
| } | |
| } | |
| async function copyFileAndMakeWritable(from, to) { | |
| await _fs.default.promises.copyFile(from, to); | |
| await _fs.default.promises.chmod(to, 0o664); | |
| } | |
| function sanitizeForFilePath(s) { | |
| return s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-'); | |
| } | |
| function toPosixPath(aPath) { | |
| return aPath.split(_path.default.sep).join(_path.default.posix.sep); | |
| } | |
| class SerializedFS { | |
| constructor() { | |
| this._buffers = new Map(); | |
| // Should never be accessed from within appendOperation. | |
| this._error = void 0; | |
| this._operations = []; | |
| this._operationsDone = void 0; | |
| this._operationsDone = new _manualPromise.ManualPromise(); | |
| this._operationsDone.resolve(); // No operations scheduled yet. | |
| } | |
| mkdir(dir) { | |
| this._appendOperation({ | |
| op: 'mkdir', | |
| dir | |
| }); | |
| } | |
| writeFile(file, content, skipIfExists) { | |
| this._buffers.delete(file); // No need to flush the buffer since we'll overwrite anyway. | |
| this._appendOperation({ | |
| op: 'writeFile', | |
| file, | |
| content, | |
| skipIfExists | |
| }); | |
| } | |
| appendFile(file, text, flush) { | |
| if (!this._buffers.has(file)) this._buffers.set(file, []); | |
| this._buffers.get(file).push(text); | |
| if (flush) this._flushFile(file); | |
| } | |
| _flushFile(file) { | |
| const buffer = this._buffers.get(file); | |
| if (buffer === undefined) return; | |
| const content = buffer.join(''); | |
| this._buffers.delete(file); | |
| this._appendOperation({ | |
| op: 'appendFile', | |
| file, | |
| content | |
| }); | |
| } | |
| copyFile(from, to) { | |
| this._flushFile(from); | |
| this._buffers.delete(to); // No need to flush the buffer since we'll overwrite anyway. | |
| this._appendOperation({ | |
| op: 'copyFile', | |
| from, | |
| to | |
| }); | |
| } | |
| async syncAndGetError() { | |
| for (const file of this._buffers.keys()) this._flushFile(file); | |
| await this._operationsDone; | |
| return this._error; | |
| } | |
| zip(entries, zipFileName) { | |
| for (const file of this._buffers.keys()) this._flushFile(file); | |
| // Chain the export operation against write operations, | |
| // so that files do not change during the export. | |
| this._appendOperation({ | |
| op: 'zip', | |
| entries, | |
| zipFileName | |
| }); | |
| } | |
| // This method serializes all writes to the trace. | |
| _appendOperation(op) { | |
| const last = this._operations[this._operations.length - 1]; | |
| if ((last === null || last === void 0 ? void 0 : last.op) === 'appendFile' && op.op === 'appendFile' && last.file === op.file) { | |
| // Merge pending appendFile operations for performance. | |
| last.content += op.content; | |
| return; | |
| } | |
| this._operations.push(op); | |
| if (this._operationsDone.isDone()) this._performOperations(); | |
| } | |
| async _performOperations() { | |
| this._operationsDone = new _manualPromise.ManualPromise(); | |
| while (this._operations.length) { | |
| const op = this._operations.shift(); | |
| // Ignore all operations after the first error. | |
| if (this._error) continue; | |
| try { | |
| await this._performOperation(op); | |
| } catch (e) { | |
| this._error = e; | |
| } | |
| } | |
| this._operationsDone.resolve(); | |
| } | |
| async _performOperation(op) { | |
| switch (op.op) { | |
| case 'mkdir': | |
| { | |
| await _fs.default.promises.mkdir(op.dir, { | |
| recursive: true | |
| }); | |
| return; | |
| } | |
| case 'writeFile': | |
| { | |
| // Note: 'wx' flag only writes when the file does not exist. | |
| // See https://nodejs.org/api/fs.html#file-system-flags. | |
| // This way tracing never have to write the same resource twice. | |
| if (op.skipIfExists) await _fs.default.promises.writeFile(op.file, op.content, { | |
| flag: 'wx' | |
| }).catch(() => {});else await _fs.default.promises.writeFile(op.file, op.content); | |
| return; | |
| } | |
| case 'copyFile': | |
| { | |
| await _fs.default.promises.copyFile(op.from, op.to); | |
| return; | |
| } | |
| case 'appendFile': | |
| { | |
| await _fs.default.promises.appendFile(op.file, op.content); | |
| return; | |
| } | |
| case 'zip': | |
| { | |
| const zipFile = new _zipBundle.yazl.ZipFile(); | |
| const result = new _manualPromise.ManualPromise(); | |
| zipFile.on('error', error => result.reject(error)); | |
| for (const entry of op.entries) zipFile.addFile(entry.value, entry.name); | |
| zipFile.end(); | |
| zipFile.outputStream.pipe(_fs.default.createWriteStream(op.zipFileName)).on('close', () => result.resolve()).on('error', error => result.reject(error)); | |
| await result; | |
| return; | |
| } | |
| } | |
| } | |
| } | |
| exports.SerializedFS = SerializedFS; |