build method

Stream<PackagexApiStatus> build({
  1. required Directory directoryBase,
  2. required List<PackagexPlatformType> packagexPlatformTypes,
  3. required Directory? directoryBuild,
  4. required bool isApplication,
  5. required PackagexConfig? packagexConfig,
})

UncompleteDocumentation

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(", ")}",
  );

  final File file_pubspec =
      File(path.join(directoryBase.path, "pubspec.yaml"));

  await for (final streamCreate in create(
    newName: path.basename(directoryBase.path),
    directoryPackage: directoryBase.parent,
    isApplication: isApplication,
    packagexConfig: packagexConfig,
    isDontAddFlutterCommands: true,
  )) {
    yield streamCreate;
  }
  final Map yaml_code =
      (yaml.loadYaml(file_pubspec.readAsStringSync(), recover: true) as Map);

  final 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"]);

  final 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()}",
  );

  final File file_script_pkgx =
      File(path.join(directoryBase.path, "lib", "packagex", "packagex.dart"));
  if (file_script_pkgx.parent.existsSync() == false) {
    await file_script_pkgx.parent.create(
      recursive: true,
    );
  }
  final Map json_data_package_detail = {
    "name": "${packagexPubspec.name}".trim(),
    ...packagexPubspec.rawData,
  };

  json_data_package_detail.removeByKeys([
    "environment",
    "dependencies",
    "dev_dependencies",
    "dependency_overrides",
    "flutter",
    "packagex",
    "msix_config",
  ]);

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

/// AutoGenerateBy Packagex
class PackagexProject${(packagexPubspec.name ?? "").split("_").map((e) => e.toUpperCaseFirstData()).join("").toUpperCaseFirstData()} {
/// AutoGenerateBy Packagex
static bool isSame({
  required String data
}) {
  return [default_data_to_string, json.encode(default_data)].contains(data);
}
/// AutoGenerateBy Packagex
  static String get default_data_to_string {
    return (JsonEncoder.withIndent(" " * 2).convert(default_data));
  }
/// AutoGenerateBy Packagex
  static Map get default_data {
return ${JsonEncoder.withIndent(" " * 2).convert(json_data_package_detail)};
  }

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

  final 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);
    }
  }

  {
    final Process process = await Process.start(
      (isApplication) ? "flutter" : "dart",
      [
        "pub",
        "get",
        "--offline",
      ],
      workingDirectory: directoryBase.path,
    );
    process.stderr.listen((event) {
      stderr.add(event);
    });
    process.stdout.listen((event) {
      stdout.add(event);
    });
    final int exit_code = await (process.exitCode);
  }

  final List<PackagexConfigPackage> packages =
      packagexPubspec.packagex.packages;
  for (final PackagexConfigPackage packagexConfigPackage in packages) {
    final String dart_target =
        packagexConfigPackage.dart_target ?? packagexPubspec.name ?? "";
    final String dart_name = packagexConfigPackage.dart_name ??
        packagexPubspec.name!.packagex_utils_extension_toLinuxProgram();
    final String flutter_target =
        packagexConfigPackage.flutter_target ?? "main";
    final String flutter_name =
        packagexConfigPackage.flutter_name ?? packagexPubspec.name ?? "";
    final String output_name = packagexConfigPackage.output_name ??
        (packagexPubspec.name ?? "")
            .packagex_utils_extension_toLinuxProgram();

    final File file_packagex_release =
        File(path.join(directory_build_packagex.path, "${output_name}.json"));
    await file_packagex_release
        .writeAsString(json_data_package_detail.toStringifyPretty(2));

    for (final PackagexPlatformType packagexPlatformType
        in packagexPlatformTypes.toSet()) {
      final File script_cli =
          File(path.join(directoryBase.path, "bin", "${dart_target}.dart"));
      final File script_app = File(
        path.join(directoryBase.path, "lib", "${flutter_target}.dart"),
      );
      final bool is_app = script_app.existsSync();
      final bool is_cli = script_cli.existsSync();

      final List<String> dart_compile_arguments =
          packagexPubspec.packagex.dart_compile_exe_arguments.clone();
      final List<String> flutter_build_arguments =
          packagexPubspec.packagex.flutter_build_arguments.clone();

      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;
          }

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

          final Directory directory_linux_packagex_app_opt = Directory(
            path.join(
              directory_linux_package.path,
              "opt",
              (packagexPubspec.name ?? "")
                  .packagex_utils_extension_toLinuxProgram(),
            ),
          );

          if (is_app) {
            if (packagexPubspec.packagex.is_app_auto_clean_up_folder ==
                true) {
              if (directory_linux_packagex_app_opt.existsSync()) {
                await directory_linux_packagex_app_opt.delete(
                  recursive: true,
                );
              }
              await directory_linux_packagex_app_opt.create(recursive: true);
            } else {
              if (directory_linux_packagex_app_opt.existsSync() == false) {
                await directory_linux_packagex_app_opt.create(
                  recursive: true,
                );
              }
            }
          }
          final String message =
              "Set Permission: ${path.join(directory_linux_package.path, "DEBIAN")}";
          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}",
          );
          final 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);
          });
          final 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}",
            );
          }

          final File file_cli = File(
            path.join(
              directory_linux_package.path,
              "usr",
              "bin",
              "${dart_name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-linux"}",
            ),
          );
          final File file_output_app = File(
            path.join(
              directory_build_packagex.path,
              "${output_name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-linux"}.deb",
            ),
          );

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

From: ${script_cli.path}
To: ${file_cli.path}
"""
                .trim();
            yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}",
            );
            final Process process = await Process.start(
              "dart",
              [
                "compile",
                "exe",
                ...dart_compile_arguments,
                script_cli.path,
                "-o",
                file_cli.path,
              ],
              workingDirectory: directoryBase.path,
            );
            process.stderr.listen((event) {
              stderr.add(event);
            });
            process.stdout.listen((event) {
              stdout.add(event);
            });
            final int exit_code = await (process.exitCode);
            if (exit_code != 0) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } else {
              yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}",
              );
            }
          }
          if (is_cli) {
            final String message = "Set Permission: ${file_cli.path}";
            yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}",
            );
            final 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);
            });
            final int exit_code = await (process.exitCode);
            if (exit_code != 0) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } else {
              yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}",
              );
            }
          }

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

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

          if (is_app || is_cli) {
            final 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);
            });
            final int exit_code = await (process.exitCode);
            if (exit_code != 0) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } else {
              yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}",
              );
            }
          }
          if (is_app || is_cli) {
            final String message = "Dpkg Build: ${file_output_app.path}";
            yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}",
            );
            final Process process = await Process.start(
              "dpkg-deb",
              [
                "--build",
                "--root-owner-group",
                directory_linux_package.path,
                file_output_app.path,
              ],
              workingDirectory: directoryBase.path,
            );
            process.stderr.listen((event) {
              stderr.add(event);
            });
            process.stdout.listen((event) {
              stdout.add(event);
            });
            final int exit_code = await (process.exitCode);
            if (exit_code != 0) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } else {
              yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}",
              );
            }
            try {
              if (file_cli.existsSync()) {
                await file_cli.delete(recursive: true);
              }
            } catch (e) {}
          }

          if (packagexPubspec.packagex.is_app_auto_clean_up_folder == true) {
            if (directory_linux_packagex_app_opt.existsSync()) {
              await directory_linux_packagex_app_opt.delete(recursive: true);
            }
          }
          final String pathRelative =
              path.relative(file_output_app.path, from: directoryBase.path);

          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.succes,
            value:
                "✓ Built ${pathRelative} (${FileSize.filesize(size: file_output_app.statSync().size)})",
          );

          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value:
                "Command install: sudo dpkg --force-all --install ${pathRelative}",
          );

          continue;
        }

        if (packagexPlatformType == PackagexPlatformType.android) {
          if (is_app) {
            final String message = " Flutter Build:";
            yield PackagexApiStatus(
              packagexApiStatusType: PackagexApiStatusType.info,
              value: "Starting ${message}",
            );
            final Process process = await Process.start(
              "flutter",
              [
                "build",
                "apk",
                "--release",
                "--split-per-abi",
                "--target=${script_app.path}",
                ...flutter_build_arguments
                    .packagexUtilsParseFlutterArgumentsAndroid(),
              ],
              workingDirectory: directoryBase.path,
            );
            process.stderr.listen((event) {
              stderr.add(event);
            });
            process.stdout.listen((event) {
              stdout.add(event);
            });
            final int exit_code = await (process.exitCode);
            if (exit_code != 0) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } else {
              yield PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.succes,
                value: "Succes ${message}",
              );
            }
            final Directory directory_apk = Directory(
              path.join(
                directoryBase.path,
                "build",
                "app",
                "outputs",
                "flutter-apk",
              ),
            );
            final List<FileSystemEntity> dirs = directory_apk.listSync();
            for (var i = 0; i < dirs.length; i++) {
              final 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;
                  }
                  final File fileSaveTo = File(
                    path.join(
                      directory_build_packagex.path,
                      path.basename(dir.path).replaceAll(
                            RegExp("^(app)", caseSensitive: false),
                            "${output_name}",
                          ),
                    ),
                  );
                  await dir.absolute.copy(fileSaveTo.path);
                  final String pathRelative = path.relative(
                    fileSaveTo.path,
                    from: directoryBase.path,
                  );

                  yield PackagexApiStatus(
                    packagexApiStatusType: PackagexApiStatusType.succes,
                    value:
                        "✓ Built ${pathRelative} (${FileSize.filesize(size: fileSaveTo.statSync().size)})",
                  );

                  yield PackagexApiStatus(
                    packagexApiStatusType: PackagexApiStatusType.info,
                    value:
                        "Command install: adb install -r -g ${pathRelative}",
                  );

                  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;
        }
        final File file_cli = File(
          path.join(
            directory_build_packagex.path,
            "${dart_name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-windows"}.exe",
          ),
        );
        if (is_cli) {
          final String message = """
Compile Script Dart:

From: ${script_cli.path}
To: ${file_cli.path}
"""
              .trim();
          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}",
          );
          final Process process = await Process.start(
            "dart",
            [
              "compile",
              "exe",
              ...dart_compile_arguments,
              script_cli.path,
              "-o",
              file_cli.path,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          final 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) {
          final List<String> args_msix = [];
          final 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);
            }
          });
          final String message = " Flutter Build: ";
          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}",
          );
          Process process = await Process.start(
            "flutter",
            [
              "run",
              "msix:create",
              "--windows-build-args",
              "--target=${script_app.path} ${flutter_build_arguments.packagexUtilsParseFlutterArgumentsWindows().join(" ")}",
              "-o",
              directory_build_packagex.path,
              "-n",
              "${flutter_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 == false) {
          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;
        }
        final File file_cli = File(
          path.join(
            directory_build_packagex.path,
            "${dart_name}${(packagexPubspec.packagex.is_without_platform_name == true) ? "" : "-cli-macos"}",
          ),
        );
        if (is_cli) {
          final String message = """
Compile Script Dart:

From: ${script_cli.path}
To: ${file_cli.path}
"""
              .trim();
          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}",
          );
          final Process process = await Process.start(
            "dart",
            [
              "compile",
              "exe",
              ...dart_compile_arguments,
              script_cli.path,
              "-o",
              file_cli.path,
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          final 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) {
          final String message = " Flutter Build: ";
          yield PackagexApiStatus(
            packagexApiStatusType: PackagexApiStatusType.info,
            value: "Starting ${message}",
          );
          final Process process = await Process.start(
            "flutter",
            [
              "build",
              "macos",
              "--release",
              "--target=${script_app.path}",
              ...flutter_build_arguments
                  .packagexUtilsParseFlutterArgumentsMacos(),
            ],
            workingDirectory: directoryBase.path,
          );
          process.stderr.listen((event) {
            stderr.add(event);
          });
          process.stdout.listen((event) {
            stdout.add(event);
          });
          final 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 == false) {
          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_build_arguments
                  .packagexUtilsParseFlutterArgumentsIos(),
            ],
            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, "${flutter_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}",
            ],
            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) {
          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,
                  "${flutter_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) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } 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,
                  "${flutter_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) {
              /// THROW ERROR
              throw PackagexApiStatus(
                packagexApiStatusType: PackagexApiStatusType.failed,
                value: "Failed ${message}",
              );
            } 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(", ")}",
  );
}