"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SerializedFS = void 0;
exports.canAccessFile = canAccessFile;
exports.copyFileAndMakeWritable = copyFileAndMakeWritable;
exports.existsAsync = void 0;
exports.mkdirIfNeeded = mkdirIfNeeded;
exports.removeFolders = removeFolders;
exports.sanitizeForFilePath = sanitizeForFilePath;
exports.toPosixPath = toPosixPath;
var fs = _interopRequireWildcard(require("fs"));
var path = _interopRequireWildcard(require("path"));
var _manualPromise = require("../../utils/isomorphic/manualPromise");
var _zipBundle = require("../../zipBundle");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/**
 * 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 existsAsync = path => new Promise(resolve => fs.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.promises.mkdir(path.dirname(filePath), {
    recursive: true
  }).catch(() => {});
}
async function removeFolders(dirs) {
  return await Promise.all(dirs.map(dir => fs.promises.rm(dir, {
    recursive: true,
    force: true,
    maxRetries: 10
  }).catch(e => e)));
}
function canAccessFile(file) {
  if (!file) return false;
  try {
    fs.accessSync(file);
    return true;
  } catch (e) {
    return false;
  }
}
async function copyFileAndMakeWritable(from, to) {
  await fs.promises.copyFile(from, to);
  await fs.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.sep).join(path.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.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.promises.writeFile(op.file, op.content, {
            flag: 'wx'
          }).catch(() => {});else await fs.promises.writeFile(op.file, op.content);
          return;
        }
      case 'copyFile':
        {
          await fs.promises.copyFile(op.from, op.to);
          return;
        }
      case 'appendFile':
        {
          await fs.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.createWriteStream(op.zipFileName)).on('close', () => result.resolve()).on('error', error => result.reject(error));
          await result;
          return;
        }
    }
  }
}
exports.SerializedFS = SerializedFS;