///|
pub fn load_project_config_from_file(
path : String,
) -> Result[ProjectConfig, String] {
let base_dir = config_base_dir(path)
read_project_config_text(path).bind(fn(text) {
load_project_config_from_text(text, base_dir, name=path)
})
}
///|
pub fn load_project_config_from_text(
source : String,
base_dir : String,
name? : String = "moon.proton",
) -> Result[ProjectConfig, String] {
let (ast, reports) = parse_moon_proton(name~, source)
if reports.length() > 0 {
return Err(render_config_reports(reports))
}
decode_project_config(ast, base_dir)
}
///|
fn read_project_config_text(path : String) -> Result[String, String] {
try @mbfs.read_file_to_string(path, encoding="utf8") catch {
error =>
Err(
"failed to read " + path + ": " + @debug.render(@debug.to_repr(error)),
)
} noraise {
text => Ok(text)
}
}
///|
fn decode_project_config(
ast : Ast,
base_dir : String,
) -> Result[ProjectConfig, String] {
match ast {
Obj(fields, _) =>
validate_project_top_level_fields(fields).bind(fn(_) {
zip4(
required_project_window(fields),
required_project_entry(fields, base_dir),
optional_project_debug(fields),
decode_project_metadata(fields, base_dir),
).bind(fn(values) {
let (window, entry, debug, metadata) = values
zip2(
optional_project_frontend(fields, base_dir),
optional_project_bundle(fields, base_dir),
).map(fn(tooling) {
let (frontend, bundle) = tooling
ProjectConfig::new(
base_dir,
window,
entry,
metadata,
frontend~,
bundle~,
debug~,
)
})
})
})
_ => Err("moon.proton root must be a field list")
}
}
///|
fn validate_project_top_level_fields(
fields : Array[ConfigField],
) -> Result[Unit, String] {
let seen : Map[String, Unit] = Map([])
for field in fields {
if seen.contains(field.key) {
return Err("duplicate moon.proton field: " + field.key)
}
seen[field.key] = ()
match field.key {
"window" | "entry" | "debug" => ()
"product_name" | "identifier" =>
match validate_optional_non_empty_string(field.value, field.key) {
Err(error) => return Err(error)
Ok(_) => ()
}
"frontend" | "bundle" =>
match validate_optional_object(field.value, field.key) {
Err(error) => return Err(error)
Ok(_) => ()
}
"extensions" =>
return Err(
"moon.proton field `extensions` is not supported; declare extensions in MoonBit code with .extension(...)",
)
"permissions" =>
return Err("moon.proton field `permissions` is not supported in v1")
"windows" =>
return Err("moon.proton field `windows` is not supported in v1")
other => return Err("unknown moon.proton field: " + other)
}
}
Ok(())
}
///|
fn required_project_window(
fields : Array[ConfigField],
) -> Result[ProjectWindowConfig, String] {
required_config_field(fields, "window").bind(fn(value) {
match value {
Obj(window_fields, _) =>
validate_object_fields(window_fields, "window", [
"title", "width", "height", "size_hint", "titlebar_style",
]).bind(fn(_) {
zip5(
required_string_config_field(window_fields, "title", "window.title"),
required_positive_int_config_field(
window_fields, "width", "window.width",
),
required_positive_int_config_field(
window_fields, "height", "window.height",
),
optional_string_config_field(
window_fields, "size_hint", "window.size_hint",
).bind(parse_project_size_hint),
optional_string_config_field(
window_fields, "titlebar_style", "window.titlebar_style",
).bind(parse_project_titlebar_style),
).map(fn(values) {
let (title, width, height, size_hint, titlebar_style) = values
ProjectWindowConfig::new(
title,
width,
height,
size_hint~,
titlebar_style~,
)
})
})
_ => Err("moon.proton window must be an object")
}
})
}
///|
fn parse_project_titlebar_style(
titlebar_style : String?,
) -> Result[ProjectTitlebarStyle, String] {
match titlebar_style {
None => Ok(TitlebarDefault)
Some(titlebar_style) =>
match normalize_keyword(titlebar_style) {
"default" => Ok(TitlebarDefault)
"overlay" => Ok(TitlebarOverlay)
_ => Err("unsupported window titlebar_style: " + titlebar_style)
}
}
}
///|
fn parse_project_size_hint(
size_hint : String?,
) -> Result[ProjectWindowSizeHint, String] {
match size_hint {
None => Ok(WindowSizeNone)
Some(size_hint) =>
match normalize_keyword(size_hint) {
"none" => Ok(WindowSizeNone)
"min" => Ok(WindowSizeMin)
"max" => Ok(WindowSizeMax)
"fixed" => Ok(WindowSizeFixed)
_ => Err("unsupported window size_hint: " + size_hint)
}
}
}
///|
fn required_project_entry(
fields : Array[ConfigField],
base_dir : String,
) -> Result[ProjectEntry, String] {
required_config_field(fields, "entry").bind(fn(value) {
match value {
Obj(entry_fields, _) =>
validate_object_fields(entry_fields, "entry", ["kind", "value"]).bind(fn(
_,
) {
zip2(
required_string_config_field(entry_fields, "kind", "entry.kind"),
required_string_config_field(entry_fields, "value", "entry.value"),
).bind(fn(values) {
let (kind, value) = values
build_project_entry_from_parts(kind, value, base_dir)
})
})
_ => Err("moon.proton entry must be an object")
}
})
}
///|
fn build_project_entry_from_parts(
kind : String,
value : String,
base_dir : String,
) -> Result[ProjectEntry, String] {
let normalized_kind = normalize_keyword(kind)
let rebased_value = match normalized_kind {
"file" | "asset" => rebase_project_path(value, base_dir)
_ => value
}
match normalized_kind {
"html" => Ok(ProjectEntry::Html(rebased_value))
"url" => Ok(ProjectEntry::Url(rebased_value))
"file" => Ok(ProjectEntry::File(rebased_value))
"asset" => Ok(ProjectEntry::Asset(rebased_value))
_ => Err("unsupported app entry kind: " + kind)
}
}
///|
fn optional_project_debug(fields : Array[ConfigField]) -> Result[Int, String] {
match find_config_field(fields, "debug") {
None => Ok(0)
Some(value) =>
match value {
Bool(enabled, _) => Ok(debug_int_from_bool(enabled))
_ => Err("moon.proton debug must be a bool")
}
}
}
///|
fn decode_project_metadata(
fields : Array[ConfigField],
base_dir : String,
) -> Result[ProjectMetadata, String] {
zip2(
optional_string_config_field(fields, "product_name", "product_name"),
optional_string_config_field(fields, "identifier", "identifier"),
).map(fn(values) {
let (product_name, identifier) = values
let moon_mod = read_nearest_moon_mod_metadata(base_dir)
let fallback_product_name = match required_project_window(fields) {
Ok(window) => window.title
Err(_) => "Proton App"
}
ProjectMetadata::new(
product_name.unwrap_or(fallback_product_name),
identifier~,
version=moon_mod.version,
description=moon_mod.description,
license=moon_mod.license,
)
})
}
///|
fn optional_project_frontend(
fields : Array[ConfigField],
base_dir : String,
) -> Result[ProjectFrontendConfig?, String] {
match find_config_field(fields, "frontend") {
None => Ok(None)
Some(Obj(frontend_fields, _)) =>
validate_object_fields(frontend_fields, "frontend", [
"dev_url", "dist", "before_dev", "before_build", "cwd",
]).bind(fn(_) {
zip5(
optional_string_config_field(
frontend_fields, "dev_url", "frontend.dev_url",
),
optional_rebased_string_config_field(
frontend_fields, "dist", "frontend.dist", base_dir,
),
optional_string_config_field(
frontend_fields, "before_dev", "frontend.before_dev",
),
optional_string_config_field(
frontend_fields, "before_build", "frontend.before_build",
),
optional_rebased_string_config_field(
frontend_fields, "cwd", "frontend.cwd", base_dir,
),
).map(fn(values) {
let (dev_url, dist, before_dev, before_build, cwd) = values
Some(
ProjectFrontendConfig::new(
dev_url~,
dist~,
before_dev~,
before_build~,
cwd~,
),
)
})
})
Some(_) => Err("moon.proton field `frontend` must be an object")
}
}
///|
fn optional_project_bundle(
fields : Array[ConfigField],
base_dir : String,
) -> Result[ProjectBundleConfig?, String] {
match find_config_field(fields, "bundle") {
None => Ok(None)
Some(Obj(bundle_fields, _)) =>
validate_object_fields(bundle_fields, "bundle", [
"active", "targets", "icon", "resources", "output",
]).bind(fn(_) {
zip5(
optional_bool_config_field(
bundle_fields, "active", "bundle.active", false,
),
optional_string_array_config_field(
bundle_fields, "targets", "bundle.targets",
),
optional_string_array_config_field(
bundle_fields, "icon", "bundle.icon",
).map(fn(icon) {
icon.map(fn(path) { rebase_project_path(path, base_dir) })
}),
optional_string_array_config_field(
bundle_fields, "resources", "bundle.resources",
).map(fn(resources) {
resources.map(fn(path) { rebase_project_path(path, base_dir) })
}),
optional_string_config_field(bundle_fields, "output", "bundle.output").map(fn(
output,
) {
rebase_project_path(
output.unwrap_or("target/proton-dist"),
base_dir,
)
},
),
).bind(fn(values) {
let (active, targets, icon, resources, output) = values
validate_project_bundle_targets(targets).map(fn(_) {
Some(
ProjectBundleConfig::new(
active~,
targets~,
icon~,
resources~,
output~,
),
)
})
})
})
Some(_) => Err("moon.proton field `bundle` must be an object")
}
}
///|
fn validate_project_bundle_targets(
targets : Array[String],
) -> Result[Unit, String] {
let seen : Map[String, Unit] = Map([])
for target in targets {
guard target == "app" || target == "zip" else {
return Err("bundle.targets contains unsupported target: " + target)
}
guard !seen.contains(target) else {
return Err("bundle.targets contains duplicate target: " + target)
}
seen[target] = ()
}
Ok(())
}
///|
fn validate_optional_non_empty_string(
value : Ast,
key : String,
) -> Result[Unit, String] {
match value {
Str(text, _) =>
if text == "" {
Err("moon.proton field `" + key + "` must not be empty")
} else {
Ok(())
}
_ => Err("moon.proton field `" + key + "` must be a string")
}
}
///|
fn validate_optional_object(value : Ast, key : String) -> Result[Unit, String] {
match value {
Obj(_, _) => Ok(())
_ => Err("moon.proton field `" + key + "` must be an object")
}
}
///|
fn validate_object_fields(
fields : Array[ConfigField],
label : String,
allowed : Array[String],
) -> Result[Unit, String] {
let seen : Map[String, Unit] = Map([])
for field in fields {
if seen.contains(field.key) {
return Err("duplicate " + label + " field: " + field.key)
}
seen[field.key] = ()
if !allowed.contains(field.key) {
return Err("unknown " + label + " field: " + field.key)
}
}
Ok(())
}
///|
fn required_config_field(
fields : Array[ConfigField],
key : String,
) -> Result[Ast, String] {
match find_config_field(fields, key) {
Some(value) => Ok(value)
None => Err("missing required moon.proton field: " + key)
}
}
///|
fn required_string_config_field(
fields : Array[ConfigField],
key : String,
label : String,
) -> Result[String, String] {
match find_config_field(fields, key) {
Some(Str(value, _)) =>
if value == "" {
Err(label + " must not be empty")
} else {
Ok(value)
}
Some(_) => Err(label + " must be a string")
None => Err("missing required field: " + label)
}
}
///|
fn optional_string_config_field(
fields : Array[ConfigField],
key : String,
label : String,
) -> Result[String?, String] {
match find_config_field(fields, key) {
None => Ok(None)
Some(Str(value, _)) =>
if value == "" {
Err(label + " must not be empty")
} else {
Ok(Some(value))
}
Some(_) => Err(label + " must be a string")
}
}
///|
fn optional_rebased_string_config_field(
fields : Array[ConfigField],
key : String,
label : String,
base_dir : String,
) -> Result[String?, String] {
optional_string_config_field(fields, key, label).map(fn(value) {
match value {
None => None
Some(path) => Some(rebase_project_path(path, base_dir))
}
})
}
///|
fn optional_bool_config_field(
fields : Array[ConfigField],
key : String,
label : String,
default : Bool,
) -> Result[Bool, String] {
match find_config_field(fields, key) {
None => Ok(default)
Some(Bool(value, _)) => Ok(value)
Some(_) => Err(label + " must be a bool")
}
}
///|
fn optional_string_array_config_field(
fields : Array[ConfigField],
key : String,
label : String,
) -> Result[Array[String], String] {
match find_config_field(fields, key) {
None => Ok([])
Some(Arr(items, _)) => {
let values : Array[String] = []
for item in items {
match item {
Str(value, _) =>
if value == "" {
return Err(label + " must not contain empty strings")
} else {
values.push(value)
}
_ => return Err(label + " must be a string array")
}
}
Ok(values)
}
Some(_) => Err(label + " must be a string array")
}
}
///|
fn required_positive_int_config_field(
fields : Array[ConfigField],
key : String,
label : String,
) -> Result[Int, String] {
match find_config_field(fields, key) {
Some(Int(text, _)) =>
try @string.parse_int(text) catch {
_ => Err(label + " must be an int")
} noraise {
value =>
if value <= 0 {
Err(label + " must be positive")
} else {
Ok(value)
}
}
Some(_) => Err(label + " must be an int")
None => Err("missing required field: " + label)
}
}
///|
fn find_config_field(fields : Array[ConfigField], key : String) -> Ast? {
for field in fields {
if field.key == key {
return Some(field.value)
}
}
None
}
///|
priv struct MoonModMetadata {
mut version : String?
mut description : String?
mut license : String?
}
///|
fn MoonModMetadata::new() -> MoonModMetadata {
MoonModMetadata::{ version: None, description: None, license: None }
}
///|
fn read_nearest_moon_mod_metadata(start_dir : String) -> MoonModMetadata {
match find_nearest_moon_mod(start_dir) {
None => MoonModMetadata::new()
Some(path) => read_moon_mod_metadata(path)
}
}
///|
fn find_nearest_moon_mod(start_dir : String) -> String? {
for current = start_dir, depth = 0; depth < 16; {
let candidate = join_path_string(current, "moon.mod")
if (@mbfs.is_file(candidate) catch { _ => false }) {
return Some(candidate)
}
let parent = dirname_string(current)
if parent == current || parent == "" {
return None
}
continue parent, depth + 1
} nobreak {
None
}
}
///|
fn read_moon_mod_metadata(path : String) -> MoonModMetadata {
let text = @mbfs.read_file_to_string(path, encoding="utf8") catch {
_ => return MoonModMetadata::new()
}
let metadata = MoonModMetadata::new()
let (ast, _reports) = parse_moon_mod(name=path, text)
match ast {
Obj(fields, _) => {
metadata.version = moon_mod_string_field(fields, "version")
metadata.description = moon_mod_string_field(fields, "description")
metadata.license = moon_mod_string_field(fields, "license")
}
_ => ()
}
metadata
}
///|
fn moon_mod_string_field(fields : Array[ConfigField], key : String) -> String? {
for field in fields {
if field.key == key {
match field.value {
Str(value, _) => return Some(value)
_ => return None
}
}
}
None
}
///|
fn render_config_reports(reports : Array[@basic.Report]) -> String {
let builder = StringBuilder::new()
for index, report in reports {
if index > 0 {
builder.write_string("\n")
}
builder.write_string(report.to_string())
}
builder.to_string()
}
///|
fn debug_int_from_bool(enabled : Bool) -> Int {
if enabled {
1
} else {
0
}
}