electron-builder-lib/out/linuxPackager.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.toAppImageOrSnapArch = toAppImageOrSnapArch;
exports.LinuxPackager = void 0;

function _bluebirdLst() {
  const data = require("bluebird-lst");

  _bluebirdLst = function () {
    return data;
  };

  return data;
}

function _builderUtil() {
  const data = require("builder-util");

  _builderUtil = function () {
    return data;
  };

  return data;
}

function _sanitizeFilename() {
  const data = _interopRequireDefault(require("sanitize-filename"));

  _sanitizeFilename = function () {
    return data;
  };

  return data;
}

function _core() {
  const data = require("./core");

  _core = function () {
    return data;
  };

  return data;
}

function _platformPackager() {
  const data = require("./platformPackager");

  _platformPackager = function () {
    return data;
  };

  return data;
}

function _RemoteBuilder() {
  const data = require("./remoteBuilder/RemoteBuilder");

  _RemoteBuilder = function () {
    return data;
  };

  return data;
}

function _LinuxTargetHelper() {
  const data = require("./targets/LinuxTargetHelper");

  _LinuxTargetHelper = function () {
    return data;
  };

  return data;
}

function _targetFactory() {
  const data = require("./targets/targetFactory");

  _targetFactory = function () {
    return data;
  };

  return data;
}

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class LinuxPackager extends _platformPackager().PlatformPackager {
  constructor(info) {
    super(info, _core().Platform.LINUX);
    const executableName = this.platformSpecificBuildOptions.executableName;
    this.executableName = executableName == null ? this.appInfo.sanitizedName.toLowerCase() : (0, _sanitizeFilename().default)(executableName);
  }

  get defaultTarget() {
    return ["snap", "appimage"];
  }

  createTargets(targets, mapper) {
    let helper;

    const getHelper = () => {
      if (helper == null) {
        helper = new (_LinuxTargetHelper().LinuxTargetHelper)(this);
      }

      return helper;
    };

    let remoteBuilder = null;

    for (const name of targets) {
      if (name === _core().DIR_TARGET) {
        continue;
      }

      const targetClass = (() => {
        switch (name) {
          case "appimage":
            return require("./targets/AppImageTarget").default;

          case "snap":
            return require("./targets/snap").default;

          case "deb":
          case "rpm":
          case "sh":
          case "freebsd":
          case "pacman":
          case "apk":
          case "p5p":
            return require("./targets/fpm").default;

          default:
            return null;
        }
      })();

      mapper(name, outDir => {
        if (targetClass === null) {
          return (0, _targetFactory().createCommonTarget)(name, outDir, this);
        }

        const target = new targetClass(name, this, getHelper(), outDir);

        if (process.platform === "win32" || process.env._REMOTE_BUILD) {
          if (remoteBuilder == null) {
            remoteBuilder = new (_RemoteBuilder().RemoteBuilder)(this);
          } // return remoteBuilder.buildTarget(this, arch, appOutDir, this.packager)


          return new RemoteTarget(target, remoteBuilder);
        }

        return target;
      });
    }
  }

}

exports.LinuxPackager = LinuxPackager;

class RemoteTarget extends _core().Target {
  constructor(target, remoteBuilder) {
    super(target.name, true
    /* all must be scheduled in time (so, on finishBuild RemoteBuilder will have all targets added - so, we must set isAsyncSupported to true (resolved promise is returned)) */
    );
    this.target = target;
    this.remoteBuilder = remoteBuilder;
    this.buildTaskManager = new (_builderUtil().AsyncTaskManager)(this.remoteBuilder.packager.info.cancellationToken);
  }

  get options() {
    return this.target.options;
  }

  get outDir() {
    return this.target.outDir;
  }

  finishBuild() {
    var _this = this;

    return (0, _bluebirdLst().coroutine)(function* () {
      yield _this.buildTaskManager.awaitTasks();
      yield _this.remoteBuilder.build();
    })();
  }

  build(appOutDir, arch) {
    const promise = this.doBuild(appOutDir, arch);
    this.buildTaskManager.addTask(promise);
    return promise;
  }

  doBuild(appOutDir, arch) {
    var _this2 = this;

    return (0, _bluebirdLst().coroutine)(function* () {
      _builderUtil().log.info({
        target: _this2.target.name,
        arch: _builderUtil().Arch[arch]
      }, "scheduling remote build");

      yield _this2.target.checkOptions();

      _this2.remoteBuilder.scheduleBuild(_this2.target, arch, appOutDir);
    })();
  }

}

function toAppImageOrSnapArch(arch) {
  switch (arch) {
    case _builderUtil().Arch.x64:
      return "x86_64";

    case _builderUtil().Arch.ia32:
      return "i386";

    case _builderUtil().Arch.armv7l:
      return "arm";

    case _builderUtil().Arch.arm64:
      return "arm_aarch64";

    default:
      throw new Error(`Unsupported arch ${arch}`);
  }
} 
//# sourceMappingURL=linuxPackager.js.map