use std::collections::{BTreeMap, HashSet};
use specta::datatype::{
DataType, Fields, NamedReference, NamedReferenceType, Primitive, Reference,
};
use specta::{Format as _, Types};
use specta_typescript::{collect_references, primitives, Typescript};
use super::module::Module;
const HEADER: &str = "// The native modules of the program that embeds this app. Generated by `sk types`; do not edit.\n";
fn numbers(dt: &mut DataType) {
match dt {
DataType::Primitive(p) => {
if !matches!(p, Primitive::bool | Primitive::char | Primitive::str) {
*p = Primitive::i32;
}
}
DataType::List(list) => numbers(&mut list.ty),
DataType::Map(map) => {
numbers(map.key_ty_mut());
numbers(map.value_ty_mut());
}
DataType::Struct(s) => fields(&mut s.fields),
DataType::Enum(e) => {
for (_, variant) in &mut e.variants {
fields(&mut variant.fields);
}
}
DataType::Tuple(t) => t.elements.iter_mut().for_each(numbers),
DataType::Nullable(inner) => numbers(inner),
DataType::Intersection(parts) => parts.iter_mut().for_each(numbers),
DataType::Reference(Reference::Named(r)) => match &mut r.inner {
NamedReferenceType::Inline { dt, .. } => numbers(dt),
NamedReferenceType::Reference { generics, .. } => {
generics.iter_mut().for_each(|(_, dt)| numbers(dt))
}
_ => {}
},
_ => {}
}
}
fn fields(fields: &mut Fields) {
match fields {
Fields::Unit => {}
Fields::Unnamed(f) => f
.fields
.iter_mut()
.filter_map(|f| f.ty.as_mut())
.for_each(numbers),
Fields::Named(f) => f
.fields
.iter_mut()
.filter_map(|(_, f)| f.ty.as_mut())
.for_each(numbers),
}
}
fn tidy(text: &mut std::borrow::Cow<'static, str>) {
if text.lines().any(|l| l.starts_with(' ')) {
let lines: Vec<&str> = text
.lines()
.map(|l| l.strip_prefix(' ').unwrap_or(l))
.collect();
*text = lines.join("\n").into();
}
}
fn docs(dt: &mut DataType) {
match dt {
DataType::List(list) => docs(&mut list.ty),
DataType::Map(map) => {
docs(map.key_ty_mut());
docs(map.value_ty_mut());
}
DataType::Struct(s) => field_docs(&mut s.fields),
DataType::Enum(e) => {
for (_, variant) in &mut e.variants {
variant.docs = "".into();
field_docs(&mut variant.fields);
}
}
DataType::Tuple(t) => t.elements.iter_mut().for_each(docs),
DataType::Nullable(inner) => docs(inner),
DataType::Intersection(parts) => parts.iter_mut().for_each(docs),
DataType::Reference(Reference::Named(r)) => {
if let NamedReferenceType::Inline { dt, .. } = &mut r.inner {
docs(dt);
}
}
_ => {}
}
}
fn field_docs(fields: &mut Fields) {
match fields {
Fields::Unit => {}
Fields::Unnamed(f) => f
.fields
.iter_mut()
.filter_map(|f| f.ty.as_mut())
.for_each(docs),
Fields::Named(f) => {
for (_, field) in &mut f.fields {
tidy(&mut field.docs);
if let Some(ty) = field.ty.as_mut() {
docs(ty);
}
}
}
}
}
fn members(text: &str) -> String {
let mut out = String::with_capacity(text.len());
for line in text.split_inclusive('\n') {
let body = line.trim_end_matches('\n');
let trimmed = body.trim();
if trimmed.ends_with(',') && (trimmed.contains(':') || trimmed == "},") {
out.push_str(&body[..body.len() - 1]);
out.push(';');
out.push_str(&line[body.len()..]);
} else {
out.push_str(line);
}
}
out
}
fn unwrap_result(types: &Types, dt: DataType) -> DataType {
if let DataType::Reference(Reference::Named(r)) = &dt {
let is_result = types.get(r).is_some_and(|ndt| {
ndt.name == "Result" && matches!(&*ndt.module_path, "core::result" | "std::result")
});
if let (true, NamedReferenceType::Reference { generics, .. }) = (is_result, &r.inner) {
if let Some((_, ok)) = generics.first() {
return ok.clone();
}
}
}
dt
}
fn any_bytes(param: String) -> String {
match param.strip_prefix("Uint8Array") {
Some(rest) if rest.is_empty() || rest.starts_with(" | ") => {
format!("ArrayBufferView | ArrayBuffer{rest}")
}
_ => param,
}
}
struct Renderer {
ts: Typescript,
raw: Types,
types: Types,
referenced: Vec<NamedReference>,
}
impl Renderer {
fn new(raw: Types) -> Result<Self, String> {
let mut types = specta_serde::Format
.map_types(&raw)
.map_err(|e| e.to_string())?
.into_owned();
types.iter_mut(|ndt| {
tidy(&mut ndt.docs);
if let Some(ty) = ndt.ty.as_mut() {
numbers(ty);
docs(ty);
}
});
Ok(Self {
ts: Typescript::default(),
raw,
types,
referenced: Vec::new(),
})
}
fn render(&mut self, dt: &DataType) -> Result<String, String> {
let mut dt = specta_serde::Format
.map_type(&self.raw, dt)
.map_err(|e| e.to_string())?
.into_owned();
numbers(&mut dt);
let (text, refs) = collect_references(|| primitives::reference(&self.ts, &self.types, &dt));
self.referenced.extend(refs);
text.map_err(|e| e.to_string())
}
fn declarations(&mut self) -> Result<String, String> {
let mut out = BTreeMap::new();
let mut seen = HashSet::new();
while let Some(r) = self.referenced.pop() {
let Some(ndt) = self.types.get(&r) else {
continue;
};
if !seen.insert((ndt.module_path.to_string(), ndt.name.to_string())) {
continue;
}
let (text, refs) = collect_references(|| {
primitives::export(&self.ts, &self.types, std::iter::once(ndt), " ")
});
let text = members(&text.map_err(|e| e.to_string())?.replace('\t', " "));
if out.insert(ndt.name.to_string(), text).is_some() {
return Err(format!(
"two different types are named {}: rename one with #[serde(rename = \"…\")]",
ndt.name
));
}
self.referenced.extend(refs);
}
Ok(out.into_values().collect())
}
}
fn module(module: &Module) -> Result<String, String> {
let mut raw = Types::default();
let functions: Vec<_> = module
.functions
.iter()
.map(|entry| (entry, (entry.signature)(&mut raw)))
.collect();
let events: Vec<_> = module
.events
.iter()
.map(|e| (e, (e.ty)(&mut raw)))
.collect();
let mut r = Renderer::new(raw)?;
let mut body = String::from(" export const available: boolean;\n");
for (entry, (params, ret)) in functions {
let mut list = Vec::new();
let optional_from = params
.iter()
.rposition(|p| !matches!(p, DataType::Nullable(_)))
.map_or(0, |i| i + 1);
for (i, param) in params.iter().enumerate() {
let name = entry
.params
.get(i)
.cloned()
.unwrap_or_else(|| format!("arg{}", i + 1));
let mark = if i >= optional_from { "?" } else { "" };
list.push(format!("{name}{mark}: {}", any_bytes(r.render(param)?)));
}
let ret = unwrap_result(&r.raw, ret);
let ret = if matches!(&ret, DataType::Tuple(t) if t.elements.is_empty()) {
"void".to_owned()
} else {
r.render(&ret)?
};
let ret = if entry.task {
format!("Promise<{ret}>")
} else {
ret
};
body.push_str(&format!(
" export function {}({}): {ret};\n",
entry.name,
list.join(", ")
));
}
if events.is_empty() {
body.push_str(
" export function on(event: never, handler: (data: never) => void): () => void;\n",
);
body.push_str(
" export function off(event: never, handler: (data: never) => void): void;\n",
);
}
let mut off = String::new();
for (event, ty) in events {
let ty = r.render(&ty)?;
let name = serde_json::to_string(&event.name).unwrap_or_default();
body.push_str(&format!(
" export function on(event: {name}, handler: (data: {ty}) => void): () => void;\n"
));
off.push_str(&format!(
" export function off(event: {name}, handler: (data: {ty}) => void): void;\n"
));
}
body.push_str(&off);
let types = r.declarations()?;
Ok(format!(
"declare module \"native:{}\" {{\n{types}{body}}}\n",
module.name
))
}
pub(crate) fn declarations(modules: &[Module]) -> Result<String, String> {
if modules.is_empty() {
return Ok(String::new());
}
let mut out = String::from(HEADER);
for m in modules {
out.push('\n');
out.push_str(&module(m).map_err(|e| format!("native:{}: {e}", m.name))?);
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
struct Note {
id: u64,
body_text: String,
tags: Vec<Tag>,
}
#[derive(serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "lowercase")]
enum Tag {
Work,
Home,
}
#[derive(serde::Serialize, serde::Deserialize, specta::Type)]
struct Search {
limit: Option<u32>,
}
#[derive(serde::Serialize, specta::Type)]
struct Progress {
done: usize,
total: usize,
}
#[test]
fn a_module_declares_its_functions_tasks_events_and_the_types_they_reach() {
let mut m = Module::new("notes".into());
m.function("get", |_: u64| -> Result<Note, String> {
Err("none".into())
})
.params(["id"]);
m.task("search", |_: String, _: Option<Search>| Vec::<Note>::new());
m.function("count", || 0.5f64);
m.event::<Progress>("progress");
let mut empty = Module::new("empty".into());
empty.function("ping", || ());
let expected = r#"
declare module "native:notes" {
export type Note = {
id: number;
/**
* Markdown,
* with front matter.
*/
bodyText: string;
tags: Tag[];
};
export type Progress = {
done: number;
total: number;
};
export type Search = {
limit: number | null;
};
export type Tag = "work" | "home";
export const available: boolean;
export function get(id: number): Note;
export function search(arg1: string, arg2?: Search | null): Promise<Note[]>;
export function count(): number;
export function on(event: "progress", handler: (data: Progress) => void): () => void;
export function off(event: "progress", handler: (data: Progress) => void): void;
}
declare module "native:empty" {
export const available: boolean;
export function ping(): void;
export function on(event: never, handler: (data: never) => void): () => void;
export function off(event: never, handler: (data: never) => void): void;
}
"#;
assert_eq!(
declarations(&[m, empty]).unwrap(),
format!("{HEADER}{expected}")
);
assert_eq!(declarations(&[]).unwrap(), "");
}
#[skathi_macros::data(crate = crate::embed)]
#[serde(rename_all = "camelCase")]
struct Entry {
entry_id: u32,
thumbnail: Option<Vec<u8>>,
}
#[skathi_macros::data(crate = crate::embed)]
#[derive(serde::Serialize)]
enum Mood {
Calm,
Busy,
}
struct Store;
#[skathi_macros::module(crate = crate::embed, events(changed = Entry, "mood-swing" = Mood))]
impl Store {
pub fn new() -> Self {
Store
}
fn first_id(&self) -> u32 {
1
}
pub fn fetch_all(&self, max_count: u32, mood: Option<Mood>) -> Vec<Entry> {
let _ = (max_count, mood);
vec![Entry {
entry_id: self.first_id(),
thumbnail: None,
}]
}
pub fn label(&self, text: &str) -> String {
text.to_owned()
}
pub fn digest(&self, data: &[u8], key: Option<Vec<u8>>) -> Vec<u8> {
let _ = key;
data.to_vec()
}
pub fn peak(&self, samples: &[f32]) -> f32 {
samples.iter().copied().fold(0.0, f32::max)
}
#[task]
pub fn sync_now(&self) -> Result<u32, String> {
Ok(0)
}
}
#[test]
fn a_module_type_declares_its_methods_by_their_signatures() {
let mut m = Module::new("store".into());
crate::embed::IntoModule::register(Store::new(), &mut m);
let expected = r#"
declare module "native:store" {
export type Entry = {
entryId: number;
thumbnail?: Uint8Array | null;
};
export type Mood = "Calm" | "Busy";
export const available: boolean;
export function fetchAll(maxCount: number, mood?: Mood | null): Entry[];
export function label(text: string): string;
export function digest(data: ArrayBufferView | ArrayBuffer, key?: ArrayBufferView | ArrayBuffer | null): Uint8Array;
export function peak(samples: Float32Array): number;
export function syncNow(): Promise<number>;
export function on(event: "changed", handler: (data: Entry) => void): () => void;
export function on(event: "mood-swing", handler: (data: Mood) => void): () => void;
export function off(event: "changed", handler: (data: Entry) => void): void;
export function off(event: "mood-swing", handler: (data: Mood) => void): void;
}
"#;
assert_eq!(declarations(&[m]).unwrap(), format!("{HEADER}{expected}"));
}
}