ferrovue 0.2.0 → 0.4.0

package/dist/plugins/stores.d.ts

@@ -0,0 +1,37 @@
+import { type Component, type N, type Struct } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+declare module "../model.ts" {
+    interface StructTy {
+        store?: true;
+    }
+}
+export interface StoreGetter {
+    param: string | null;
+    body: N;
+    file: string;
+    setup?: true;
+}
+export interface Store {
+    hook: string;
+    id: string;
+    field: string;
+    state: string;
+    module: string;
+    getters: Map<string, StoreGetter>;
+}
+interface StoresRun {
+    dir: string | null;
+    stores: Map<string, Store>;
+    structs: Map<string, Struct>;
+    files: Map<string, string>;
+    readers: Set<Component>;
+    inProgress: Set<string>;
+}
+interface StoresScope {
+    hooks: Map<string, Store>;
+    storeToRefs: string | null;
+    values: Map<string, Store>;
+}
+export declare function storeHome(file: string): Component;
+export declare const piniaStores: Plugin<StoresRun, StoresScope>;
+export {};

package/dist/plugins/stores.js

@@ -0,0 +1,377 @@
+import { parse as parseJs } from "@babel/parser";
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { blankComponent, BOOL, fail, FLOAT, GenError, INT, opt, sameTy, snake, STR, tagAst, UNDEF } from "../model.js";
+import { ctx } from "../context.js";
+import { structOf, tyOfTs, typesImports } from "../typescript.js";
+import { patternNames, setupStatement } from "../script.js";
+import { expr, fieldVal } from "../expr.js";
+import { runOf, scopeOf } from "../plugin.js";
+import { header, structSource } from "../rust.js";
+function storeImport(comp, from) {
+    const { stores } = runOf(piniaStores);
+    if (!from.startsWith(".") || stores.size === 0)
+        return null;
+    const target = resolve(ctx.rootDir, dirname(comp.file), from).replace(/\.ts$/, "");
+    return [...stores.values()].some((s) => s.module === target) ? target : null;
+}
+function readStores(root, dir) {
+    const run = runOf(piniaStores);
+    const files = readdirSync(join(root, dir)).filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts")).toSorted();
+    for (const f of files) {
+        const path = join(root, dir, f);
+        const comp = storeHome(relative(root, path));
+        comp.source = readFileSync(path, "utf8");
+        const ast = parseJs(comp.source, { sourceType: "module", plugins: ["typescript"] }).program.body;
+        tagAst(ast, "source");
+        typesImports(comp, ast);
+        const decls = ast.map((st) => (st.type === "ExportNamedDeclaration" ? st.declaration : st)).filter(Boolean);
+        const interfaces = decls.filter((d) => d.type === "TSInterfaceDeclaration");
+        for (const d of interfaces) {
+            if (run.structs.has(d.id.name))
+                fail(comp, `\`${d.id.name}\` is declared by another store too`, d);
+            run.structs.set(d.id.name, { name: d.id.name, fields: [] });
+            run.files.set(d.id.name, comp.file);
+        }
+        for (const d of interfaces) {
+            const st = structOf(comp, d.id.name, d.body.body, run.structs);
+            for (const field of st.fields)
+                field.ty = markStore(field.ty);
+            run.structs.set(d.id.name, st);
+        }
+        for (const d of decls) {
+            if (d.type !== "VariableDeclaration")
+                continue;
+            for (const v of d.declarations) {
+                const init = v.init;
+                if (init?.type !== "CallExpression" || init.callee.type !== "Identifier" || init.callee.name !== "defineStore")
+                    continue;
+                const [id, options] = init.arguments;
+                if (id?.type !== "StringLiteral")
+                    fail(comp, "a store's id is a string literal", init);
+                if (options?.type === "ArrowFunctionExpression" || options?.type === "FunctionExpression") {
+                    setupStore(comp, v.id.name, id.value, options, path);
+                    continue;
+                }
+                if (options?.type !== "ObjectExpression")
+                    fail(comp, "a store is `defineStore(id, { state, getters, actions })` or `defineStore(id, () => { … })`", init);
+                const state = options.properties.find((p) => (p.key?.name ?? p.key?.value) === "state");
+                const fn = state?.value ?? (state?.type === "ObjectMethod" ? state : null);
+                const ret = fn?.returnType?.typeAnnotation;
+                if (ret?.type !== "TSTypeReference" || !run.structs.has(ret.typeName.name)) {
+                    fail(comp, "a store's `state` declares its return type, an interface in the same file: `state: (): State => ({ … })`", state ?? init);
+                }
+                const getters = new Map();
+                const getterObj = options.properties.find((p) => (p.key?.name ?? p.key?.value) === "getters");
+                if (getterObj && getterObj.value?.type !== "ObjectExpression")
+                    fail(comp, "a store's `getters` is an object literal", getterObj);
+                for (const g of getterObj?.value.properties ?? []) {
+                    const getterFn = g.type === "ObjectMethod" ? g : g.value;
+                    const name = g.key?.name ?? g.key?.value;
+                    if (!getterFn || !["ArrowFunctionExpression", "FunctionExpression", "ObjectMethod"].includes(getterFn.type)) {
+                        fail(comp, `getter \`${name}\` is a function of the state`, g);
+                    }
+                    let body = getterFn.body;
+                    if (body.type === "BlockStatement") {
+                        const only = body.body.length === 1 ? body.body[0] : null;
+                        body = only?.type === "ReturnStatement" ? only.argument : null;
+                    }
+                    const param = getterFn.params[0];
+                    getters.set(name, { param: param?.type === "Identifier" ? param.name : null, body, file: comp.file });
+                }
+                run.stores.set(v.id.name, {
+                    hook: v.id.name,
+                    id: id.value,
+                    field: snake(id.value),
+                    state: ret.typeName.name,
+                    module: path.replace(/\.ts$/, ""),
+                    getters,
+                });
+            }
+        }
+    }
+}
+function setupStore(comp, hook, id, fn, path) {
+    const run = runOf(piniaStores);
+    if (fn.body.type !== "BlockStatement")
+        fail(comp, "a setup store's function returns its state from a block: `() => { …; return { … } }`", fn);
+    const refs = new Map();
+    const computeds = new Map();
+    const others = new Set();
+    let returned = null;
+    for (const st of fn.body.body) {
+        if (st.type === "ReturnStatement") {
+            returned = st.argument;
+            continue;
+        }
+        if (st.type === "FunctionDeclaration") {
+            if (st.id)
+                others.add(st.id.name);
+            continue;
+        }
+        if (st.type === "ExpressionStatement") {
+            setupStatement(comp, st);
+            continue;
+        }
+        if (st.type !== "VariableDeclaration")
+            fail(comp, `\`${st.type}\` in a setup store is not supported`, st);
+        for (const d of st.declarations) {
+            if (d.id.type !== "Identifier") {
+                for (const name of patternNames(d.id))
+                    others.add(name);
+                continue;
+            }
+            const init = d.init;
+            const callee = init?.type === "CallExpression" && init.callee.type === "Identifier" ? init.callee.name : null;
+            if (callee === "ref" || callee === "shallowRef") {
+                refs.set(d.id.name, refType(comp, init));
+            }
+            else if (callee === "computed") {
+                const getter = init.arguments[0];
+                let body = getter?.body;
+                if (body?.type === "BlockStatement") {
+                    const only = body.body.length === 1 ? body.body[0] : null;
+                    body = only?.type === "ReturnStatement" ? only.argument : null;
+                }
+                computeds.set(d.id.name, body);
+            }
+            else
+                others.add(d.id.name);
+        }
+    }
+    if (returned?.type !== "ObjectExpression")
+        fail(comp, "a setup store returns an object of its state, getters and actions", returned ?? fn);
+    const state = [];
+    const getters = new Map();
+    for (const p of returned.properties) {
+        if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier")
+            fail(comp, "a setup store returns plain names: `{ count, doubled, increment }`", p);
+        const key = p.key.name ?? p.key.value;
+        const local = p.value.name;
+        if (refs.has(local))
+            state.push({ js: key, rust: snake(key), ty: markStore(refs.get(local)) });
+        else if (computeds.has(local))
+            getters.set(key, { param: null, body: computeds.get(local), file: comp.file, setup: true });
+        else if (!others.has(local))
+            fail(comp, `\`${local}\` is not declared in the store's function`, p);
+    }
+    const name = id.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") + "State";
+    if (run.structs.has(name))
+        fail(comp, `\`${name}\` names this setup store's state; rename the interface`, fn);
+    run.structs.set(name, { name, fields: state });
+    run.files.set(name, comp.file);
+    run.stores.set(hook, { hook, id, field: snake(id), state: name, module: path.replace(/\.ts$/, ""), getters });
+}
+function refType(comp, init) {
+    const run = runOf(piniaStores);
+    const typed = init.typeParameters?.params?.[0];
+    const value = init.arguments[0];
+    if (typed) {
+        const ty = tyOfTs(comp, typed, run.structs);
+        return value ? ty : opt(ty);
+    }
+    const literal = (n) => {
+        if (n?.type === "StringLiteral" || (n?.type === "TemplateLiteral" && n.expressions.length === 0))
+            return STR;
+        if (n?.type === "NumericLiteral")
+            return Number.isInteger(n.value) ? INT : FLOAT;
+        if (n?.type === "UnaryExpression" && n.operator === "-")
+            return literal(n.argument);
+        if (n?.type === "BooleanLiteral")
+            return BOOL;
+        if (n?.type === "ArrayExpression" && n.elements.length) {
+            const of = literal(n.elements[0]);
+            return of && n.elements.every((el) => sameTy(literal(el) ?? UNDEF, of)) ? { k: "list", of } : null;
+        }
+        return null;
+    };
+    return literal(value) ?? fail(comp, "a setup store's ref declares its type: `ref<string[]>([])`", init);
+}
+export function storeHome(file) {
+    return blankComponent(basename(file), "stores", file, runOf(piniaStores).structs);
+}
+function storesSource(dir) {
+    const { stores, structs: states, files } = runOf(piniaStores);
+    const home = storeHome(dir);
+    const testDerive = (src) => src.replace("#[cfg_attr(test, derive(serde::Deserialize))]", `#[cfg_attr(test, derive(${src.includes("Default, serde::Serialize") ? "" : "Default, "}serde::Deserialize))]\n#[cfg_attr(test, serde(default))]`);
+    const structs = [...states.values()]
+        .map((st) => testDerive(structSource(st, home, `/// \`${st.name}\` in \`${files.get(st.name)}\`.\n`)))
+        .join("\n");
+    const all = {
+        name: "Stores",
+        fields: [...stores.values()].map((st) => ({ js: st.id, rust: st.field, ty: { k: "struct", name: st.state, store: true } })),
+    };
+    const top = testDerive(structSource(all, home, "/// Every store's state, keyed by id as `pinia.state.value` is: what the page sends the client.\n"));
+    return `${header(dir, "the store files")}
+//! The Pinia stores' state, which components read while they render on the server.
+
+${/Cow</.test(structs) ? "use std::borrow::Cow;\n\n" : ""}${structs}
+${top}`;
+}
+function mentions(n, name) {
+    if (!n || typeof n !== "object")
+        return false;
+    if (n.type === "Identifier" && n.name === name)
+        return true;
+    return Object.entries(n).some(([k, v]) => k !== "loc" && k !== "__fv" && (Array.isArray(v) ? v.some((x) => mentions(x, name)) : typeof v === "object" && mentions(v, name)));
+}
+function storeGetter(s, base, name, node) {
+    if (base.ty.k !== "struct" || !base.ty.store)
+        return null;
+    const stateName = base.ty.name;
+    const store = [...runOf(piniaStores).stores.values()].find((st) => st.state === stateName);
+    const g = store?.getters.get(name);
+    if (!g)
+        return null;
+    const where = `getter \`${name}\` in ${g.file}`;
+    if (!g.body)
+        fail(s.comp, `${where} returns a single expression`, node);
+    const uses = (n, type) => !!n && typeof n === "object" && (n.type === type || Object.entries(n).some(([k, v]) => k !== "loc" && (Array.isArray(v) ? v.some((x) => uses(x, type)) : typeof v === "object" && uses(v, type))));
+    if (uses(g.body, "ThisExpression"))
+        fail(s.comp, `${where} reads \`this\`; read the state through the getter's parameter`, node);
+    if (g.body.type === "ArrowFunctionExpression" || g.body.type === "FunctionExpression") {
+        fail(s.comp, `${where} returns a function, which takes arguments only the client passes`, node);
+    }
+    const locals = new Map();
+    if (g.param)
+        locals.set(g.param, { code: base.code, ty: base.ty });
+    const setup = new Map();
+    const refs = new Set();
+    if (g.setup) {
+        const fields = runOf(piniaStores).structs.get(stateName)?.fields ?? [];
+        for (const f of fields) {
+            setup.set(f.js, fieldVal(s.comp, base.code, base.ty, f.js, node));
+            refs.add(f.js);
+        }
+        for (const other of store.getters.keys()) {
+            if (other === name || !mentions(g.body, other))
+                continue;
+            if (runOf(piniaStores).inProgress.has(`${stateName}.${other}`))
+                fail(s.comp, `${where} and \`${other}\` read each other`, node);
+            runOf(piniaStores).inProgress.add(`${stateName}.${name}`);
+            try {
+                setup.set(other, storeGetter(s, base, other, node));
+            }
+            finally {
+                runOf(piniaStores).inProgress.delete(`${stateName}.${name}`);
+            }
+            refs.add(other);
+        }
+    }
+    try {
+        return expr({ ...s, locals, narrowed: new Map(), setup, refs, propsIdent: null }, g.body);
+    }
+    catch (e) {
+        if (e instanceof GenError)
+            throw new GenError(`${s.comp.file}: ${where}: ${e.message.replace(/^[^:]*: /, "")}`);
+        throw e;
+    }
+}
+function markStore(ty) {
+    if (ty.k === "struct")
+        return { ...ty, store: true };
+    if (ty.k === "opt" || ty.k === "list" || ty.k === "record")
+        return { ...ty, of: markStore(ty.of) };
+    return ty;
+}
+export const piniaStores = {
+    name: "stores",
+    configure: (config) => ({
+        dir: config.stores ?? null,
+        stores: new Map(),
+        structs: new Map(),
+        files: new Map(),
+        readers: new Set(),
+        inProgress: new Set(),
+    }),
+    prepare(root) {
+        const { dir } = runOf(piniaStores);
+        if (dir)
+            readStores(root, dir);
+    },
+    importedType(comp, file, name, local) {
+        const { stores, structs } = runOf(piniaStores);
+        const module = file.replace(/\.ts$/, "");
+        if (![...stores.values()].some((x) => x.module === module))
+            return false;
+        if (structs.has(name))
+            comp.importedTypes.set(local, { k: "struct", name, store: true });
+        return true;
+    },
+    struct: (ty) => (ty.store ? { st: runOf(piniaStores).structs.get(ty.name), module: "stores" } : null),
+    scope: () => ({ hooks: new Map(), storeToRefs: null, values: new Map() }),
+    scriptImport(s, st, from) {
+        const comp = s.comp;
+        const own = scopeOf(piniaStores, s);
+        if (storeImport(comp, from)) {
+            for (const sp of st.specifiers) {
+                const hook = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
+                if (st.importKind === "type" || sp.importKind === "type" || (hook !== null && runOf(piniaStores).structs.has(hook)))
+                    continue;
+                const store = hook ? runOf(piniaStores).stores.get(hook) : undefined;
+                if (!store || store.module !== storeImport(comp, from))
+                    fail(comp, "import a store by its `use…` hook", sp);
+                own.hooks.set(sp.local.name, store);
+            }
+            return true;
+        }
+        if (from !== "pinia")
+            return false;
+        for (const sp of st.specifiers) {
+            const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
+            if (name === "storeToRefs")
+                own.storeToRefs = sp.local.name;
+            else
+                s.clientOnly.set(sp.local.name, `\`${name}\` from Pinia does not run on the server`);
+        }
+        return true;
+    },
+    scriptBinding(s, d) {
+        const comp = s.comp;
+        const own = scopeOf(piniaStores, s);
+        const init = d.init;
+        const callee = init?.type === "CallExpression" && init.callee.type === "Identifier" ? init.callee.name : null;
+        if (d.id.type === "ObjectPattern" && callee !== null && callee === own.storeToRefs) {
+            const arg = init.arguments[0];
+            const store = arg?.type === "Identifier" ? own.values.get(arg.name) : undefined;
+            if (!store || init.arguments.length !== 1)
+                fail(comp, "`storeToRefs` takes a store bound in this setup", d);
+            for (const p of d.id.properties) {
+                if (p.type !== "ObjectProperty" || p.computed || p.value.type !== "Identifier") {
+                    fail(comp, "`storeToRefs` is destructured into plain names", p);
+                }
+                const key = p.key.type === "Identifier" ? p.key.name : p.key.value;
+                const state = { code: `fv_stores.${store.field}`, ty: { k: "struct", name: store.state, store: true } };
+                s.setup.set(p.value.name, storeGetter(s, state, key, p) ?? fieldVal(comp, state.code, state.ty, key, p));
+                s.refs.add(p.value.name);
+            }
+            runOf(piniaStores).readers.add(comp);
+            return true;
+        }
+        const hook = d.id.type === "Identifier" && callee !== null ? own.hooks.get(callee) : undefined;
+        if (!hook)
+            return false;
+        if (init.arguments.length)
+            fail(comp, "a store hook takes no arguments", d);
+        own.values.set(d.id.name, hook);
+        s.setup.set(d.id.name, { code: `fv_stores.${hook.field}`, ty: { k: "struct", name: hook.state, store: true } });
+        runOf(piniaStores).readers.add(comp);
+        return true;
+    },
+    member: (s, base, prop, n, computed) => (computed ? null : storeGetter(s, base, prop, n)),
+    params: [
+        {
+            name: "fv_stores",
+            ty: "&super::stores::Stores<'_>",
+            pageTy: "&'p super::stores::Stores<'p>",
+            reads: (c) => runOf(piniaStores).readers.has(c),
+            test: { lines: ["let state: stores::Stores = serde_json::from_value(fixture.stores.clone()).map_err(|e| e.to_string())?;"], arg: "&state", fixture: true },
+            fixtureField: '    #[serde(rename = "$stores", default = "Fixture::no_stores")]\n    stores: serde_json::Value,',
+            fixtureDefault: "    fn no_stores() -> serde_json::Value {\n        serde_json::Value::Object(Default::default())\n    }",
+        },
+    ],
+    modules() {
+        const { dir, stores } = runOf(piniaStores);
+        return stores.size ? [["stores.rs", storesSource(dir.replace(/\/?$/, "/"))]] : [];
+    },
+};

package/dist/plugins/teleport.d.ts

@@ -0,0 +1,5 @@
+import { type Component } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+type TeleportRun = Set<Component>;
+export declare const teleport: Plugin<TeleportRun>;
+export {};

package/dist/plugins/teleport.js

@@ -0,0 +1,55 @@
+import { fail } from "../model.js";
+import { expr } from "../expr.js";
+import { cond } from "../narrowing.js";
+import { bare, strArg } from "../parens.js";
+import { statements } from "../template.js";
+import { runOf } from "../plugin.js";
+export const teleport = {
+    name: "teleport",
+    configure: () => new Set(),
+    compiled(comp, code) {
+        if (code.includes("_ssrRenderTeleport("))
+            runOf(teleport).add(comp);
+    },
+    statement(s, e, c, st) {
+        if (c.callee.type !== "Identifier" || c.callee.name !== "_ssrRenderTeleport")
+            return false;
+        const [, content, target, disabled] = c.arguments;
+        if (s.fill)
+            fail(s.comp, "a `<Teleport>` in slot content whose emptiness is decided at run time", st);
+        const to = expr(s, target);
+        if (to.ty.k !== "str")
+            fail(s.comp, "a `<Teleport>`'s `to` is a string", target);
+        const off = disabled ? bare(cond(s, disabled)) : "false";
+        if (content?.type !== "ArrowFunctionExpression" || content.body.type !== "BlockStatement")
+            fail(s.comp, "unexpected `<Teleport>` content", st);
+        e.open(`fv::teleport_into(out, fv_teleports, ${strArg(to.code)}, ${off}, &|out: &mut String|`);
+        statements(s, e, content.body.body);
+        e.close(");");
+        return true;
+    },
+    params: [
+        {
+            name: "fv_teleports",
+            ty: "&fv::Teleports",
+            pageTy: "&'p fv::Teleports",
+            reads: (c) => runOf(teleport).has(c),
+            test: { lines: ["let teleports = ferrovue::Teleports::new();"], arg: "&teleports", after: ["teleports_into(&mut out, teleports);"] },
+            testSupport: `/// What was teleported, after a marker, as the conformance suite writes Vue's: \`{"target":"…"}\`.
+#[cfg(test)]
+fn teleports_into(out: &mut String, teleports: ferrovue::Teleports) {
+    let targets = teleports.into_targets();
+    if targets.is_empty() {
+        return;
+    }
+    let pairs: Vec<String> = targets
+        .iter()
+        .map(|(t, html)| format!("{}:{}", serde_json::to_string(t).unwrap(), serde_json::to_string(html).unwrap()))
+        .collect();
+    out.push_str("<!--fv-teleports-->{");
+    out.push_str(&pairs.join(","));
+    out.push('}');
+}`,
+        },
+    ],
+};

package/dist/rust.d.ts

@@ -1,14 +1,11 @@
 import { type Component, type N, type Struct, type Ty } from "./model.ts";
-import { type RouteDef } from "./context.ts";
 export declare function needsLifetime(ty: Ty, comp: Component, seen?: Set<string>): boolean;
 export declare function structLifetime(st: Struct, comp: Component): boolean;
 export declare function rustTy(ty: Ty, comp: Component): string;
 export declare function structSource(st: Struct, comp: Component, doc: string): string;
 export declare function header(source: string, edit?: string): string;
-/** Rust expressions summing the lengths of the strings a value of type `ty` at `place` holds. */
 export declare function textLen(comp: Component, place: string, ty: Ty, seen?: Set<string>): string[];
+export declare function isIsland(comp: Component): boolean;
 export declare function componentSource(comp: Component, ast: N[], ssr: string, components: Map<string, Component>): string;
-export declare function modSource(comps: Component[]): string;
-export declare function storesSource(dir: string): string;
+export declare function modSource(comps: Component[], modules: string[]): string;
 export declare function typesSource(): string;
-export declare function routesSource(routes: RouteDef[], file: string): string;