build-minizip.yml

name: Build minizip static libraries

on:
  workflow_call:
    inputs:
      zlib_release_tag:
        required: false
        type: string
  workflow_dispatch:
    inputs:
      zlib_release_tag:
        description: Optional zlib release tag to use
        required: false
        type: string
  push:
    branches: [ master ]
    paths:
      - minizip/**
      - zlib/fetch.sh
      - .github/scripts/latest-release-tag.sh
      - .github/workflows/build-minizip.yml
  pull_request:
    branches: [ master ]
    paths:
      - minizip/**
      - zlib/fetch.sh
      - .github/scripts/latest-release-tag.sh
      - .github/workflows/build-minizip.yml

env:
  MINIZIP_VERSION: 1.3.1
  ZLIB_VERSION: 1.3.1
  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true

jobs:
  prepare:
    name: Resolve zlib release
    runs-on: ubuntu-24.04
    outputs:
      zlib_release_tag: ${{ steps.release.outputs.zlib_release_tag }}

    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Resolve zlib release tag
        id: release
        env:
          REQUESTED_ZLIB_RELEASE_TAG: ${{ inputs.zlib_release_tag }}
        run: |
          if [ -n "${REQUESTED_ZLIB_RELEASE_TAG}" ]; then
            zlib_release_tag="${REQUESTED_ZLIB_RELEASE_TAG}"
          else
            zlib_release_tag="$(.github/scripts/latest-release-tag.sh zlib "${ZLIB_VERSION}")"
          fi

          echo "Using zlib release ${zlib_release_tag}"
          echo "zlib_release_tag=${zlib_release_tag}" >> "$GITHUB_OUTPUT"

  build-linux:
    name: Build ${{ matrix.platform_arch }}
    needs: prepare
    strategy:
      fail-fast: false
      matrix:
        include:
          - project: linux-amd64
            runner: ubuntu-22.04
            docker_platform: linux/amd64
            platform_arch: linux/x86_64
            zlib_platform: linux
            zlib_arch: x86_64
            use_qemu: false
          - project: linux-arm32v7
            runner: ubuntu-22.04
            docker_platform: linux/arm/v7
            platform_arch: linux/armv7l
            zlib_platform: linux
            zlib_arch: armv7l
            use_qemu: true
          - project: linux-arm64
            runner: ubuntu-22.04-arm
            docker_platform: linux/arm64
            platform_arch: linux/aarch64
            zlib_platform: linux
            zlib_arch: aarch64
            use_qemu: false

    runs-on: ${{ matrix.runner }}

    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Allow multiarch
        if: ${{ matrix.use_qemu }}
        run: docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

      - name: Fetch zlib prebuilts
        run: |
          bash zlib/fetch.sh \
            --platform "${{ matrix.zlib_platform }}" \
            --arch "${{ matrix.zlib_arch }}" \
            --release-tag "${{ needs.prepare.outputs.zlib_release_tag }}"

      - name: Build static libraries
        run: |
          docker run \
            --platform ${{ matrix.docker_platform }} \
            -v "${PWD}:/sources" \
            -w /sources \
            -t totalcross/${{ matrix.project }}:v1.0.7 \
            bash -lc "
              cmake --version &&
              cmake -S /sources/minizip -B /sources/minizip/build/${{ matrix.project }} \
                -DCMAKE_BUILD_TYPE=Release \
                -DZLIB_DIR=/sources/zlib/local/${{ matrix.zlib_platform }}/${{ matrix.zlib_arch }} \
                -G Ninja &&
              cmake --build /sources/minizip/build/${{ matrix.project }} &&
              cmake --install /sources/minizip/build/${{ matrix.project }} --prefix /sources/minizip/build/${{ matrix.project }}/install &&
              bash /sources/minizip/scripts/package-artifact.sh \
                /sources/minizip/build/${{ matrix.project }} \
                /sources/minizip/build/${{ matrix.project }}/install \
                ${{ matrix.platform_arch }}
            "

      - name: Upload artifact
        uses: actions/upload-artifact@v7
        with:
          name: minizip-${{ matrix.project }}
          path: minizip/build/${{ matrix.project }}/minizip-*.tar.gz

  build-windows:
    name: Build windows/${{ matrix.arch }}
    needs: prepare
    strategy:
      fail-fast: false
      matrix:
        include:
          - arch: x86
            runner: windows-2022
            cmake_platform: Win32
          - arch: x64
            runner: windows-2022
            cmake_platform: x64
          - arch: arm64
            runner: windows-11-arm
            cmake_platform: ARM64

    runs-on: ${{ matrix.runner }}

    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Fetch zlib prebuilts
        shell: bash
        run: |
          bash zlib/fetch.sh \
            --platform windows \
            --arch ${{ matrix.arch }} \
            --release-tag "${{ needs.prepare.outputs.zlib_release_tag }}"

      - name: Build static libraries
        shell: bash
        run: |
          cmake -S minizip -B minizip/build/windows-${{ matrix.arch }} \
            -DCMAKE_BUILD_TYPE=Release \
            -DZLIB_DIR="$PWD/zlib/local/windows/${{ matrix.arch }}" \
            -G "Visual Studio 17 2022" \
            -A ${{ matrix.cmake_platform }}
          cmake --build minizip/build/windows-${{ matrix.arch }} --config Release
          cmake --install minizip/build/windows-${{ matrix.arch }} --config Release --prefix minizip/build/windows-${{ matrix.arch }}/install
          bash minizip/scripts/package-artifact.sh minizip/build/windows-${{ matrix.arch }} minizip/build/windows-${{ matrix.arch }}/install windows/${{ matrix.arch }}

      - name: Upload artifact
        uses: actions/upload-artifact@v7
        with:
          name: minizip-windows-${{ matrix.arch }}
          path: minizip/build/windows-${{ matrix.arch }}/minizip-*.tar.gz

  build-android:
    name: Build android/arm64-v8a
    needs: prepare
    runs-on: ubuntu-24.04

    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Setup Android SDK
        uses: android-actions/setup-android@v3
        with:
          packages: ''

      - name: Install Android NDK
        run: sdkmanager "ndk;28.2.13676358" "cmake;3.22.1"

      - name: Fetch zlib prebuilts
        run: |
          bash zlib/fetch.sh \
            --platform android \
            --arch arm64-v8a \
            --release-tag "${{ needs.prepare.outputs.zlib_release_tag }}"

      - name: Build static libraries
        run: |
          cmake -S minizip -B minizip/build/android-arm64-v8a \
            -DCMAKE_BUILD_TYPE=Release \
            -DZLIB_DIR="$PWD/zlib/local/android/arm64-v8a" \
            -DCMAKE_TOOLCHAIN_FILE="${ANDROID_HOME}/ndk/28.2.13676358/build/cmake/android.toolchain.cmake" \
            -DANDROID_ABI=arm64-v8a \
            -DANDROID_PLATFORM=android-24 \
            -DANDROID_USE_LEGACY_TOOLCHAIN_FILE=OFF \
            -G Ninja
          cmake --build minizip/build/android-arm64-v8a
          cmake --install minizip/build/android-arm64-v8a --prefix minizip/build/android-arm64-v8a/install
          bash minizip/scripts/package-artifact.sh minizip/build/android-arm64-v8a minizip/build/android-arm64-v8a/install android/arm64-v8a

      - name: Upload artifact
        uses: actions/upload-artifact@v7
        with:
          name: minizip-android-arm64-v8a
          path: minizip/build/android-arm64-v8a/minizip-*.tar.gz

  build-apple:
    name: Build ${{ matrix.platform }}/${{ matrix.arch }}
    needs: prepare
    strategy:
      fail-fast: false
      matrix:
        include:
          - platform: macos
            arch: arm64
            build_dir: macos-arm64
            cmake_generator: Ninja
            cmake_args: -DCMAKE_OSX_ARCHITECTURES=arm64
          - platform: ios
            arch: arm64
            build_dir: ios-arm64
            cmake_generator: Xcode
            cmake_args: -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED=NO
          - platform: ios-simulator
            arch: arm64
            build_dir: ios-simulator-arm64
            cmake_generator: Xcode
            cmake_args: -DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED=NO

    runs-on: macos-15

    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Fetch zlib prebuilts
        run: |
          bash zlib/fetch.sh \
            --platform "${{ matrix.platform }}" \
            --arch "${{ matrix.arch }}" \
            --release-tag "${{ needs.prepare.outputs.zlib_release_tag }}"

      - name: Build static libraries
        run: |
          cmake -S minizip -B minizip/build/${{ matrix.build_dir }} \
            -DCMAKE_BUILD_TYPE=Release \
            -DZLIB_DIR="$PWD/zlib/local/${{ matrix.platform }}/${{ matrix.arch }}" \
            ${{ matrix.cmake_args }} \
            -G "${{ matrix.cmake_generator }}"
          cmake --build minizip/build/${{ matrix.build_dir }} --config Release
          cmake --install minizip/build/${{ matrix.build_dir }} --config Release --prefix minizip/build/${{ matrix.build_dir }}/install
          bash minizip/scripts/package-artifact.sh minizip/build/${{ matrix.build_dir }} minizip/build/${{ matrix.build_dir }}/install ${{ matrix.platform }}/${{ matrix.arch }}

      - name: Upload artifact
        uses: actions/upload-artifact@v7
        with:
          name: minizip-${{ matrix.build_dir }}
          path: minizip/build/${{ matrix.build_dir }}/minizip-*.tar.gz

  package-ios:
    name: Package iOS XCFramework
    needs: build-apple
    runs-on: macos-15

    steps:
      - name: Download iOS device artifact
        uses: actions/download-artifact@v7
        with:
          name: minizip-ios-arm64
          path: package-input/ios

      - name: Download iOS simulator artifact
        uses: actions/download-artifact@v7
        with:
          name: minizip-ios-simulator-arm64
          path: package-input/ios-simulator

      - name: Create XCFramework
        run: |
          mkdir -p package-work package-output
          tar -xzf package-input/ios/minizip-ios-arm64.tar.gz -C package-work
          tar -xzf package-input/ios-simulator/minizip-ios-simulator-arm64.tar.gz -C package-work

          device_root="${PWD}/package-work/minizip/ios/arm64"
          simulator_root="${PWD}/package-work/minizip/ios-simulator/arm64"
          device_lib="$(find "${device_root}/lib" -type f \( -name "libminizip*.a" -o -name "minizip*.a" \) | head -n 1)"
          simulator_lib="$(find "${simulator_root}/lib" -type f \( -name "libminizip*.a" -o -name "minizip*.a" \) | head -n 1)"

          if [ -z "${device_lib}" ] || [ -z "${simulator_lib}" ]; then
            echo "Unable to locate minizip iOS static libraries" >&2
            exit 1
          fi

          xcodebuild -create-xcframework \
            -library "${device_lib}" -headers "${device_root}/include" \
            -library "${simulator_lib}" -headers "${simulator_root}/include" \
            -output package-output/minizip-ios.xcframework

          cd package-output
          ditto -c -k --sequesterRsrc --keepParent minizip-ios.xcframework minizip-ios.xcframework.zip

      - name: Upload XCFramework artifact
        uses: actions/upload-artifact@v7
        with:
          name: minizip-ios-xcframework
          path: package-output/minizip-ios.xcframework.zip