twm-weapp/dist/helper/FileResourceGen.js

"use strict";

require("core-js/modules/es.array.find");

require("core-js/modules/es.array.index-of");

require("core-js/modules/es.regexp.exec");

require("core-js/modules/es.string.replace");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.processUnlinkDir = exports.processAddDir = exports.processAddFile = void 0;

var _utils = require("../utils");

var _resource = require("../resource");

/**
 * 生成文件对象
 * 根据扩展字段里的配置，如果文件需要翻译( 配置 replace 字段 )，则会生成 Source File (.ts) 和 Target File(.js)
 */
var processAddFile = function processAddFile(sourcePath, context) {
  var extensionMap = context.extensionMap,
      extensionNames = context.extensionNames,
      extensions = context.extensions,
      replaceNames = context.replaceNames,
      output = context.output,
      root = context.root,
      fileContext = context.fileContext; // 获取 Source File 的扩展对象

  var extension = getExtension((0, _utils.extname)(sourcePath), extensionNames, extensions); // 生成 Source File 对象

  var sourceFile = new _resource.FileResource({
    sourceAbsolutePath: sourcePath,
    distAbsolutePath: (0, _utils.joinPath)(output, (0, _utils.relativePath)(root, sourcePath)),
    extension: extension
  });
  var translateFilePathE = sourceFile.extname; // 获取 Target File 的扩展名，根据 Source File 的扩展名从配置里获取，如果没有配置使用原来的扩展名

  if (extensionMap[sourceFile.extname]) {
    if (extension && (extension.test && extension.test.test(sourceFile.sourceAbsolutePath) || !extension.test)) {
      translateFilePathE = extensionMap[sourceFile.extname];
    }
  } // const translateFilePathE = extensionMap[sourceFile.extname]
  //     ? extensionMap[sourceFile.extname]
  //     : sourceFile.extname;
  // 获取 Target File 的路径


  var translateFilePathA = extension ? (0, _utils.joinPath)((0, _utils.dirname)(sourceFile.sourceAbsolutePath), sourceFile.fileNoExtName + translateFilePathE) : sourceFile.sourceAbsolutePath; // 获取 Target File 的生成路径

  var translateFilePathD = extension ? (0, _utils.joinPath)(output, (0, _utils.relativePath)(root, (0, _utils.dirname)(translateFilePathA)), sourceFile.fileNoExtName + translateFilePathE) : sourceFile.distAbsolutePath; // 获取 Target File 的扩展对象

  var translateE = getExtension((0, _utils.extname)(translateFilePathA), extensionNames, extensions);

  if (extension && extension.replace && typeof extension.replace === 'string' && extension.replace !== extension.extname) {
    // 处理需要翻译的文件，需要生成 TargetFile
    processAddSourceFile(sourceFile, translateFilePathA, translateFilePathD, translateE, fileContext);
  } else {
    // 处理不需要翻译的文件，Target File 可以共用 Source File
    processAddTargetFile(sourceFile, translateFilePathA, extensions, replaceNames, fileContext);
  }
};
/**
 * 从 extensionNames 中获取与扩展名 fileExtName 相同的扩展对象
 */


exports.processAddFile = processAddFile;

var getExtension = function getExtension(fileExtName, extensionNames, extensions) {
  var eIndex = extensionNames.indexOf(fileExtName);
  var ext = extensions[eIndex];
  return ext;
};
/**
 * 处理需要翻译的文件
 */


var processAddSourceFile = function processAddSourceFile(sourceFile, sourceAbsolutePath, distAbsolutePath, extension, fileContext) {
  // 直接生成 Target File，并设置
  var sourceTarget = new _resource.FileResource({
    sourceAbsolutePath: sourceAbsolutePath,
    distAbsolutePath: distAbsolutePath,
    extension: extension
  });
  fileContext.addFile(sourceFile, sourceTarget);
};
/**
 * 处理不需要翻译的文件
 */


var processAddTargetFile = function processAddTargetFile(sourceFile, translateFilePathA, extensions, repaceNames, fileContext) {
  // 处理不需要翻译的文件，且已经存在 Target File 的 Source File
  // 例如: 存在 app.less 和 app.wxss 两个文件，遍历到 app.less 时会同时生成 Source File 和 Target File
  // 而遍历到 app.wxss 时不再需要生成文件对象了
  if (fileContext.isSameTargetFile(sourceFile)) {
    return;
  } // 获取扩展对象
  // const extension = getExtension( sourceFile.extname, repaceNames, extensions );


  var extension = extensions.find(function (e) {
    return e.replace === sourceFile.extname;
  });
  var path = translateFilePathA;

  if (extension) {
    path = (0, _utils.replaceExtname)(translateFilePathA, extension.extname);
  }

  try {
    (0, _utils.accessSync)(path);

    if (!extension) {
      fileContext.addFile(sourceFile, sourceFile);
    }
  } catch (e) {
    fileContext.addFile(sourceFile, sourceFile);
  }
};

var processAddDir = function processAddDir(pathA, context) {
  var output = context.output,
      root = context.root,
      fileContext = context.fileContext;

  if (fileContext.translateNameDirMap.has(pathA)) {
    return;
  }

  var pathD = (0, _utils.joinPath)(output, (0, _utils.relativePath)(root, pathA));
  var sourceDir = new _resource.DirectorResource(pathA, pathD, _resource.EDirectorState.ADD);
  fileContext.addDirector(sourceDir, sourceDir);
};

exports.processAddDir = processAddDir;

var processUnlinkDir = function processUnlinkDir(pathA, context) {
  var fileContext = context.fileContext;

  var _fileContext$getChang = fileContext.getChangeDirSourceAndTarget(pathA),
      dirSource = _fileContext$getChang.dirSource,
      dirTarget = _fileContext$getChang.dirTarget;

  if (dirSource && dirTarget) {
    fileContext.unlinkDirector(dirSource);
  }
};

exports.processUnlinkDir = processUnlinkDir;