This is the code to wait until the page is completely loaded using cdp package.

pdfgenerator.service.go

package reportserv

import (
	"context"
	"fmt"
	"report-server/models"
	"sync"
	"time"

	"github.com/mafredri/cdp"
	"github.com/mafredri/cdp/devtool"
	"github.com/mafredri/cdp/protocol/page"
	"github.com/mafredri/cdp/protocol/target"
	"github.com/mafredri/cdp/rpcc"
)

var printToPDFMutex sync.Mutex

func CreatePDFReport(pdfReportRequest models.PDFReportRequest) error {

	fmt.Println("===================")
	const timeout = 30 * time.Second
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()

	// Initialize cdp
	c, conn, pt, err := initCDP(ctx, timeout)
	if err != nil {
		return err
	}
	defer conn.Close() // Leaving connections open will leak memory.

	// Close the target when done
	// (In development, skip this step to leave tabs open!)
	closeTargetArgs := target.NewCloseTargetArgs(target.ID(pt.ID))
	defer c.Target.CloseTarget(ctx, closeTargetArgs)

	// Enable lifecycle events...
	err = c.Page.SetLifecycleEventsEnabled(ctx, page.NewSetLifecycleEventsEnabledArgs(true))
	if err != nil {
		return err
	}
	events, err := c.Page.LifecycleEvent(ctx)
	if err != nil {
		return err
	}
	defer events.Close()

	// Enable events on the Page domain, it's often preferrable to create
	// event clients before enabling events so that we don't miss any.
	if err = c.Page.Enable(ctx); err != nil {
		return err
	}

	// Create the Navigate arguments with the optional Referrer field set.
	// url := "https://www.google.com"
	navArgs := page.NewNavigateArgs(pdfReportRequest.Url)
	nav, err := c.Page.Navigate(ctx, navArgs)
	if err != nil {
		return err
	}

	for {
		ev, err := events.Recv()
		if err != nil {
			return err
		}
		fmt.Println(ev.Name)
		if ev.Name == "networkIdle" {
			break
		}
	}

	fmt.Printf("Page loaded with frame ID: %s\n", nav.FrameID)

	return err
}

func initCDP(ctx context.Context, timeout time.Duration) (*cdp.Client, *rpcc.Conn, *devtool.Target, error) {
	// Use the DevTools HTTP/JSON API to manage targets (e.g. pages, webworkers).
	devt := devtool.New("http://127.0.0.1:9222")
	pt, err := devt.Create(ctx)
	if err != nil {
		return nil, nil, nil, err
	}

	// Initiate a new RPC connection to the Chrome DevTools Protocol target.
	conn, err := rpcc.DialContext(ctx, pt.WebSocketDebuggerURL)
	if err != nil {
		return nil, nil, nil, err
	}

	c := cdp.NewClient(conn)
	return c, conn, pt, nil
}

report.model.go

package models

import "github.com/mafredri/cdp/protocol/page"

// ReportRequest store the report request information
type PDFReportRequest struct {
	Url           string              `json:"url"`
	LayoutOptions page.PrintToPDFArgs `json:"layoutOptions,omitempty"`
}

The idea is to generate a pdf file of a web page using cdp. These files are part of a golang service.