config

Documentation

Overview

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

Index

• Variables
• func ArchSupported(arch string) error
• func OSSupported(os string) error
• func VersionLinkerFlags() string
• 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 Setup
• type Types
  • func TypesValues() []Types
  • func (i Types) Desc() string
  • func (i Types) Int64() int64
  • func (i Types) IsValid() bool
  • 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 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).

func VersionLinkerFlags

func VersionLinkerFlags() string

VersionLinkerFlags returns the ld linker flags that specify the app and core version.

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 {

	// the user-friendly name of the project
	Name string

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

	// the description of the project
	Desc string

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

	// the type of the project (App/Library)
	Type Types `def:"App"`

	// Webcore, if specified, indicates that the app has webcore
	// 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 webcoregen.go, and
	// a directory tree will be made for all of the pages when building
	// for platform web.
	Webcore string

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

	// the configuration information for the pack command
	Pack Pack `cmd:"pack" view:"add-fields"`

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

	// the configuration options for the setup command
	Setup Setup `cmd:"setup" view:"add-fields"`

	// the configuration options for the log command
	Log Log `cmd:"log" view:"add-fields"`

	// the configuration options for the generate command
	Generate Generate `cmd:"generate" view:"add-fields"`
}

Config is the main config struct that contains all of the configuration options for the Cogent Core 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 gtigen
	Gtigen gtigen.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 Setup

type Setup struct {

	// the platform to set things up for
	Platform Platform `posarg:"0"`
}

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) IsValid

func (i Types) IsValid() bool

IsValid returns whether the value is a valid option for type Types.

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 automatically add a random string to the
	// end of the version string for the app when building for web. This is
	// necessary in order for changes made during local development to show up,
	// but should not be enabled in release builds to prevent constant inaccurate
	// update messages. It is enabled by default in the serve command and disabled
	// by default otherwise.
	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

	// A placeholder background color for the application page to display before
	// its stylesheets are loaded.
	//
	// DEFAULT: #2d2c2c.
	BackgroundColor string `default:"#2d2c2c"`

	// The theme color for the application. This affects how the OS displays the
	// app (e.g., PWA title bar or Android's task switcher).
	//
	// DEFAULT: #2d2c2c.
	ThemeColor string `default:"#2d2c2c"`

	// The text displayed while loading a page. Load progress can be inserted by
	// including "{progress}" in the loading label.
	//
	// DEFAULT: "{progress}%".
	LoadingLabel string `default:"{progress}%"`

	// 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_VERSION
	// - GOAPP_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.