opengraph

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 7, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Article

type Article struct {
	OpenGraphObject
	PublishedTime  string   // article:published_time, the time the article was first published
	ModifiedTime   string   // article:modified_time, the time the article was last modified
	ExpirationTime string   // article:expiration_time, the time the article will expire
	Author         []string // article:author, URLs to the authors of the article
	Section        string   // article:section, a high-level section name
	Tag            []string // article:tag, tags of the article
}

Article represents the Open Graph article metadata. For more details about the meaning of the properties see: https://ogp.me/#type_article

Example usage:

Pure struct usage:

// Create an article using pure struct
article := &opengraph.Article{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Article Title",
		URL:         "https://www.example.com/articles/example-article",
		Description: "This is an example article description.",
		Image:       "https://www.example.com/images/article.jpg",
	},
	PublishedTime:  "2024-09-15T09:00:00Z",
	ModifiedTime:   "2024-09-15T10:00:00Z",
	ExpirationTime: "2024-12-31T23:59:59Z",
	Author:         []string{"https://www.example.com/authors/jane-doe"},
	Section:        "Technology",
	Tag:            []string{"tech", "innovation", "example"},
}

Factory method usage:

// Create an article
article := opengraph.NewArticle(
	"Example Article Title",
	"https://www.example.com/articles/example-article",
	"This is an example article description.",
	"https://www.example.com/images/article.jpg",
	"2024-09-15T09:00:00Z",
	"2024-09-15T10:00:00Z",
	"2024-12-31T23:59:59Z",
	[]string{"https://www.example.com/authors/jane-doe"},
	"Technology",
	[]string{"tech", "innovation", "example"},
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@article.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := article.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="article"/>
<meta property="og:title" content="Example Article Title"/>
<meta property="og:url" content="https://www.example.com/articles/example-article"/>
<meta property="og:description" content="This is an example article description."/>
<meta property="og:image" content="https://www.example.com/images/article.jpg"/>
<meta property="article:published_time" content="2024-09-15T09:00:00Z"/>
<meta property="article:modified_time" content="2024-09-15T10:00:00Z"/>
<meta property="article:expiration_time" content="2024-12-31T23:59:59Z"/>
<meta property="article:section" content="Technology"/>
<meta property="article:author" content="https://www.example.com/authors/jane-doe"/>
<meta property="article:tag" content="tech"/>
<meta property="article:tag" content="innovation"/>
<meta property="article:tag" content="example"/>

func NewArticle

func NewArticle(title, url, description, image, publishedTime, modifiedTime, expirationTime string, author []string, section string, tags []string) *Article

NewArticle initializes an Article with the default type "article".

func (*Article) ToGoHTMLMetaTags

func (art *Article) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Audio as `template.HTML` value for Go's `html/template`.

func (*Article) ToMetaTags

func (art *Article) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Article using templ.Component.

type Audio

type Audio struct {
	OpenGraphObject
	Duration  string // music:duration, duration of the audio in seconds
	ArtistURL string // music:musician, URL to the musician or artist
}

Audio represents the Open Graph audio metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create an audio object using pure struct
audio := &opengraph.Audio{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Audio Title",
		URL:         "https://www.example.com/audio/example-audio",
		Description: "This is an example audio description.",
		Image:       "https://www.example.com/images/audio.jpg",
	},
	Duration:  "300", // Duration in seconds
	ArtistURL: "https://www.example.com/musicians/jane-doe",
}

Factory method usage:

// Create an audio object using the factory method
audio := opengraph.NewAudio(
	"Example Audio Title",
	"https://www.example.com/audio/example-audio",
	"This is an example audio description.",
	"https://www.example.com/images/audio.jpg",
	"300", // Duration in seconds
	"https://www.example.com/musicians/jane-doe",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@audio.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := audio.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="music.audio"/>
<meta property="og:title" content="Example Audio Title"/>
<meta property="og:url" content="https://www.example.com/audio/example-audio"/>
<meta property="og:description" content="This is an example audio description."/>
<meta property="og:image" content="https://www.example.com/images/audio.jpg"/>
<meta property="music:duration" content="300"/>
<meta property="music:musician" content="https://www.example.com/musicians/jane-doe"/>

func NewAudio

func NewAudio(title, url, description, image, duration, artistURL string) *Audio

NewAudio initializes an Audio with the default type "music.audio".

func (*Audio) ToGoHTMLMetaTags

func (audio *Audio) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Audio as `template.HTML` value for Go's `html/template`.

func (*Audio) ToMetaTags

func (audio *Audio) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Audio as templ.Component.

type Book

type Book struct {
	OpenGraphObject
	Author      []string // book:author, URLs to the authors of the book
	ISBN        string   // book:isbn, ISBN number of the book
	ReleaseDate string   // book:release_date, the release date of the book
	Tag         []string // book:tag, tags for the book
}

Book represents the Open Graph book metadata. For more details about the meaning of the properties see: https://ogp.me/#type_book

Example usage:

Pure struct usage:

// Create a book using pure struct
book := &opengraph.Book{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Book Title",
		URL:         "https://www.example.com/books/example-book",
		Description: "This is an example book description.",
		Image:       "https://www.example.com/images/book.jpg",
	},
	ISBN:        "978-3-16-148410-0",
	ReleaseDate: "2024-09-15",
	Author:      []string{"https://www.example.com/authors/jane-doe"},
	Tag:         []string{"fiction", "bestseller", "example"},
}

Factory method usage:

// Create a book
book := opengraph.NewBook(
	"Example Book Title",
	"https://www.example.com/books/example-book",
	"This is an example book description.",
	"https://www.example.com/images/book.jpg",
	"978-3-16-148410-0",
	"2024-09-15",
	[]string{"https://www.example.com/authors/jane-doe"},
	[]string{"fiction", "bestseller", "example"},
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@book.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := book.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="book"/>
<meta property="og:title" content="Example Book Title"/>
<meta property="og:url" content="https://www.example.com/books/example-book"/>
<meta property="og:description" content="This is an example book description."/>
<meta property="og:image" content="https://www.example.com/images/book.jpg"/>
<meta property="book:isbn" content="978-3-16-148410-0"/>
<meta property="book:release_date" content="2024-09-15"/>
<meta property="book:author" content="https://www.example.com/authors/jane-doe"/>
<meta property="book:tag" content="fiction"/>
<meta property="book:tag" content="bestseller"/>
<meta property="book:tag" content="example"/>

func NewBook

func NewBook(title, url, description, image, isbn, releaseDate string, author, tags []string) *Book

NewBook initializes a Book with the default type "book".

func (*Book) ToGoHTMLMetaTags

func (book *Book) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Book as `template.HTML` value for Go's `html/template`.

func (*Book) ToMetaTags

func (book *Book) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Book as templ.Component.

type Business

type Business struct {
	OpenGraphObject
	StreetAddress string // business:contact_data:street_address, street address of the business
	Locality      string // business:contact_data:locality, locality or city of the business
	Region        string // business:contact_data:region, region or state of the business
	PostalCode    string // business:contact_data:postal_code, postal code of the business
	Country       string // business:contact_data:country_name, country of the business
	Email         string // business:contact_data:email, email address of the business
	PhoneNumber   string // business:contact_data:phone_number, phone number of the business
	Website       string // business:contact_data:website, website URL of the business
}

Business represents the Open Graph business metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create a business using pure struct
business := &opengraph.Business{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Business",
		URL:         "https://www.example.com/business",
		Description: "This is an example business description.",
		Image:       "https://www.example.com/images/business.jpg",
	},
	StreetAddress: "123 Main St",
	Locality:      "Anytown",
	Region:        "CA",
	PostalCode:    "12345",
	Country:       "USA",
	Email:         "info@example.com",
	PhoneNumber:   "+1-800-555-1234",
	Website:       "https://www.example.com",
}

Factory method usage:

// Create a business
business := opengraph.NewBusiness(
	"Example Business",
	"https://www.example.com/business",
	"This is an example business description.",
	"https://www.example.com/images/business.jpg",
	"123 Main St",
	"Anytown",
	"CA",
	"12345",
	"USA",
	"info@example.com",
	"+1-800-555-1234",
	"https://www.example.com",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@business.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := business.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="business.business"/>
<meta property="og:title" content="Example Business"/>
<meta property="og:url" content="https://www.example.com/business"/>
<meta property="og:description" content="This is an example business description."/>
<meta property="og:image" content="https://www.example.com/images/business.jpg"/>
<meta property="business:contact_data:street_address" content="123 Main St"/>
<meta property="business:contact_data:locality" content="Anytown"/>
<meta property="business:contact_data:region" content="CA"/>
<meta property="business:contact_data:postal_code" content="12345"/>
<meta property="business:contact_data:country_name" content="USA"/>
<meta property="business:contact_data:email" content="info@example.com"/>
<meta property="business:contact_data:phone_number" content="+1-800-555-1234"/>
<meta property="business:contact_data:website" content="https://www.example.com"/>

func NewBusiness

func NewBusiness(title, url, description, image, streetAddress, locality, region, postalCode, country, email, phoneNumber, website string) *Business

NewBusiness initializes a Business with the default type "business.business".

func (*Business) ToGoHTMLMetaTags

func (bus *Business) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Business as `template.HTML` value for Go's `html/template`.

func (*Business) ToMetaTags

func (bus *Business) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Business as templ.Component.

type Event

type Event struct {
	OpenGraphObject
	StartDate string // event:start_date, the start date and time of the event
	EndDate   string // event:end_date, the end date and time of the event
	Location  string // event:location, the location of the event
}

Event represents the Open Graph event metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create an event using pure struct
event := &opengraph.Event{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Event Title",
		URL:         "https://www.example.com/event/example-event",
		Description: "This is an example event description.",
		Image:       "https://www.example.com/images/event.jpg",
	},
	StartDate: "2024-09-15T09:00:00Z",
	EndDate:   "2024-09-15T18:00:00Z",
	Location:  "Anytown Convention Center",
}

Factory method usage:

// Create an event using the factory method
event := opengraph.NewEvent(
	"Example Event Title",
	"https://www.example.com/event/example-event",
	"This is an example event description.",
	"https://www.example.com/images/event.jpg",
	"2024-09-15T09:00:00Z",
	"2024-09-15T18:00:00Z",
	"Anytown Convention Center",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@event.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := event.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="event"/>
<meta property="og:title" content="Example Event Title"/>
<meta property="og:url" content="https://www.example.com/event/example-event"/>
<meta property="og:description" content="This is an example event description."/>
<meta property="og:image" content="https://www.example.com/images/event.jpg"/>
<meta property="event:start_date" content="2024-09-15T09:00:00Z"/>
<meta property="event:end_date" content="2024-09-15T18:00:00Z"/>
<meta property="event:location" content="Anytown Convention Center"/>

func NewEvent

func NewEvent(title, url, description, image, startDate, endDate, location string) *Event

NewEvent initializes an Event with the default type "event".

func (*Event) ToGoHTMLMetaTags

func (e *Event) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Event as `template.HTML` value for Go's `html/template`.

func (*Event) ToMetaTags

func (e *Event) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Event as templ.Component.

type MusicAlbum

type MusicAlbum struct {
	OpenGraphObject
	Musician    []string // music:musician, URLs to the musicians in the album
	ReleaseDate string   // music:release_date, the release date of the album
	Genre       string   // music:genre, genre of the album
}

MusicAlbum represents the Open Graph music album metadata. For more details about the meaning of the properties see: https://ogp.me/#type_music.album

Example usage:

Pure struct usage:

// Create a music album using pure struct
musicAlbum := &opengraph.MusicAlbum{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Album Title",
		URL:         "https://www.example.com/music/album/example-album",
		Description: "This is an example album description.",
		Image:       "https://www.example.com/images/album.jpg",
	},
	Musician:    []string{"https://www.example.com/musicians/jane-doe", "https://www.example.com/musicians/john-doe"},
	ReleaseDate: "2024-09-15",
	Genre:       "Rock",
}

Factory method usage:

// Create a music album
musicAlbum := opengraph.NewMusicAlbum(
	"Example Album Title",
	"https://www.example.com/music/album/example-album",
	"This is an example album description.",
	"https://www.example.com/images/album.jpg",
	"2024-09-15",
	"Rock",
	[]string{"https://www.example.com/musicians/jane-doe", "https://www.example.com/musicians/john-doe"},
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@musicAlbum.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := musicAlbum.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="music.album"/>
<meta property="og:title" content="Example Album Title"/>
<meta property="og:url" content="https://www.example.com/music/album/example-album"/>
<meta property="og:description" content="This is an example album description."/>
<meta property="og:image" content="https://www.example.com/images/album.jpg"/>
<meta property="music:release_date" content="2024-09-15"/>
<meta property="music:genre" content="Rock"/>
<meta property="music:musician" content="https://www.example.com/musicians/jane-doe"/>
<meta property="music:musician" content="https://www.example.com/musicians/john-doe"/>

func NewMusicAlbum

func NewMusicAlbum(title, url, description, image, releaseDate, genre string, musician []string) *MusicAlbum

NewMusicAlbum initializes a MusicAlbum with the default type "music.album".

func (*MusicAlbum) ToGoHTMLMetaTags

func (ma *MusicAlbum) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Music Album as `template.HTML` value for Go's `html/template`.

func (*MusicAlbum) ToMetaTags

func (ma *MusicAlbum) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Music Album as templ.Component.

type MusicPlaylist

type MusicPlaylist struct {
	OpenGraphObject
	SongURLs []string // music:song, URLs to the songs in the playlist
	Duration string   // music:duration, duration of the playlist in seconds
}

MusicPlaylist represents the Open Graph music playlist metadata. For more details about the meaning of the properties see: https://ogp.me/#type_music.playlist

Example usage:

Pure struct usage:

// Create a music playlist using pure struct
musicPlaylist := &opengraph.MusicPlaylist{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Playlist Title",
		URL:         "https://www.example.com/music/playlist/example-playlist",
		Description: "This is an example playlist description.",
		Image:       "https://www.example.com/images/playlist.jpg",
	},
	SongURLs: []string{"https://www.example.com/musicians/jane-doe", "https://www.example.com/musicians/john-doe"},
	Duration: "60",
}

Factory method usage:

// Create a music playlist
musicPlaylist := opengraph.NewMusicPlaylist(
	"Example Playlist Title",
	"https://www.example.com/music/playlist/example-playlist",
	"This is an example playlist description.",
	"https://www.example.com/images/playlist.jpg",
	[]string{"https://www.example.com/musicians/jane-doe", "https://www.example.com/musicians/john-doe"},
	"60",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@musicPlaylist.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := musicAlbum.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="music.playlist"/>
<meta property="og:title" content="Example Playlist Title"/>
<meta property="og:url" content="https://www.example.com/music/playlist/example-playlist"/>
<meta property="og:description" content="This is an example playlist description."/>
<meta property="og:image" content="https://www.example.com/images/playlist.jpg"/>
<meta property="music:song" content="https://www.example.com/musicians/jane-doe"/>
<meta property="music:song" content="https://www.example.com/musicians/john-doe"/>
<meta property="music:duration" content="60"/>

func NewMusicPlaylist

func NewMusicPlaylist(title, url, description, image string, songURLs []string, duration string) *MusicPlaylist

NewMusicPlaylist initializes a MusicPlaylist with the default type "music.playlist".

func (*MusicPlaylist) ToGoHTMLMetaTags

func (mp *MusicPlaylist) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Music Playlist as `template.HTML` value for Go's `html/template`.

func (*MusicPlaylist) ToMetaTags

func (mp *MusicPlaylist) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Music Playlist as templ.Component.

type MusicRadioStation

type MusicRadioStation struct {
	OpenGraphObject
}

MusicRadioStation represents the Open Graph music radio station metadata. For more details about the meaning of the properties see: https://ogp.me/#type_music.radio_station

Example usage:

Pure struct usage:

// Create a music radio station using pure struct
musicRadioStation := &opengraph.MusicRadioStation{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Radio Station",
		URL:         "https://www.example.com/music/radio/example-radio",
		Description: "This is an example radio station description.",
		Image:       "https://www.example.com/images/radio.jpg",
	},
}

Factory method usage:

// Create a music radio station using the factory method
musicRadioStation := opengraph.NewMusicRadioStation(
	"Example Radio Station",
	"https://www.example.com/music/radio/example-radio",
	"This is an example radio station description.",
	"https://www.example.com/images/radio.jpg",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@musicRadioStation.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := musicRadioStation.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="music.radio_station"/>
<meta property="og:title" content="Example Radio Station"/>
<meta property="og:url" content="https://www.example.com/music/radio/example-radio"/>
<meta property="og:description" content="This is an example radio station description."/>
<meta property="og:image" content="https://www.example.com/images/radio.jpg"/>

func NewMusicRadioStation

func NewMusicRadioStation(title, url, description, image string) *MusicRadioStation

NewMusicRadioStation initializes a MusicRadioStation with the default type "music.radio_station".

func (*MusicRadioStation) ToGoHTMLMetaTags

func (mrs *MusicRadioStation) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Music Radio Station as `template.HTML` value for Go's `html/template`.

func (*MusicRadioStation) ToMetaTags

func (mrs *MusicRadioStation) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Music Radio Station as templ.Component.

type MusicSong

type MusicSong struct {
	OpenGraphObject
	Duration     string   // music:duration, duration of the song in seconds
	AlbumURL     string   // music:album, URL to the album
	MusicianURLs []string // music:musician, URLs to the musicians
}

MusicSong represents the Open Graph music song metadata. For more details about the meaning of the properties see: https://ogp.me/#type_music.song

Example usage:

Pure struct usage:

// Create a music song using pure struct
musicSong := &opengraph.MusicSong{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Song Title",
		URL:         "https://www.example.com/music/song/example-song",
		Description: "This is an example song description.",
		Image:       "https://www.example.com/images/song.jpg",
	},
	Duration: "240", // Duration in seconds
	AlbumURL: "https://www.example.com/music/album/example-album",
	MusicianURLs: []string{
		"https://www.example.com/musicians/jane-doe",
		"https://www.example.com/musicians/john-doe",
	},
}

Factory method usage:

// Create a music song using the factory method
musicSong := opengraph.NewMusicSong(
	"Example Song Title",
	"https://www.example.com/music/song/example-song",
	"This is an example song description.",
	"https://www.example.com/images/song.jpg",
	"240", // Duration in seconds
	"https://www.example.com/music/album/example-album",
	[]string{"https://www.example.com/musicians/jane-doe", "https://www.example.com/musicians/john-doe"},
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@musicSong.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := musicSong.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="music.song"/>
<meta property="og:title" content="Example Song Title"/>
<meta property="og:url" content="https://www.example.com/music/song/example-song"/>
<meta property="og:description" content="This is an example song description."/>
<meta property="og:image" content="https://www.example.com/images/song.jpg"/>
<meta property="music:duration" content="240"/>
<meta property="music:album" content="https://www.example.com/music/album/example-album"/>
<meta property="music:musician" content="https://www.example.com/musicians/jane-doe"/>
<meta property="music:musician" content="https://www.example.com/musicians/john-doe"/>

func NewMusicSong

func NewMusicSong(title, url, description, image, duration, albumURL string, musicianURLs []string) *MusicSong

NewMusicSong initializes a MusicSong with the default type "music.song".

func (*MusicSong) ToGoHTMLMetaTags

func (ms *MusicSong) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Music Song as `template.HTML` value for Go's `html/template`.

func (*MusicSong) ToMetaTags

func (ms *MusicSong) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Music Song as templ.Component.

type OpenGraphObject

type OpenGraphObject struct {
	Type        string // og:type, the type of the object
	Title       string // og:title, the title of the object
	URL         string // og:url, the canonical URL of the object
	Description string // og:description, a brief description of the object
	Image       string // og:image, URL to the image of the object
}

OpenGraphObject represents common Open Graph metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

type Place

type Place struct {
	OpenGraphObject
	Latitude      float64 // place:location:latitude, latitude of the place
	Longitude     float64 // place:location:longitude, longitude of the place
	StreetAddress string  // place:contact_data:street_address, street address of the place
	Locality      string  // place:contact_data:locality, locality or city of the place
	Region        string  // place:contact_data:region, region or state of the place
	PostalCode    string  // place:contact_data:postal_code, postal code of the place
	Country       string  // place:contact_data:country_name, country of the place
}

Place represents the Open Graph place metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create a place using pure struct
place := &opengraph.Place{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Place",
		URL:         "https://www.example.com/place/example-place",
		Description: "This is an example place description.",
		Image:       "https://www.example.com/images/place.jpg",
	},
	Latitude:  40.7128, // Example latitude
	Longitude: -74.0060, // Example longitude
	StreetAddress: "123 Main St",
	Locality: "New York",
	Region: "NY",
	PostalCode: "10001",
	Country: "USA",
}

Factory method usage:

// Create a place using the factory method
place := opengraph.NewPlace(
	"Example Place",
	"https://www.example.com/place/example-place",
	"This is an example place description.",
	"https://www.example.com/images/place.jpg",
	40.7128,   // Latitude
	-74.0060,  // Longitude
	"123 Main St",
	"New York",
	"NY",
	"10001",
	"USA",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@place.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := place.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="place"/>
<meta property="og:title" content="Example Place"/>
<meta property="og:url" content="https://www.example.com/place/example-place"/>
<meta property="og:description" content="This is an example place description."/>
<meta property="og:image" content="https://www.example.com/images/place.jpg"/>
<meta property="place:location:latitude" content="40.7128"/>
<meta property="place:location:longitude" content="-74.0060"/>
<meta property="place:contact_data:street_address" content="123 Main St"/>
<meta property="place:contact_data:locality" content="New York"/>
<meta property="place:contact_data:region" content="NY"/>
<meta property="place:contact_data:postal_code" content="10001"/>
<meta property="place:contact_data:country_name" content="USA"/>

func NewPlace

func NewPlace(title, url, description, image string, latitude, longitude float64, streetAddress, locality, region, postalCode, country string) *Place

NewPlace initializes a Place with the default type "place".

func (*Place) ToGoHTMLMetaTags

func (place *Place) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Place as `template.HTML` value for Go's `html/template`.

func (*Place) ToMetaTags

func (place *Place) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Place as templ.Component.

type Product

type Product struct {
	OpenGraphObject
	Price         string // product:price:amount, price of the product
	PriceCurrency string // product:price:currency, currency of the price
}

Product represents the Open Graph product metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create a product using pure struct
product := &opengraph.Product{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Product",
		URL:         "https://www.example.com/product/example-product",
		Description: "This is an example product description.",
		Image:       "https://www.example.com/images/product.jpg",
	},
	Price:        "29.99",
	PriceCurrency: "USD",
}

Factory method usage:

// Create a product
product := opengraph.NewProduct(
	"Example Product",
	"https://www.example.com/product/example-product",
	"This is an example product description.",
	"https://www.example.com/images/product.jpg",
	"29.99",
	"USD",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@product.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := product.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="product"/>
<meta property="og:title" content="Example Product"/>
<meta property="og:url" content="https://www.example.com/product/example-product"/>
<meta property="og:description" content="This is an example product description."/>
<meta property="og:image" content="https://www.example.com/images/product.jpg"/>
<meta property="product:price:amount" content="29.99"/>
<meta property="product:price:currency" content="USD"/>

func NewProduct

func NewProduct(title, url, description, image, price, priceCurrency string) *Product

NewProduct initializes a Product with the default type "product".

func (*Product) ToGoHTMLMetaTags

func (p *Product) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Product as `template.HTML` value for Go's `html/template`.

func (*Product) ToMetaTags

func (p *Product) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Product as templ.Component.

type ProductGroup

type ProductGroup struct {
	OpenGraphObject
	Products []string // product:group_item, URLs to individual products in the group
}

ProductGroup represents the Open Graph product group metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create a product group using pure struct
productGroup := &opengraph.ProductGroup{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Product Group",
		URL:         "https://www.example.com/product-group/example-product-group",
		Description: "This is an example product group description.",
		Image:       "https://www.example.com/images/product-group.jpg",
	},
	Products: []string{
		"https://www.example.com/product/product-1",
		"https://www.example.com/product/product-2",
	},
}

Factory method usage:

// Create a product group using the factory method
productGroup := opengraph.NewProductGroup(
	"Example Product Group",
	"https://www.example.com/product-group/example-product-group",
	"This is an example product group description.",
	"https://www.example.com/images/product-group.jpg",
	[]string{
		"https://www.example.com/product/product-1",
		"https://www.example.com/product/product-2",
	},
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@productGroup.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := productGroup.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="product.group"/>
<meta property="og:title" content="Example Product Group"/>
<meta property="og:url" content="https://www.example.com/product-group/example-product-group"/>
<meta property="og:description" content="This is an example product group description."/>
<meta property="og:image" content="https://www.example.com/images/product-group.jpg"/>
<meta property="product:group_item" content="https://www.example.com/product/product-1"/>
<meta property="product:group_item" content="https://www.example.com/product/product-2"/>

func NewProductGroup

func NewProductGroup(title, url, description, image string, products []string) *ProductGroup

NewProductGroup initializes a ProductGroup with the default type "product.group".

func (*ProductGroup) ToGoHTMLMetaTags

func (pg *ProductGroup) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Product Group as `template.HTML` value for Go's `html/template`.

func (*ProductGroup) ToMetaTags

func (pg *ProductGroup) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Product Group as templ.Component.

type Profile

type Profile struct {
	OpenGraphObject
	FirstName string // profile:first_name, first name
	LastName  string // profile:last_name, last name
	Username  string // profile:username, username
	Gender    string // profile:gender, gender
}

Profile represents the Open Graph profile metadata. For more details about the meaning of the properties see: https://ogp.me/#type_profile

Example usage:

Pure struct usage:

// Create a profile using pure struct
profile := &opengraph.Profile{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "John Doe",
		URL:         "https://www.example.com/profile/johndoe",
		Description: "This is John Doe's profile.",
		Image:       "https://www.example.com/images/profile.jpg",
	},
	FirstName: "John",
	LastName:  "Doe",
	Username:  "johndoe",
	Gender:    "male",
}

Factory method usage:

// Create a profile
profile := opengraph.NewProfile(
	"John Doe",
	"John",
	"Doe",
	"johndoe",
	"male",
	"https://www.example.com/profile/johndoe",
	"This is John Doe's profile.",
	"https://www.example.com/images/profile.jpg",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@profile.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := profile.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="profile"/>
<meta property="og:title" content="John Doe"/>
<meta property="profile:first_name" content="John"/>
<meta property="profile:last_name" content="Doe"/>
<meta property="profile:username" content="johndoe"/>
<meta property="profile:gender" content="male"/>
<meta property="og:url" content="https://www.example.com/profile/johndoe"/>
<meta property="og:description" content="This is John Doe's profile."/>
<meta property="og:image" content="https://www.example.com/images/profile.jpg"/>

func NewProfile

func NewProfile(title string, firstName string, lastName string, username string, gender string, url string, description string, image string) *Profile

NewProfile initializes an OpenGraphProfile with the default type "profile".

func (*Profile) ToGoHTMLMetaTags

func (p *Profile) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Profile as `template.HTML` value for Go's `html/template`.

func (*Profile) ToMetaTags

func (p *Profile) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Profile as templ.Component.

type Restaurant

type Restaurant struct {
	OpenGraphObject
	StreetAddress  string // place:contact_data:street_address, street address of the restaurant
	Locality       string // place:contact_data:locality, locality or city of the restaurant
	Region         string // place:contact_data:region, region or state of the restaurant
	PostalCode     string // place:contact_data:postal_code, postal code of the restaurant
	Country        string // place:contact_data:country_name, country of the restaurant
	Phone          string // place:contact_data:phone_number, phone number of the restaurant
	MenuURL        string // restaurant:menu, URL to the restaurant's menu
	ReservationURL string // restaurant:reservation, URL to the reservation page
}

Restaurant represents the Open Graph restaurant metadata. For more details about the meaning of the properties see: https://ogp.me/#metadata

Example usage:

Pure struct usage:

// Create a restaurant using pure struct
restaurant := &opengraph.Restaurant{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Restaurant",
		URL:         "https://www.example.com/restaurant/example-restaurant",
		Description: "This is an example restaurant description.",
		Image:       "https://www.example.com/images/restaurant.jpg",
	},
	StreetAddress: "123 Food Street",
	Locality:      "Gourmet City",
	Region:        "CA",
	PostalCode:    "12345",
	Country:       "USA",
	Phone:         "+1-800-FOOD-123",
	MenuURL:       "https://www.example.com/menu",
	ReservationURL: "https://www.example.com/reservations",
}

Factory method usage:

// Create a restaurant using the factory method
restaurant := opengraph.NewRestaurant(
	"Example Restaurant",
	"https://www.example.com/restaurant/example-restaurant",
	"This is an example restaurant description.",
	"https://www.example.com/images/restaurant.jpg",
	"123 Food Street",
	"Gourmet City",
	"CA",
	"12345",
	"USA",
	"+1-800-FOOD-123",
	"https://www.example.com/menu",
	"https://www.example.com/reservations",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@restaurant.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := restaurant.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="restaurant"/>
<meta property="og:title" content="Example Restaurant"/>
<meta property="og:url" content="https://www.example.com/restaurant/example-restaurant"/>
<meta property="og:description" content="This is an example restaurant description."/>
<meta property="og:image" content="https://www.example.com/images/restaurant.jpg"/>
<meta property="place:contact_data:street_address" content="123 Food Street"/>
<meta property="place:contact_data:locality" content="Gourmet City"/>
<meta property="place:contact_data:region" content="CA"/>
<meta property="place:contact_data:postal_code" content="12345"/>
<meta property="place:contact_data:country_name" content="USA"/>
<meta property="place:contact_data:phone_number" content="+1-800-FOOD-123"/>
<meta property="restaurant:menu" content="https://www.example.com/menu"/>
<meta property="restaurant:reservation" content="https://www.example.com/reservations"/>

func NewRestaurant

func NewRestaurant(title, url, description, image, streetAddress, locality, region, postalCode, country, phone, menuURL, reservationURL string) *Restaurant

NewRestaurant initializes a Restaurant with the default type "restaurant".

func (*Restaurant) ToGoHTMLMetaTags

func (restaurant *Restaurant) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Restaurant as `template.HTML` value for Go's `html/template`.

func (*Restaurant) ToMetaTags

func (restaurant *Restaurant) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Restaurant as templ.Component.

type Video

type Video struct {
	OpenGraphObject
	Duration    string   // video:duration, duration of the video in seconds
	ActorURLs   []string // video:actor, URLs to the actors in the video
	DirectorURL string   // video:director, URL to the director of the video
	ReleaseDate string   // video:release_date, the release date of the video
}

Video represents the Open Graph video metadata. For more details about the meaning of the properties see: https://ogp.me/#type_video Example usage:

Pure struct usage:

// Create a video using pure struct
video := &opengraph.Video{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Video",
		URL:         "https://www.example.com/video/example-video",
		Description: "This is an example video description.",
		Image:       "https://www.example.com/images/video.jpg",
	},
	Duration: "300", // Duration in seconds
	ActorURLs: []string{
		"https://www.example.com/actors/jane-doe",
		"https://www.example.com/actors/john-doe",
	},
	DirectorURL: "https://www.example.com/directors/jane-director",
	ReleaseDate: "2024-09-15",
}

Factory method usage:

// Create a video using the factory method
video := opengraph.NewVideo(
	"Example Video",
	"https://www.example.com/video/example-video",
	"This is an example video description.",
	"https://www.example.com/images/video.jpg",
	"300", // Duration in seconds
	[]string{"https://www.example.com/actors/jane-doe", "https://www.example.com/actors/john-doe"},
	"https://www.example.com/directors/jane-director",
	"2024-09-15",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@video.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := video.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="video.movie"/>
<meta property="og:title" content="Example Video"/>
<meta property="og:url" content="https://www.example.com/video/example-video"/>
<meta property="og:description" content="This is an example video description."/>
<meta property="og:image" content="https://www.example.com/images/video.jpg"/>
<meta property="video:duration" content="300"/>
<meta property="video:actor" content="https://www.example.com/actors/jane-doe"/>
<meta property="video:actor" content="https://www.example.com/actors/john-doe"/>
<meta property="video:director" content="https://www.example.com/directors/jane-director"/>
<meta property="video:release_date" content="2024-09-15"/>

func NewVideo

func NewVideo(title, url, description, image, duration string, actorURLs []string, directorURL, releaseDate string) *Video

NewVideo initializes a Video with the default type "video.movie".

func (*Video) ToGoHTMLMetaTags

func (video *Video) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Video as `template.HTML` value for Go's `html/template`.

func (*Video) ToMetaTags

func (video *Video) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Video using templ.Component.

type VideoEpisode

type VideoEpisode struct {
	OpenGraphObject
	SeriesURL     string   // video:series, URL to the video series
	Duration      string   // video:duration, duration of the episode in seconds
	ActorURLs     []string // video:actor, URLs to the actors in the episode
	DirectorURL   string   // video:director, URL to the director of the episode
	ReleaseDate   string   // video:release_date, the release date of the episode
	EpisodeNumber int      // video:episode, the episode number in the series
}

VideoEpisode represents the Open Graph video episode metadata. For more details about the meaning of the properties see: https://ogp.me/#type_video.episode

Example usage:

Pure struct usage:

// Create a video episode using pure struct
videoEpisode := &opengraph.VideoEpisode{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Video Episode",
		URL:         "https://www.example.com/video/episode/example-episode",
		Description: "This is an example video episode description.",
		Image:       "https://www.example.com/images/episode.jpg",
	},
	SeriesURL:   "https://www.example.com/video/series/example-series",
	Duration:    "1800", // Duration in seconds
	ActorURLs:   []string{"https://www.example.com/actors/jane-doe", "https://www.example.com/actors/john-doe"},
	DirectorURL: "https://www.example.com/directors/jane-director",
	ReleaseDate: "2024-09-15",
	EpisodeNumber: 1,
}

Factory method usage:

// Create a video episode using the factory method
videoEpisode := opengraph.NewVideoEpisode(
	"Example Video Episode",
	"https://www.example.com/video/episode/example-episode",
	"This is an example video episode description.",
	"https://www.example.com/images/episode.jpg",
	"1800", // Duration in seconds
	"https://www.example.com/video/series/example-series",
	[]string{"https://www.example.com/actors/jane-doe", "https://www.example.com/actors/john-doe"},
	"https://www.example.com/directors/jane-director",
	"2024-09-15",
	1, // Episode number
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@videoEpisode.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := videoEpisode.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="video.episode"/>
<meta property="og:title" content="Example Video Episode"/>
<meta property="og:url" content="https://www.example.com/video/episode/example-episode"/>
<meta property="og:description" content="This is an example video episode description."/>
<meta property="og:image" content="https://www.example.com/images/episode.jpg"/>
<meta property="video:duration" content="1800"/>
<meta property="video:actor" content="https://www.example.com/actors/jane-doe"/>
<meta property="video:actor" content="https://www.example.com/actors/john-doe"/>
<meta property="video:director" content="https://www.example.com/directors/jane-director"/>
<meta property="video:release_date" content="2024-09-15"/>
<meta property="video:series" content="https://www.example.com/video/series/example-series"/>
<meta property="video:episode" content="1"/>

func NewVideoEpisode

func NewVideoEpisode(title, url, description, image, duration, seriesURL string, actorURLs []string, directorURL, releaseDate string, episodeNumber int) *VideoEpisode

NewVideoEpisode initializes a VideoEpisode with the default type "video.episode".

func (*VideoEpisode) ToGoHTMLMetaTags

func (ve *VideoEpisode) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Video Episode as `template.HTML` value for Go's `html/template`.

func (*VideoEpisode) ToMetaTags

func (ve *VideoEpisode) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Video Episode as templ.Component.

type VideoMovie

type VideoMovie struct {
	OpenGraphObject
	Duration    string   // video:duration, duration of the movie in seconds
	ActorURLs   []string // video:actor, URLs to the actors in the movie
	DirectorURL string   // video:director, URL to the director of the movie
	ReleaseDate string   // video:release_date, the release date of the movie
}

VideoMovie represents the Open Graph video movie metadata. For more details about the meaning of the properties see: https://ogp.me/#type_video.movie

Example usage:

Pure struct usage:

// Create a video movie using pure struct
videoMovie := &opengraph.VideoMovie{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Movie",
		URL:         "https://www.example.com/video/movie/example-movie",
		Description: "This is an example movie description.",
		Image:       "https://www.example.com/images/movie.jpg",
	},
	Duration:    "7200", // Duration in seconds (2 hours)
	ActorURLs:   []string{"https://www.example.com/actors/jane-doe", "https://www.example.com/actors/john-doe"},
	DirectorURL: "https://www.example.com/directors/jane-director",
	ReleaseDate: "2024-09-15",
}

Factory method usage:

// Create a video movie using the factory method
videoMovie := opengraph.NewVideoMovie(
	"Example Movie",
	"https://www.example.com/video/movie/example-movie",
	"This is an example movie description.",
	"https://www.example.com/images/movie.jpg",
	"7200", // Duration in seconds (2 hours)
	[]string{"https://www.example.com/actors/jane-doe", "https://www.example.com/actors/john-doe"},
	"https://www.example.com/directors/jane-director",
	"2024-09-15",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@videoMovie.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := videoMovie.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="video.movie"/>
<meta property="og:title" content="Example Movie"/>
<meta property="og:url" content="https://www.example.com/video/movie/example-movie"/>
<meta property="og:description" content="This is an example movie description."/>
<meta property="og:image" content="https://www.example.com/images/movie.jpg"/>
<meta property="video:duration" content="7200"/>
<meta property="video:actor" content="https://www.example.com/actors/jane-doe"/>
<meta property="video:actor" content="https://www.example.com/actors/john-doe"/>
<meta property="video:director" content="https://www.example.com/directors/jane-director"/>
<meta property="video:release_date" content="2024-09-15"/>

func NewVideoMovie

func NewVideoMovie(title, url, description, image, duration string, actorURLs []string, directorURL, releaseDate string) *VideoMovie

NewVideoMovie initializes a VideoMovie with the default type "video.movie".

func (*VideoMovie) ToGoHTMLMetaTags

func (vm *VideoMovie) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph Video Movie as `template.HTML` value for Go's `html/template`.

func (*VideoMovie) ToMetaTags

func (vm *VideoMovie) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph Video Movie as templ.Component.

type WebSite

type WebSite struct {
	OpenGraphObject
}

WebSite represents the Open Graph website metadata. For more details about the meaning of the properties see: https://ogp.me/#type_website

Example usage:

Pure struct usage:

// Create a website using pure struct
website := &opengraph.WebSite{
	OpenGraphObject: opengraph.OpenGraphObject{
		Title:       "Example Website",
		URL:         "https://www.example.com",
		Description: "This is an example website description.",
		Image:       "https://www.example.com/images/logo.jpg",
	},
}

Factory method usage:

// Create a website using the factory method
website := opengraph.NewWebSite(
	"Example Website",
	"https://www.example.com",
	"This is an example website description.",
	"https://www.example.com/images/logo.jpg",
)

// Rendering the HTML meta tags using templ:

templ Page() {
	@website.ToMetaTgs()
}

// Rendering the HTML meta tags as `template.HTML` value:

metaTagsHtml := website.ToGoHTMLMetaTgs()

Expected output:

<meta property="og:type" content="website"/>
<meta property="og:title" content="Example Website"/>
<meta property="og:url" content="https://www.example.com"/>
<meta property="og:description" content="This is an example website description."/>
<meta property="og:image" content="https://www.example.com/images/logo.jpg"/>

func NewWebSite

func NewWebSite(title, url, description, image string) *WebSite

NewWebSite initializes a WebSite with the default type "website".

func (*WebSite) ToGoHTMLMetaTags

func (ws *WebSite) ToGoHTMLMetaTags() (template.HTML, error)

ToGoHTMLMetaTags generates the HTML meta tags for the Open Graph WebSite as `template.HTML` value for Go's `html/template`.

func (*WebSite) ToMetaTags

func (ws *WebSite) ToMetaTags() templ.Component

ToMetaTags generates the HTML meta tags for the Open Graph WebSite using templ.Component.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL