wip: Add valkyrie validation

Author: tingerrr

src/_pkg.typ

@@ -2,3 +2,4 @@
 #import "@preview/hydra:0.4.0"
 #import "@preview/showybox:2.0.1"
 #import "@preview/t4t:0.3.2"
+#import "@local/valkyrie:0.2.0" as z

src/_valid.typ

@@ -0,0 +1,12 @@
+#import "_pkg.typ"
+
+#let _content = content
+#let _color = color
+#let _gradient = gradient
+#let _version = version
+
+#import _pkg.z: *
+
+#let paint = base-type.with(name: "color/gradient", types: (_color, _gradient,))
+
+#let auto_ = base-type.with(name: "auto", types: (type(auto),))

src/author.typ

@@ -1,3 +1,6 @@
+#import "/src/_pkg.typ"
+#import "/src/_valid.typ"
+
 /// The marks used in `author` for automatic mark numbering.
 ///
 /// Can be used to add new or alter existing marks, marks come in the form of
@@ -9,14 +12,26 @@
 
 /// Display a person with the given options.
 ///
-/// - ..first (str): The first and middle names.
-/// - last (str, array): The last names.
 /// - short (int): The shortness level.
 ///   - `0`: do not shorten any names
 ///   - `1`: shorten middle names
 ///   - `2`: shorten middle and first names
+/// - ..first (str): The first and middle names.
+/// - last (str, array): The last names.
 /// -> content
-#let name(..first, last, short: 1) = {
+#let name(
+  short: 1,
+  ..first,
+  last,
+  _validate: true,
+) = {
+  if _validate {
+    import _valid as z
+    _ = z.parse(first, z.sink(positional: z.array(z.string())), scope: ("first",))
+    _ = z.parse(last, z.array(z.string(), pre-transform: z.coerce.array), scope: ("last",))
+    _ = z.parse(short, z.integer(min: 0, max: 2), scope: ("short",))
+  }
+
   first = first.pos()
 
   if type(first) == str {
@@ -52,23 +67,33 @@
 
 /// Show full author information, see also `name`.
 ///
-/// - ..first (str, none): The first and middle names.
-/// - last (str, array): The last names.
 /// - short (int): The shortness level.
 ///   - `0`: do not shorten any names
 ///   - `1`: shorten middle names
 ///   - `2`: shorten middle and first names
 /// - label (label, none): The label to use for email attribution, see `email`.
 /// - email (str, content, none): The email to attribute the user to.
+/// - ..first (str): The first and middle names.
+/// - last (str, array): The last names.
 /// -> content
 #let author(
-  ..first,
-  last,
   short: 1,
   label: none,
   email: none,
+  ..first,
+  last,
+  _validate: true,
 ) = {
-  name(..first, last, short: short)
+  if _validate {
+    import _valid as z
+    _ = z.parse(first, z.sink(positional: z.array(z.string())), scope: ("first",))
+    _ = z.parse(last, z.array(z.string(), pre-transform: z.coerce.array), scope: ("last",))
+    _ = z.parse(short, z.integer(min: 0, max: 2), scope: ("short",))
+    _ = z.parse(email, z.content(optional: true), scope: ("email",))
+    _ = z.parse(label, z.label(optional: true), scope: ("label",))
+  }
+
+  name(..first, last, short: short, _validate: false)
 
   if label != none {
     context super(marks.final().marks.at(str(label)))
@@ -94,7 +119,15 @@
   mark: auto,
   label,
   body,
+  _validate: true,
 ) = {
+  if _validate {
+    import _valid as z
+    _ = z.parse(body, z.content(optional: true), scope: ("body",))
+    _ = z.parse(mark, z.either(z.content(optional: true), z.auto_()), scope: ("mark",))
+    _ = z.parse(label, z.label(optional: true), scope: ("label",))
+  }
+
   if mark == auto {
     marks.update(m => {
       m.current-auto += 1;

src/component/table-of-contents.typ

@@ -1,9 +1,10 @@
 #import "/src/_pkg.typ"
+#import "/src/_valid.typ"
 #import "/src/theme.typ" as _theme
 
 #let _columns = columns
 
-#let fill(arr, len, new) = if arr.len() >= len {
+#let _fill(arr, len, new) = if arr.len() >= len {
   arr
 } else {
   arr + ((new,) * (len - arr.len()))
@@ -24,11 +25,17 @@
   target: heading.where(outlined: true),
   columns: 1,
   theme: _theme.default,
+  _validate: true,
 ) = {
-  _pkg.t4t.assert.any-type(str, content, title)
-  _pkg.t4t.assert.any-type(selector, function, target)
-  _pkg.t4t.assert.any-type(int, columns)
-  _pkg.t4t.assert.any-type(dictionary, theme)
+  if _validate {
+    import _valid as z
+
+    _ = z.parse(title, z.content(), scope: ("title",))
+    _ = z.parse(columns, z.integer(), scope: ("columns",))
+    _ = z.parse(theme, _theme.schema(), scope: ("theme",))
+
+    _pkg.t4t.assert.any-type(selector, function, target)
+  }
 
   // NOTE: unsure if this looks good, this also doens't work in CI for now
   // set text(font: theme.fonts.headings)
@@ -61,7 +68,7 @@
 
     for part in parts {
       if part.level >= indent-stack.len() {
-        indent-stack = fill(indent-stack, part.level, 0em)
+        indent-stack = _fill(indent-stack, part.level, 0em)
       }
 
       let level-max = indent-stack.at(part.level - 1)

src/component/title-page.typ

@@ -1,4 +1,5 @@
 #import "/src/_pkg.typ"
+#import "/src/_valid.typ"
 #import "/src/theme.typ" as _theme
 
 #let _version = version
@@ -28,25 +29,38 @@
   abstract: lorem(100),
   license: "MIT",
   theme: _theme.default,
+  _validate: true,
 ) = {
-  let assert-text = _pkg.t4t.assert.any-type.with(str, content)
-  let assert-maybe-text = _pkg.t4t.assert.any-type.with(str, content, type(none))
+  if _validate {
+    import _valid as z
 
-  assert-text(title)
-  assert-maybe-text(subtitle)
-  assert-text(array, authors)
-  _pkg.t4t.assert.any-type(str, array, type(none), urls)
-  assert-maybe-text(abstract)
-  _pkg.t4t.assert.any-type(_version, version)
-  assert-maybe-text(license)
-  _pkg.t4t.assert.any-type(dictionary, theme)
+    _ = z.parse(title, z.content(), scope: ("title",))
+    _ = z.parse(subtitle, z.content(optional: true), scope: ("subtitle",))
+    _ = z.parse(abstract, z.content(optional: true), scope: ("abstract",))
+    _ = z.parse(license, z.content(optional: true), scope: ("license",))
+    _ = z.parse(theme, _theme.schema(), scope: ("theme",))
 
-  if authors != none {
-    authors = _pkg.t4t.def.as-arr(authors)
-  }
+    authors = z.parse(
+      authors,
+      z.array(z.string(), min: 1, pre-transform: z.coerce.array),
+      scope: ("authors",),
+    )
+
+    urls = z.parse(
+      urls,
+      z.array(
+        z.string(),
+        pre-transform: z.coerce.array,
+        post-transform: (self, it) => if it == (none,) { none } else { it },
+        optional: true,
+      ),
+      scope: ("urls",),
+    )
 
-  if urls != none {
-    urls = _pkg.t4t.def.as-arr(urls)
+    _pkg.t4t.assert.any-type(_version, version)
+  } else {
+    authors = if type(authors) == str { (authors,) } else { authors }
+    urls = if type(urls) == str { (urls,) } else { urls }
   }
 
   pad(y: 10em, x: 5em, {

src/example.typ

@@ -1,4 +1,5 @@
 #import "/src/_pkg.typ"
+#import "/src/_valid.typ"
 #import "/src/theme.typ" as _theme
 
 /// Show a source code frame.
@@ -8,37 +9,57 @@
 /// -> content
 #let frame(
   theme: _theme.default,
+  _validate: true,
   ..args,
-) = _pkg.showybox.showybox(
-  frame: (
-    border-color: theme.colors.primary,
-    title-color: theme.colors.primary,
-    thickness: .75pt,
-    radius: 4pt,
-    inset: 8pt
-  ),
-  ..args
-)
+) = {
+  if _validate {
+    import _valid as z
+    _ = z.parse(theme, _theme.schema(), scope: ("theme",))
+    // NOTE: intentionally left empty, we only validte our own inputs
+  }
+
+  _pkg.showybox.showybox(
+    frame: (
+      border-color: theme.colors.primary,
+      title-color: theme.colors.primary,
+      thickness: .75pt,
+      radius: 4pt,
+      inset: 8pt
+    ),
+    ..args
+  )
+}
 
 /// Shows example code and its corresponding output in a frame.
 ///
 /// - side-by-side (bool): Whether or not the example source and output should
 ///   be shown side by side.
 /// - scope (dictionary): The scope to pass to `eval`.
 /// - breakable (bool): If the frame can brake over multiple pages.
-/// - theme (theme): The theme to use for this code example.
 /// - result (content): The content to render as the example result. Evaluated
 ///  `eval`.
 /// - source (content): A raw element containing the source code to evaluate.
+/// - theme (theme): The theme to use for this code example.
 /// -> content
 #let code-result(
   side-by-side: false,
   scope: (:),
   breakable: false,
-  theme: _theme.default,
   result: auto,
   source,
+  theme: _theme.default,
+  _validate: true,
 ) = {
+  if _validate {
+    import _valid as z
+    _ = z.parse(side-by-side, z.boolean(), scope: ("side-by-side",))
+    _ = z.parse(breakable, z.boolean(), scope: ("breakable",))
+    _ = z.parse(scope, z.dictionary((:)), scope: ("scope",))
+    _ = z.parse(result, z.either(z.content(), z.auto_()), scope: ("result",))
+    _ = z.parse(source, z.content(), scope: ("source",))
+    _ = z.parse(theme, _theme.schema(), scope: ("theme",))
+  }
+
   let mode = if source.lang == "typc" {
     "code"
   } else if source.lang in ("typ", "typst") {
@@ -62,6 +83,6 @@
         grid.hline(stroke: 0.75pt + theme.colors.primary)
       },
       result,
-    )
+    ),
   )
 }

src/lib.typ

@@ -1,4 +1,5 @@
 #import "_pkg.typ"
+#import "_valid.typ"
 
 #import "author.typ"
 #import "component.typ"
@@ -36,31 +37,42 @@
   abstract: lorem(100),
   license: "MIT",
   theme: theme.default,
+  _validate: true,
 ) = body => {
-  let assert-text = _pkg.t4t.assert.any-type.with(str, content)
-  let assert-maybe-text = _pkg.t4t.assert.any-type.with(str, content, type(none))
+  if _validate {
+    import _valid as z
 
-  assert-text(title)
-  assert-maybe-text(subtitle)
-  assert-text(array, authors)
-  _pkg.t4t.assert.any-type(str, array, type(none), urls)
-  assert-maybe-text(abstract)
-  _pkg.t4t.assert.any-type(_version, version)
-  assert-maybe-text(license)
-  _pkg.t4t.assert.any-type(dictionary, theme)
+    z.parse(title, z.content(), scope: ("title",))
+    z.parse(subtitle, z.content(optional: true), scope: ("subtitle",))
+    z.parse(abstract, z.content(optional: true), scope: ("abstract",))
+    z.parse(license, z.content(optional: true), scope: ("license",))
+    z.parse(theme, _theme.schema, scope: ("theme",))
 
-  let authors = authors
-  if authors != none {
-    authors = _pkg.t4t.def.as-arr(authors)
-  }
+    authors = z.parse(
+      z.array(z.string(), min: 1, pre-transform: z.coerce.array),
+      authors,
+      scope: ("authors",),
+    )
+
+    urls = z.parse(
+      urls,
+      z.array(
+        z.string(),
+        pre-transform: z.coerce.array,
+        post-transform: (self, it) => if it == (none,) { none } else { it },
+        optional: true,
+      ),
+      scope: ("urls",),
+    )
 
-  let urls = urls
-  if urls != none {
-    urls = _pkg.t4t.def.as-arr(urls)
+    _pkg.t4t.assert.any-type(_version, version)
+  } else {
+    authors = if type(authors) == str { (authors,) } else { authors }
+    urls = if type(urls) == str { (urls,) } else { urls }
   }
 
   set document(title: title, author: authors)
-  show: style.default(theme: theme)
+  show: style.default(theme: theme, _validate: false)
 
   component.make-title-page(
     title: title,
@@ -72,12 +84,14 @@
     abstract: abstract,
     license: license,
     theme: theme,
+    _validate: false,
   )
 
   component.make-table-of-contents(
     title: heading(outlined: false, numbering: none, level: 2)[Table of Contents],
     columns: 1,
     theme: theme,
+    _validate: false,
   )
 
   body