config

Documentation

Overview

Package config contains the configuration structs for the Cogent Core tool.

Index

• Variables
• func ArchSupported(arch string) error
• func LinkerFlags(c *Config) string
• func OSSupported(os string) error
• type Build
• type Config
  • func (c *Config) OnConfig(cmd string) error
• type Generate
• type Log
• type Pack
• type Platform
  • func (p *Platform) SetString(platform string) error
  • func (p Platform) String() string
• type Types
  • func TypesValues() []Types
  • func (i Types) Desc() string
  • func (i Types) Int64() int64
  • func (i Types) MarshalText() ([]byte, error)
  • func (i *Types) SetInt64(in int64)
  • func (i *Types) SetString(s string) error
  • func (i Types) String() string
  • func (i *Types) UnmarshalText(text []byte) error
  • func (i Types) Values() []enums.Enum
• type Web

Variables

var ArchsForOS = map[string][]string{
	"darwin":  {"386", "amd64", "arm", "arm64"},
	"windows": {"386", "amd64", "arm", "arm64"},
	"linux":   {"386", "amd64", "arm", "arm64"},
	"android": {"386", "amd64", "arm", "arm64"},
	"ios":     {"arm64"},
}

ArchsForOS returns contains all of the architectures supported for each operating system.

var SupportedArch = map[string]bool{
	"386":         true,
	"amd64":       true,
	"amd64p32":    true,
	"arm":         true,
	"armbe":       true,
	"arm64":       true,
	"arm64be":     true,
	"loong64":     false,
	"mips":        false,
	"mipsle":      false,
	"mips64":      false,
	"mips64le":    false,
	"mips64p32":   false,
	"mips64p32le": false,
	"ppc":         false,
	"ppc64":       false,
	"ppc64le":     false,
	"riscv":       false,
	"riscv64":     false,
	"s390":        false,
	"s390x":       false,
	"sparc":       false,
	"sparc64":     false,
	"wasm":        true,
}

SupportedArch is a map containing all computer architectures and whether they are supported by Cogent Core.

var SupportedOS = map[string]bool{
	"aix":       false,
	"android":   true,
	"darwin":    true,
	"dragonfly": false,
	"freebsd":   false,
	"hurd":      false,
	"illumos":   false,
	"ios":       true,
	"web":       true,
	"linux":     true,
	"nacl":      false,
	"netbsd":    false,
	"openbsd":   false,
	"plan9":     false,
	"solaris":   false,
	"wasip1":    false,
	"windows":   true,
	"zos":       false,
}

SupportedOS is a map containing all operating systems and whether they are supported by Cogent Core.

Functions

func ArchSupported

func ArchSupported(arch string) error

ArchSupported determines whether the given architecture is supported by Cogent Core. If it is, it returns nil. If it isn't, it also returns an error detailing the issue with the architecture (not found or not supported).

func LinkerFlags

func LinkerFlags(c *Config) string

LinkerFlags returns the ld linker flags that specify the app and core version, the app about information, and the app icon.

func OSSupported

func OSSupported(os string) error

OSSupported determines whether the given operating system is supported by Cogent Core. If it is, it returns nil. If it isn't, it returns an error detailing the issue with the operating system (not found or not supported).

Types

type Build

type Build struct {

	// the target platforms to build executables for
	Target []Platform `flag:"t,target" posarg:"0" required:"-" save:"-"`

	// whether to build/run the app in debug mode, which sets
	// the "debug" tag when building. On iOS and Android, this
	// also prints the program output.
	Debug bool `flag:"d,debug"`

	// the minimum version of the iOS SDK to compile against
	IOSVersion string `default:"13.0"`

	// the minimum supported Android SDK (uses-sdk/android:minSdkVersion in AndroidManifest.xml)
	AndroidMinSDK int `default:"23" min:"23"`

	// the target Android SDK version (uses-sdk/android:targetSdkVersion in AndroidManifest.xml)
	AndroidTargetSDK int `default:"29"`
}

type Config

type Config struct {

	// Name is the user-friendly name of the project.
	// The default is based on the current directory name.
	Name string

	// NamePrefix is the prefix to add to the default name of the project
	// and any projects nested below it. A separating space is automatically included.
	NamePrefix string

	// ID is the bundle / package ID to use for the project
	// (required for building for mobile platforms and packaging
	// for desktop platforms). It is typically in the format com.org.app
	// (eg: com.cogent.mail). It defaults to com.parentDirectory.currentDirectory.
	ID string

	// About is the about information for the project, which can be viewed via
	// the "About" button in the app bar. It is also used when packaging the app.
	About string

	// the version of the project to release
	Version string `cmd:"release" posarg:"0" save:"-"`

	// Pages, if specified, indicates that the app has core
	// pages located at this directory. If so, markdown code blocks with
	// language Go (must be uppercase, as that indicates that is an
	// "exported" example) will be collected and stored at pagegen.go, and
	// a directory tree will be made for all of the pages when building
	// for platform web.
	Pages string

	// the configuration options for the build, install, run, and pack commands
	Build Build `cmd:"build,install,run,pack"`

	// the configuration information for the pack command
	Pack Pack `cmd:"pack"`

	// the configuration information for web
	Web Web `cmd:"build,install,run,pack"`

	// the configuration options for the log command
	Log Log `cmd:"log"`

	// the configuration options for the generate command
	Generate Generate `cmd:"generate"`
}

Config is the main config struct that contains all of the configuration options for the Cogent Core command line tool.

func (*Config) OnConfig

func (c *Config) OnConfig(cmd string) error

type Generate

type Generate struct {

	// the enum generation configuration options passed to enumgen
	Enumgen enumgen.Config

	// the generation configuration options passed to typegen
	Typegen typegen.Config

	// the source directory to run generate on (can be multiple through ./...)
	Dir string `default:"." posarg:"0" required:"-" nest:"-"`
}

type Log

type Log struct {

	// the target platform to view the logs for (ios or android)
	Target string `default:"android"`

	// whether to keep the previous log messages or clear them
	Keep bool `default:"false"`

	// messages not generated from your app equal to or above this log level will be shown
	All string `default:"F"`
}

type Pack

type Pack struct {

	// whether to build a .dmg file on macOS in addition to a .app file.
	// This is automatically disabled for the install command.
	DMG bool `default:"true"`
}

type Platform

type Platform struct {
	OS   string
	Arch string
}

Platform is a platform with an operating system and an architecture

func (*Platform) SetString

func (p *Platform) SetString(platform string) error

SetString sets the platform from the given string of format os[/arch]

func (Platform) String

func (p Platform) String() string

String returns the platform as a string in the form "os/arch"

type Types

type Types int32 //enums:enum -trim-prefix Type

Types is an enum with all of the possible types of packages.

const (
	// TypeApp is an executable app
	TypeApp Types = iota
	// TypeLibrary is an importable library
	TypeLibrary
)

const TypesN Types = 2

TypesN is the highest valid value for type Types, plus one.

func TypesValues

func TypesValues() []Types

TypesValues returns all possible values for the type Types.

func (Types) Desc

func (i Types) Desc() string

Desc returns the description of the Types value.

func (Types) Int64

func (i Types) Int64() int64

Int64 returns the Types value as an int64.

func (Types) MarshalText

func (i Types) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface.

func (*Types) SetInt64

func (i *Types) SetInt64(in int64)

SetInt64 sets the Types value from an int64.

func (*Types) SetString

func (i *Types) SetString(s string) error

SetString sets the Types value from its string representation, and returns an error if the string is invalid.

func (Types) String

func (i Types) String() string

String returns the string representation of this Types value.

func (*Types) UnmarshalText

func (i *Types) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface.

func (Types) Values

func (i Types) Values() []enums.Enum

Values returns all possible values for the type Types.

type Web

type Web struct {

	// Port is the port to serve the page at when using the serve command.
	Port string `default:"8080"`

	// RandomVersion is whether to make the app worker version random.
	// It is enabled by default and should be kept on for easy deployment.
	RandomVersion bool `default:"true"`

	// Gzip is whether to gzip the app.wasm file that is built in the build command
	// and serve it as a gzip-encoded file in the run command.
	Gzip bool

	// The page language.
	//
	// DEFAULT: en.
	Lang string `default:"en"`

	// The page authors.
	Author string

	// The page keywords.
	Keywords []string

	// The path of the default image that is used by social networks when
	// linking the app.
	Image string

	// The interval between each app auto-update while running in a web browser.
	// Zero or negative values deactivates the auto-update mechanism.
	//
	// Default is 10 seconds.
	AutoUpdateInterval time.Duration `default:"10s"`

	// If specified, make this page a Go import vanity URL with this
	// module URL, pointing to the GitHub repository specified by GithubVanityURL
	// (eg: cogentcore.org/core).
	VanityURL string

	// If VanityURL is specified, the underlying GitHub repository for the vanity URL
	// (eg: cogentcore/core).
	GithubVanityRepository string

	// The environment variables that are passed to the progressive web app.
	//
	// Reserved keys:
	// - GOAPP_STATIC_RESOURCES_URL
	Env map[string]string

	// The HTTP header to retrieve the WebAssembly file content length.
	//
	// Content length finding falls back to the Content-Length HTTP header when
	// no content length is found with the defined header.
	WasmContentLengthHeader string
}

Web containts the configuration information for building for web and creating the HTML page that loads a Go wasm app and its resources.