wasm

type Component struct {
	// Name is the component's name in the manifest.
	Name string
	// Dir is the absolute directory of the tarawasm project.
	Dir string
	// Language is the language of the component, from tarawasm.json.
	Language string
	// Output is the component tarawasm builds, relative to Dir.
	Output string
	// SDKVersion is the tarantool-wasm release the component's SDK lock pins;
	// empty for a project without one.
	SDKVersion string
}

type ComponentStatus struct {
	Component

	// SDKRestored is true when the SDK the component pins is in its
	// .tarawasm, as tt wasm prepare puts it.
	SDKRestored bool
}

type Fetcher struct {
	// CacheDir holds the assets, by release version; empty disables the cache.
	CacheDir string
	// Client is the HTTP client; nil is http.DefaultClient.
	Client *http.Client
}

type NewOptions struct {
	// ProjectDir is the package the component is added to.
	ProjectDir string
	// Name is the component's name in the manifest.
	Name string
	// Dir is its directory, relative to the project; empty is Name.
	Dir string
	// Language is the language of the component.
	Language string
	// World names its WIT world, and so the component it builds:
	// dist/<world>.wasm. Empty is the name of the component.
	World string
	// Template, when set, is the template laid over the component.
	Template string
	// Fetcher downloads the tools tt installs.
	Fetcher Fetcher
	// Tarawasm runs the tarawasm of the project.
	Tarawasm Tarawasm
	// Resolve re-resolves the lock after the manifest changed.
	Resolve func(ctx context.Context) error
	// Progress receives one line per step.
	Progress io.Writer
}

type NewReport struct {
	// Dir is the component's directory, relative to the project.
	Dir string
	// Output is the component it builds, relative to Dir.
	Output string
	// Module is the Lua module the template uses the component with; empty
	// without a template.
	Module string
}

type Options struct {
	// ProjectDir is the project to prepare: the directory of its manifest.
	ProjectDir string
	// Version is the tarantool-wasm release; empty is DefaultVersion.
	Version string
	// Fetcher downloads the release assets.
	Fetcher Fetcher
	// Tarawasm installs tarawasm; SkipTarawasm leaves it out.
	Tarawasm     Tarawasm
	SkipTarawasm bool
	// Language, when set, has tarawasm set up the toolchain of that language.
	Language string
	// RockServer, when set, is a rock server that serves the rocks of the
	// release, which tt wasm rock packs: the dependency is declared from it,
	// and nothing is packed in the project.
	RockServer string
	// Declare declares the dependency rock on the registry and re-resolves the
	// lock. It reports whether the manifest already declared it, in which case
	// the declaration was left alone.
	Declare func(ctx context.Context, name, constraint, registry string) (bool, error)
	// PrepareEnv writes the project's .env/activate.sh, when it is missing.
	PrepareEnv func() error
	// Progress receives one line per step.
	Progress io.Writer
}

type PackOptions struct {
	// Dir is the directory the rocks and their index go to: a rock server.
	Dir string
	// Version is the release; empty is DefaultVersion.
	Version string
	// Fetcher downloads the assets.
	Fetcher Fetcher
	// Progress receives one line per rock.
	Progress io.Writer
}

type Platform struct {
	// GOOS and GOARCH name the hosts the build runs on.
	GOOS   string `json:"goos"`
	GOARCH string `json:"goarch"`
	// Asset is the file name of the release asset.
	Asset string `json:"asset"`
	// SHA256 is the asset's checksum, as GitHub publishes it for the asset.
	SHA256 string `json:"sha256"`
	// RockArch is the LuaRocks arch of the rock: what go-luarocks accepts as
	// the host's (linux-x86_64, macosx-aarch64).
	RockArch string `json:"rock_arch"`
	// Module is the file the rock carries under lib/: wasm.so, or wasm.dylib
	// on macOS, where Tarantool looks for C modules as ?.dylib only.
	Module string `json:"module"`
}

type Release struct {
	// Version is the release version, without the v of its tag.
	Version string `json:"version"`
	// RockRevision is the revision of the rockspec tt writes for it.
	RockRevision int `json:"rock_revision"`
	// SDKAsset and SDKMD5 name the release's SDK archive: the source the
	// rockspec points at. It is the one asset all platforms share, so the
	// rockspec, and the checksum the lock records from it, is the same on
	// every host.
	SDKAsset string `json:"sdk_asset"`
	SDKMD5   string `json:"sdk_md5"`
	// Platforms are the native builds of the release.
	Platforms []Platform `json:"platforms"`
	// BaseURL is where the assets are: <base>/v<version>/<asset>. Empty is
	// the releases of tarantool-wasm-rs on GitHub.
	BaseURL string `json:"base_url,omitempty"`
}

type Report struct {
	// Release and Platform are what the project was prepared with.
	Release  Release
	Platform Platform
	// Rock is the path of the rock in the project's registry; empty when the
	// rock comes from RockServer.
	Rock string
	// Registry is the registry the dependency is declared from.
	Registry string
	// Declared is false when the manifest already declared the dependency.
	Declared bool
	// Tarawasm is where tarawasm went; nil when it was skipped.
	Tarawasm *TarawasmLayout
	// TarawasmInstalled is false when an installed tarawasm was kept.
	TarawasmInstalled bool
	// Languages are the languages whose toolchains were checked.
	Languages []string
	// Components are the components whose SDK was restored.
	Components []string
}

type StatusReport struct {
	// Declared and Registry are the wasm rock the manifest declares; empty
	// when it declares none, or no exact version.
	Declared string
	Registry string
	// Rock is the rock of this host in the registry; empty when it is not
	// there.
	Rock string
	// Tarawasm is the tarawasm of the project; empty when it is not there.
	Tarawasm string
	// Components are the components tarawasm builds.
	Components []ComponentStatus
	// Languages and Toolchains are their languages and what was found of the
	// toolchain of each.
	Languages  []string
	Toolchains map[string][]ToolStatus
	// Problems are what keeps the project from building, one a line.
	Problems []string
}

type Tarawasm struct {
	// Python is the interpreter the environment is made with.
	Python string
	// Source is what pip installs; empty is the pinned commit.
	Source string
	// Reinstall makes the environment anew even when it is there.
	Reinstall bool
	// Output receives the output of python and pip.
	Output io.Writer
	// contains filtered or unexported fields
}

type TarawasmLayout struct {
	// Env is the virtual environment.
	Env string
	// Link is the link the project's builds find tarawasm by.
	Link string
}

type Tool struct {
	// Name is the program, as the builds find it on PATH.
	Name string
	// VersionArgs make it print its version.
	VersionArgs []string
	// Minimum and Below bound the version it must have: at least Minimum,
	// below Below; either may be empty.
	Minimum string
	Below   string
	// Hint says how to get it, for a tool the user installs.
	Hint string
	// Dir, when set, is an environment variable naming the directory whose
	// bin/ holds the tool, as WASI_SDK_PATH does for clang; PATH is the
	// fallback.
	Dir string
	// Release is the build tt installs into the project; nil for a tool the
	// user installs. tt installs nothing into the system.
	Release *ToolRelease
}

type ToolAsset struct {
	URL    string
	SHA256 string
}

type ToolRelease struct {
	// Version is the version tt installs.
	Version string
	// Assets are its downloads, by host: GOOS/GOARCH.
	Assets map[string]ToolAsset
	// Wheel is true for a tool whose assets are Python wheels, which pip
	// installs into the environment of tarawasm from the file tt downloaded.
	Wheel bool
	// Tree is the path of the program in an archive tt keeps whole: the
	// archive is unpacked into the version directory, its top directory
	// stripped. Empty for an asset that is, or holds, the program alone.
	Tree string
	// Overlays are more archives of each host unpacked over the tree, as
	// Binaryen is over TinyGo.
	Overlays map[string][]ToolAsset
	// Links are more programs of the tree linked into the project's bin.
	Links []string
	// Unlinked keeps the program out of the project's bin, where it would
	// stand in for a tool of the system in every build: clang. tarawasm is
	// told where it is instead, in each component (see Tool.ProjectSetting).
	Unlinked bool
	// Dir names the version directory; empty is the name of the tool.
	Dir string
}

type ToolStatus struct {
	Tool Tool
	// Path is where it was found; empty when it was not.
	Path string
	// Version is the version it reports; empty when it was not found.
	Version string
	// OK is true for a tool found in a version it may have.
	OK bool
}

type ToolchainOptions struct {
	// Root is the .tarantool of the project.
	Root string
	// Language is the language whose toolchain is ensured.
	Language string
	// Fetcher downloads the tools tt installs.
	Fetcher Fetcher
	// TarawasmEnv is the environment of tarawasm, where pip installs; empty
	// when the project has no tarawasm.
	TarawasmEnv string
	// Output receives the output of pip.
	Output io.Writer
}

type ToolchainResult struct {
	// Statuses are the tools of the toolchain, as checked.
	Statuses []ToolStatus
	// Unlinked are the programs tt installed without linking them into the
	// project's bin, by tool: tarawasm is told of them in each component.
	Unlinked map[string]string
}