build method

Stream<PackagexApiStatus> build({ required Directory directoryBase, required List<PackagexPlatformType> packagexPlatformTypes, required Directory? directoryBuild, required bool isApplication, required PackagexConfig? packagexConfig, })

Implementation

Stream<PackagexApiStatus> build({
  required Directory directoryBase,
  required List<PackagexPlatformType> packagexPlatformTypes,
  required Directory? directoryBuild,
  required bool isApplication,
  required PackagexConfig? packagexConfig,
}) async* {
  packagexConfig ??= PackagexConfig({});
  yield PackagexApiStatus(
      packagexApiStatusType: PackagexApiStatusType.info,
      value:
          "Starting Build: ${packagexPlatformTypes.map((e) => e.name.toUpperCaseFirstData()).join(", ")}");

  File file_pubspec = File(path.join(directoryBase.path, "pubspec.yaml"));
  var strm = create(
    newName: path.basename(directoryBase.path),
    directoryPackage: directoryBase.parent,
    isApplication: isApplication,
    packagexConfig: packagexConfig,
  );
  await for (var event in strm) {
    yield event;
  }
  Map yaml_code =
      (yaml.loadYaml(file_pubspec.readAsStringSync(), recover: true) as Map);

  PackagexPubspec packagexPubspec = PackagexPubspec(yaml_code.clone());

  packagexPubspec.packagex.rawData.general_lib_utils_updateMapWithReplace(
      data: packagexConfig.rawData, ignoreKeys: ["@type"]);
  packagexPubspec.rawData
      .general_lib_utils_removeRecursiveByKeys(keyDatas: ["@type"]);

  Directory directory_build_packagex = directoryBuild ??
      Directory(path.join(directoryBase.path, "build", "packagex"));
  yield PackagexApiStatus(
      packagexApiStatusType: PackagexApiStatusType.info,
      value: "Directory Build: ${directory_build_packagex.uri.toFilePath()}");

  File file_script_pkgx =
      File(path.join(directoryBase.path, "lib", "packagex", "packagex.dart"));
  if (!file_script_pkgx.parent.existsSync()) {
    await file_script_pkgx.parent.create(
      recursive: true,
    );
  }
  Map json_data_package_detail = {
    "name": "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}"
        .trim(),
    ...packagexPubspec.rawData,
    ...packagexPubspec.packagex.flutter_commands.rawData,
  };
  json_data_package_detail.removeByKeys([
    "environment",
    "dependencies",
    "dev_dependencies",
    "flutter",
    "packagex",
    "msix_config",
  ]);

  String packagex_script_project = """
// ignore_for_file: non_constant_identifier_names
import 'dart:convert';

class PackagexProject${(packagexPubspec.packagex.flutter_name ?? packagexPubspec.name ?? "").split("_").map((e) => e.toUpperCaseFirstData()).join("").toUpperCaseFirstData()} {

static bool isSame({
  required String data
}) {
  return [default_data_to_string, json.encode(default_data)].contains(data);
}

  static String get default_data_to_string {
    return (JsonEncoder.withIndent(" " * 2).convert(default_data));
  }

  static Map get default_data {
return ${JsonEncoder.withIndent(" " * 2).convert(json_data_package_detail)};
  }

}
"""
      .trim();
  await file_script_pkgx.writeAsString(packagex_script_project);

  bool is_auto_delete =
      Platform.environment["packagex_is_auto_delete"] == "true";
  if (is_auto_delete) {
    if (directory_build_packagex.existsSync()) {
      await directory_build_packagex.delete(recursive: true);
    }
    await directory_build_packagex.create(recursive: true);
  } else {
    if (directory_build_packagex.existsSync() == false) {
      await directory_build_packagex.create(recursive: true);
    }
  }

  File file_packagex_release = File(path.join(directory_build_packagex.path,
      "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}.json"));
  await file_packagex_release
      .writeAsString(json_data_package_detail.toStringifyPretty(2));

  for (PackagexPlatformType packagex_platform_type
      in packagexPlatformTypes.toSet()) {
    PackagexPlatformType packagexPlatformType = packagex_platform_type;

    File script_cli = File(path.join(directoryBase.path, "bin",
        "${packagexPubspec.packagex.dart_target ?? packagexPubspec.name}.dart"));
    File script_app = File(path.join(directoryBase.path, "lib",
        "${packagexPubspec.packagex.flutter_target ?? "main"}.dart"));
    bool is_app = false;
    bool is_cli = false;
    if (script_app.existsSync()) {
      is_app = true;
    }
    if (script_cli.existsSync()) {
      is_cli = true;
    }

    List<String> flutter_commands = [];

    packagexPubspec.packagex.flutter_commands.rawData.forEach((key, value) {
      String key_args_flutter =
          "--${key.toString().replaceAll(RegExp(r"_"), "-")}";
      if (key_args_flutter == "--obfuscate") {
        if (value == true) {
          flutter_commands.add(key_args_flutter);
        }
      }
      if (key_args_flutter == "--split-per-abi") {
        if (value == true) {
          if (packagexPlatformType == PackagexPlatformType.android) {
            flutter_commands.add(key_args_flutter);
          }
        }
      }
      if (key_args_flutter == "--no-tree-shake-icons") {
        if (value == true) {
          flutter_commands.add(key_args_flutter);
        }
      }

      if (key_args_flutter == "--split-debug-info") {
        flutter_commands.add("${key_args_flutter}=${value}");
      }
      if (key_args_flutter == "--build-name") {
        flutter_commands.add("${key_args_flutter}=${value}");
      }
      if (key_args_flutter == "--build-number") {
        flutter_commands.add("${key_args_flutter}");
        flutter_commands.add("${value}");
      }
    });

    yield PackagexApiStatus(
        packagexApiStatusType: PackagexApiStatusType.info,
        value: "Starting Build: ${packagexPlatformType.name}");
    if (packagexPlatformType == PackagexPlatformType.android ||
        packagexPlatformType == PackagexPlatformType.linux) {
      if (packagexPlatformType == PackagexPlatformType.linux) {
        if (!Platform.isLinux) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Package linux hanya bisa di perangkat linux saja !");
          continue;
        }

        Directory directory_linux_package = Directory(path.join(
          directoryBase.path,
          "linux",
          "packagex",
        ));

        Directory directory_app_deb = Directory(path.join(
          directory_linux_package.path,
          "usr",
          "share",
          (packagexPubspec.name ?? "").replaceAll(RegExp(r"([_])"), "-"),
        ));

        if (is_app) {
          if (directory_app_deb.existsSync()) {
            await directory_app_deb.delete(recursive: true);
            await directory_app_deb.create(recursive: true);
          } else {
            await directory_app_deb.create(recursive: true);
          }
        }
        String message =
            "Set Permission: ${path.join(directory_linux_package.path, "DEBIAN")}";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "chmod",
          [
            "-R",
            "775",
            path.join(directory_linux_package.path, "DEBIAN"),
          ],
          runInShell: true,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }

        File file_cli = File(path.join(
          directory_linux_package.path,
          "usr",
          "bin",
          "${packagexPubspec.packagex.dart_name ?? packagexPubspec.name!.replaceAll(RegExp(r"([_])"), "-")}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-linux"}",
        ));
        File file_app = File(path.join(directory_build_packagex.path,
            "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-linux"}.deb"));

        if (is_cli) {
          String message = """
Compile Script Dart:

From: ${script_cli.path}
To: ${file_cli.path}
"""
              .trim();
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "dart",
            [
              "compile",
              "exe",
              script_cli.path,
              "-o",
              file_cli.path,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }
        if (is_cli) {
          String message = "Set Permission: ${file_cli.path}";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "chmod",
            [
              "775",
              file_cli.path,
            ],
            runInShell: true,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }

        if (is_app) {
          String message = " Flutter Build:";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "flutter",
            [
              "build",
              "linux",
              "--release",
              "--target=${script_app.path}",
              ...flutter_commands,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }
        if (is_app) {
          String path_app = path.join(directoryBase.path, "build", "linux",
              "x64", "release", "bundle", ".");

          String message =
              "Copy App Files: From ${path_app} To ${directory_app_deb.path} ";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "cp",
            [
              "-rf",
              path_app,
              directory_app_deb.path,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }

        if (is_app || is_cli) {
          String message =
              "Set Permission: chmod -R 755 ${directory_linux_package.path}";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "chmod",
            ["-R", "775", directory_linux_package.path],
            runInShell: true,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }
        if (is_app || is_cli) {
          String message = "Dpkg Build: ${file_app.path}";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "dpkg-deb",
            [
              "--build",
              "--root-owner-group",
              directory_linux_package.path,
              file_app.path,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
          try {
            if (file_cli.existsSync()) {
              await file_cli.delete(recursive: true);
            }
          } catch (e) {}
        }
        await directory_app_deb.delete(recursive: true);

        continue;
      }

      if (packagexPlatformType == PackagexPlatformType.android) {
        if (is_app) {
          String message = " Flutter Build:";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "flutter",
            [
              "build",
              "apk",
              "--release",
              "--split-per-abi",
              "--target=${script_app.path}",
              ...flutter_commands,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
          Directory directory_apk = Directory(path.join(
              directoryBase.path, "build", "app", "outputs", "flutter-apk"));
          List<FileSystemEntity> dirs = directory_apk.listSync();
          for (var i = 0; i < dirs.length; i++) {
            FileSystemEntity dir = dirs[i];
            try {
              if (dir is Directory) {
              } else if (dir is File) {
                if (path.extension(dir.path) != ".apk") {
                  continue;
                }
                if (path.basename(dir.path) == "app-release.apk") {
                  continue;
                }
                await dir.absolute.copy(path.join(
                    directory_build_packagex.path,
                    path.basename(dir.path).replaceAll(
                        RegExp("^(app)", caseSensitive: false),
                        "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}")));
                await dir.absolute.delete(
                  recursive: true,
                );
              }
            } catch (e) {}
          }
        }
      }
    }
    if (packagexPlatformType == PackagexPlatformType.windows) {
      if (!Platform.isWindows) {
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.failed,
            value: "Package windows hanya bisa di perangkat windows saja !");
        continue;
      }
      File file_cli = File(
        path.join(directory_build_packagex.path,
            "${packagexPubspec.packagex.dart_name ?? packagexPubspec.name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-windows"}.exe"),
      );
      if (is_cli) {
        String message = """
Compile Script Dart:

From: ${script_cli.path}
To: ${file_cli.path}
"""
            .trim();
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "dart",
          [
            "compile",
            "exe",
            script_cli.path,
            "-o",
            file_cli.path,
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }

      if (is_app) {
        List<String> args_msix = [];
        List<String> msix_args = [
          "--display-name",
          "--publisher-display-name",
          "--identity-name",
          "--version",
          "--logo-path",
          "--trim-logo",
          "--capabilities",
          "--languages",
          "--file-extension",
          "--protocol-activation",
          "--app-uri-handler-hosts",
          "--execution-alias",
          "--enable-at-startup",
          "--store",
          "--certificate-path",
          "--certificate-password",
          "--publisher",
          "--signtool-options",
          "--sign-msix",
          "--install-certificate",
        ];
        packagexPubspec.msix_config.rawData.forEach((key, value) {
          if (value is String && value.isNotEmpty) {
            String key_args_msix =
                "--${key.toString().replaceAll(RegExp(r"_"), "-")}";
            if (!msix_args.contains(key_args_msix)) {
              return;
            }
            if (key_args_msix == "--version") {
              List<String> versions = value.toString().split(".");
              if (versions.length != 4) {
                value = "0.0.0.0";
              }
            }
            args_msix.add(key_args_msix);
            args_msix.add(value);
          }
        });
        String message = " Flutter Build: ";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "flutter",
          [
            "pub",
            "run",
            "msix:create",
            "--windows-build-args",
            "--target=${script_app.path} ${flutter_commands.join(" ")}",
            "-o",
            directory_build_packagex.path,
            "-n",
            "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-app-windows"}",
            ...args_msix,
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }
    }

    if (packagexPlatformType == PackagexPlatformType.macos) {
      if (!Platform.isMacOS) {
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.failed,
            value: "Package macos hanya bisa di perangkat macos saja !");
        // return {"@type": "error", "message": "platform_not_supported", "description": "Package macos hanya bisa di perangkat macos saja !"};
        continue;
      }
      File file_cli = File(path.join(directory_build_packagex.path,
          "${packagexPubspec.packagex.dart_name ?? packagexPubspec.name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-macos"}"));
      if (is_cli) {
        String message = """
Compile Script Dart:

From: ${script_cli.path}
To: ${file_cli.path}
"""
            .trim();
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "dart",
          [
            "compile",
            "exe",
            script_cli.path,
            "-o",
            file_cli.path,
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }

      if (is_app) {
        String message = " Flutter Build: ";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "flutter",
          [
            "build",
            "macos",
            "--release",
            "--target=${script_app.path}",
            ...flutter_commands,
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }
    }

    if (packagexPlatformType == PackagexPlatformType.ios) {
      if (!Platform.isMacOS) {
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.failed,
            value: "Package ios hanya bisa di perangkat macos saja !");
        continue;
      }

      if (is_app) {
        String message = " Flutter Build:";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "flutter",
          [
            "build",
            "ios",
            "--release",
            "--no-codesign",
            "--target=${script_app.path}",
            ...flutter_commands,
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }
      if (is_app) {
        String message = " Flutter Build:";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "sh",
          [
            "-c",
            """
cd build/ios/iphoneospackagexCli(args)
mkdir Payload
cd Payload
ln -s ../Runner.app
cd ..
zip -r  ${path.join(directory_build_packagex.path, "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-ios"}.ipa")} Payload
"""
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }
      continue;
    }

    if (packagexPlatformType == PackagexPlatformType.web) {
      if (is_app) {
        String message = " Flutter Build:";
        yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}");
        Process process = await Process.start(
          "flutter",
          [
            "build",
            "web",
            "--release",
            "--target=${script_app.path}",
            "--web-renderer",
            "html",
          ],
          workingDirectory: directoryBase.path,
        );
        process.stderr.listen((event) {
          stderr.add(event);
        });
        process.stdout.listen((event) {
          stdout.add(event);
        });
        int exit_code = await (process.exitCode);
        if (exit_code != 0) {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.failed,
              value: "Failed ${message}");
          return;
        } else {
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.succes,
              value: "Succes ${message}");
        }
      }
      if (is_app) {
        Directory directory_build_web_canvaskit = Directory(
            path.join(directoryBase.path, "build", "web", "canvaskit", "."));

        try {
          await directory_build_web_canvaskit.delete(recursive: true);
        } catch (e) {}

        if (Platform.isWindows) {
          String message = " Compress:";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "tar",
            [
              "-cf",
              path.join(directory_build_packagex.path,
                  "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}-web.zip"),
              "*",
            ],
            workingDirectory: path.join(directoryBase.path, "build", "web"),
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }

        if (Platform.isMacOS || Platform.isLinux) {
          String message = " Compress:";
          yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}");
          Process process = await Process.start(
            "zip",
            [
              "-r",
              path.join(directory_build_packagex.path,
                  "${packagexPubspec.packagex.flutter_name ?? packagexPubspec.name}-web.zip"),
              ".",
            ],
            workingDirectory:
                path.join(directoryBase.path, "build", "web", "."),
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          int exit_code = await (process.exitCode);
          if (exit_code != 0) {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}");
            return;
          } else {
            yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}");
          }
        }
      }
      continue;
    }
  }
  yield PackagexApiStatus(
      packagexApiStatusType: PackagexApiStatusType.succes,
      value:
          "Finished Build: ${packagexPlatformTypes.map((e) => e.name.toUpperCaseFirstData()).join(", ")}");
}