ferrovue 0.3.0 → 0.4.0

package/dist/plugins/router.d.ts

@@ -0,0 +1,42 @@
+import { type Component } from "../model.ts";
+import { type Plugin } from "../plugin.ts";
+declare module "../model.ts" {
+    interface PluginTys {
+        route: {
+            k: "route";
+        };
+        params: {
+            k: "params";
+        };
+        queryobj: {
+            k: "queryobj";
+        };
+        query: {
+            k: "query";
+        };
+    }
+}
+export interface RouteDef {
+    path: string;
+    name?: string;
+    children?: RouteDef[];
+    fullPath: string;
+}
+export declare function allRoutes(routes: RouteDef[]): RouteDef[];
+interface RouterRun {
+    routes: RouteDef[] | null;
+    file: string | null;
+    base: string;
+    linkActive: string;
+    linkExactActive: string;
+    readers: Set<Component>;
+    views: Set<Component>;
+}
+interface RouterScope {
+    useRoute: string | null;
+    components: Map<string, "RouterLink" | "RouterView">;
+}
+export declare function readRoutes(root: string, file: string): RouteDef[];
+export declare function routesSource(routes: RouteDef[], file: string): string;
+export declare const router: Plugin<RouterRun, RouterScope>;
+export {};

package/dist/plugins/router.js

@@ -0,0 +1,256 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { BOOL, fail, GenError, opt, rustStr, STR } from "../model.js";
+import { CONFIG_FILE } from "../context.js";
+import { expr } from "../expr.js";
+import { boolOf, pathOf } from "../narrowing.js";
+import { atom, bare, not, strArg } from "../parens.js";
+import { runOf, scopeOf } from "../plugin.js";
+import { header } from "../rust.js";
+import { scopeIdOf } from "./scoped.js";
+import { routerLink } from "./router-link.js";
+export function allRoutes(routes) {
+    return routes.flatMap((r) => [r, ...allRoutes(r.children ?? [])]);
+}
+function typeofString(n) {
+    if (n.type !== "BinaryExpression" || (n.operator !== "===" && n.operator !== "!=="))
+        return null;
+    const isTypeof = (m) => m.type === "UnaryExpression" && m.operator === "typeof";
+    const isString = (m) => m.type === "StringLiteral" && m.value === "string";
+    const target = isTypeof(n.left) && isString(n.right) ? n.left.argument : isTypeof(n.right) && isString(n.left) ? n.right.argument : null;
+    return target ? { target, negated: n.operator === "!==" } : null;
+}
+function theRoute(s, n) {
+    if (!runOf(router).routes)
+        fail(s.comp, `reading the route needs \`routes\` in ${CONFIG_FILE}`, n);
+    runOf(router).readers.add(s.comp);
+    return { code: "fv_route", ty: { k: "route" } };
+}
+function routeField(s, base, prop, n) {
+    if (base.ty.k === "params") {
+        return { code: `fv_route.param(${rustStr(prop)})`, ty: opt(STR) };
+    }
+    if (base.ty.k === "queryobj")
+        return { code: `fv_route.query(${rustStr(prop)})`, ty: { k: "query" } };
+    switch (prop) {
+        case "path":
+            return { code: "fv_route.path()", ty: STR };
+        case "hash":
+            return { code: "fv_route.hash()", ty: STR };
+        case "name":
+            return { code: "fv_route.name()", ty: opt(STR) };
+        case "params":
+            return { code: "fv_route", ty: { k: "params" } };
+        case "query":
+            return { code: "fv_route", ty: { k: "queryobj" } };
+        case "fullPath":
+            return { code: "fv_route.full_path()", ty: STR };
+    }
+    return fail(s.comp, `\`route.${prop}\` is not available on the server: \`path\`, \`fullPath\`, \`hash\`, \`name\`, \`params\` and \`query\` are`, n);
+}
+export function readRoutes(root, file) {
+    const raw = JSON.parse(readFileSync(join(root, file), "utf8"));
+    if (!Array.isArray(raw))
+        throw new GenError(`${file} lists the routes in an array`);
+    const read = (list, parent) => list.map((r) => {
+        const o = (typeof r === "string" ? { path: r } : r);
+        if (typeof o?.path !== "string" || (o.name !== undefined && typeof o.name !== "string") || (o.children !== undefined && !Array.isArray(o.children))) {
+            throw new GenError(`${file}: a route is a path, or \`{ "path": "…", "name": "…", "children": [ … ] }\``);
+        }
+        const fullPath = parent === null || o.path.startsWith("/") ? o.path : `${parent}${parent.endsWith("/") || o.path === "" ? "" : "/"}${o.path}`;
+        const def = { path: o.path, fullPath };
+        if (o.name !== undefined)
+            def.name = o.name;
+        if (o.children)
+            def.children = read(o.children, fullPath);
+        return def;
+    });
+    return read(raw, null);
+}
+function routeDefs(routes, depth) {
+    const pad = "    ".repeat(depth);
+    return routes
+        .map((r) => {
+        const name = r.name === undefined ? "None" : `Some(${rustStr(r.name)})`;
+        const children = r.children?.length ? `&[\n${routeDefs(r.children, depth + 1)}\n${pad}]` : "&[]";
+        return `${pad}ferrovue::RouteDef { path: ${rustStr(r.path)}, name: ${name}, children: ${children} },`;
+    })
+        .join("\n");
+}
+export function routesSource(routes, file) {
+    return `${header(file, "the routes file")}
+//! The app's routes: what \`<RouterLink>\` resolves against and \`useRoute()\` reads.
+
+/// Each route: its vue-router path, its name if it has one, and the routes nested in it.
+pub const ROUTES: &[ferrovue::RouteDef<'static>] = &[
+${routeDefs(routes, 1)}
+];
+
+/// Every route's full path, nested ones included.
+pub const PATHS: &[&str] = &[
+${allRoutes(routes).map((r) => `    ${rustStr(r.fullPath)},`).join("\n")}
+];
+
+/// The history's base, which every link's \`href\` starts with.
+pub const BASE: &str = ${rustStr(runOf(router).base)};
+
+/// The router these routes make: build it once, and resolve each request's location with
+/// [\`ferrovue::Router::at\`].
+pub fn router() -> ferrovue::Router {
+    ferrovue::Router::tree(ROUTES).with_base(BASE)
+}
+`;
+}
+export const router = {
+    name: "router",
+    configure(config, root) {
+        const r = config.router ?? (config.routes ? { routes: config.routes } : null);
+        return {
+            routes: r ? readRoutes(root, r.routes) : null,
+            file: r?.routes ?? null,
+            base: r?.base ?? "",
+            linkActive: r?.linkActiveClass ?? "router-link-active",
+            linkExactActive: r?.linkExactActiveClass ?? "router-link-exact-active",
+            readers: new Set(),
+            views: new Set(),
+        };
+    },
+    compiled(comp, code, script) {
+        const imported = (exported) => script.some((st) => st.type === "ImportDeclaration" && st.source.value === "vue-router" &&
+            st.specifiers.some((sp) => sp.type === "ImportSpecifier" && (sp.imported.name ?? sp.imported.value) === exported));
+        const run = runOf(router);
+        if (code.includes('_resolveComponent("RouterLink")') || imported("RouterLink") || code.includes("_ctx.$route"))
+            run.readers.add(comp);
+        if (code.includes('_resolveComponent("RouterView")') || imported("RouterView"))
+            run.views.add(comp);
+    },
+    scope: () => ({ useRoute: null, components: new Map() }),
+    scriptImport(s, st, from) {
+        if (from !== "vue-router")
+            return false;
+        const own = scopeOf(router, s);
+        for (const sp of st.specifiers) {
+            const name = sp.type === "ImportSpecifier" ? (sp.imported.name ?? sp.imported.value) : null;
+            if (name === "useRoute")
+                own.useRoute = sp.local.name;
+            else if (name === "RouterLink" || name === "RouterView")
+                own.components.set(sp.local.name, name);
+            else
+                s.clientOnly.set(sp.local.name, `\`${name}\` from vue-router does not run on the server`);
+        }
+        return true;
+    },
+    scriptBinding(s, d) {
+        const { useRoute } = scopeOf(router, s);
+        const init = d.init;
+        if (useRoute === null || d.id.type !== "Identifier" || init?.type !== "CallExpression" || init.callee.type !== "Identifier" || init.callee.name !== useRoute)
+            return false;
+        s.setup.set(d.id.name, theRoute(s, d));
+        return true;
+    },
+    global: (s, name, n) => (name === "$route" ? theRoute(s, n) : null),
+    member(s, base, prop, n, computed) {
+        if (base.ty.k === "params" || base.ty.k === "queryobj" || (base.ty.k === "route" && !computed))
+            return routeField(s, base, prop, n);
+        return null;
+    },
+    equality(s, n) {
+        const tested = typeofString(n);
+        if (!tested)
+            return null;
+        const v = expr(s, tested.target);
+        if (v.ty.k !== "query")
+            fail(s.comp, '`typeof` tests a query value only, as `typeof route.query.q === "string"`', n);
+        const one = `${atom(v.code)}.attr_value().is_some()`;
+        return boolOf(tested.negated ? not(one) : one);
+    },
+    presence(s, n) {
+        const t = typeofString(n);
+        if (!t)
+            return undefined;
+        const path = pathOf(t.target);
+        const v = expr(s, t.target);
+        if (path === null || v.ty.k !== "query")
+            return null;
+        const option = `${atom(v.code)}.attr_value()`;
+        return { path, of: STR, negated: t.negated, truthy: false, option, present: `${option}.is_some()`, pattern: (name) => `let Some(${name}) = ${option}` };
+    },
+    values: {
+        describe: (ty) => (ty.k === "query" ? "a query value" : undefined),
+        truthy: (v) => (v.ty.k === "query" ? `${atom(v.code)}.truthy()` : undefined),
+        interpolate(e, v) {
+            if (v.ty.k !== "query")
+                return false;
+            e.stmt(`${atom(v.code)}.write_display(out);`);
+            return true;
+        },
+        unbindable: (ty) => ty.k === "query"
+            ? { what: "a query value, which is an array when its key is repeated", fix: 'narrow it to one string, as `typeof route.query.q === "string" ? route.query.q : ""`' }
+            : undefined,
+        nullish(s, a, b, n) {
+            if (a.ty.k !== "query")
+                return undefined;
+            if (b.ty.k !== "str")
+                fail(s.comp, "`??` after a query value takes a string", n);
+            return { code: `${atom(a.code)}.or(${bare(b.code)})`, ty: a.ty };
+        },
+        equals(a, b) {
+            if (a.ty.k === "query" && b.ty.k === "str")
+                return `${atom(a.code)}.is(${strArg(b.code)})`;
+            if (b.ty.k === "query" && a.ty.k === "str")
+                return `${atom(b.code)}.is(${strArg(a.code)})`;
+            if (a.ty.k === "query" && b.ty.k === "undef")
+                return `${atom(a.code)}.is_undefined()`;
+            if (b.ty.k === "query" && a.ty.k === "undef")
+                return `${atom(b.code)}.is_undefined()`;
+            return undefined;
+        },
+        isArray: (v) => (v.ty.k === "query" ? { code: `${atom(v.code)}.is_array()`, ty: BOOL } : undefined),
+    },
+    resolveComponent(s, local, name) {
+        if (name !== "RouterLink" && name !== "RouterView")
+            return false;
+        scopeOf(router, s).components.set(local, name);
+        return true;
+    },
+    component(s, e, n) {
+        const target = n.arguments[0];
+        const { components } = scopeOf(router, s);
+        const routed = target.type === "Identifier"
+            ? components.get(target.name)
+            : target.type === "MemberExpression" && target.object.name === "$setup"
+                ? components.get(target.computed ? target.property.value : target.property.name)
+                : undefined;
+        if (routed === "RouterLink")
+            routerLink(s, e, n);
+        else if (routed === "RouterView") {
+            if (scopeIdOf(s.comp) !== null)
+                fail(s.comp, "`<RouterView>` in a component with `<style scoped>` gives the page this component's id, which the server's page does not carry", n);
+            e.stmt("fv_slots.router_view.render_to(out);");
+        }
+        else
+            return false;
+        return true;
+    },
+    child(s, child, n) {
+        if (runOf(router).views.has(child)) {
+            fail(s.comp, `${child.name} holds \`<RouterView>\`: the server renders it at the top, never as a child`, n);
+        }
+    },
+    slotFields: (comp) => (runOf(router).views.has(comp) ? [{ js: "routerView", rust: "router_view", doc: "The page `<RouterView>` shows." }] : []),
+    params: [
+        {
+            name: "fv_route",
+            ty: "&fv::Route<'_>",
+            pageTy: "&'p fv::Route<'p>",
+            reads: (c) => runOf(router).readers.has(c),
+            test: { lines: ["let router = route_table::router();", "let route = router.at(&fixture.route);"], arg: "&route", fixture: true },
+            fixtureField: '    #[serde(rename = "$route", default = "Fixture::root")]\n    route: String,',
+            fixtureDefault: '    fn root() -> String {\n        "/".to_owned()\n    }',
+        },
+    ],
+    modules() {
+        const { routes, file } = runOf(router);
+        return routes ? [["route_table.rs", routesSource(routes, file)]] : [];
+    },
+};

package/dist/plugins/scoped.d.ts

@@ -0,0 +1,12 @@
+import { type Component } from "../model.ts";
+import { type ScopeIdMode } from "../context.ts";
+import { type Plugin } from "../plugin.ts";
+interface ScopedRun {
+    mode: ScopeIdMode;
+    viteRoot: string;
+    ids: Map<Component, string>;
+    slotted: Set<Component>;
+}
+export declare function scopeIdOf(comp: Component): string | null;
+export declare const scoped: Plugin<ScopedRun>;
+export {};

package/dist/plugins/scoped.js

@@ -0,0 +1,125 @@
+import { parse as parseJs } from "@babel/parser";
+import { createHash } from "node:crypto";
+import { relative, resolve as resolvePath, sep } from "node:path";
+import { fail, rustStr } from "../model.js";
+import {} from "../context.js";
+import { runOf } from "../plugin.js";
+export function scopeIdOf(comp) {
+    return runOf(scoped).ids.get(comp) ?? null;
+}
+function scopeHash(file, source) {
+    const { mode, viteRoot } = runOf(scoped);
+    const path = relative(viteRoot, resolvePath(file)).split(sep).join("/");
+    return createHash("sha256")
+        .update(mode === "filepath" ? path : path + source)
+        .digest("hex")
+        .slice(0, 8);
+}
+function flowOf(comp, ssr, children) {
+    const calls = [];
+    const outlets = [];
+    const self = new Set();
+    const resolve = (target) => {
+        if (target?.type === "MemberExpression" && target.object.name === "$setup") {
+            return children.get(target.computed ? target.property.value : target.property.name) ?? null;
+        }
+        return target?.type === "Identifier" && self.has(target.name) ? comp.name : null;
+    };
+    const mentions = (n, name) => !!n && typeof n === "object" && (n.type === "Identifier" ? n.name === name : Object.values(n).some((v) => mentions(v, name)));
+    const walk = (n, within) => {
+        if (!n || typeof n !== "object")
+            return;
+        if (Array.isArray(n)) {
+            for (const x of n)
+                walk(x, within);
+            return;
+        }
+        if (n.type === "VariableDeclarator" && n.init?.type === "CallExpression" && n.init.callee.name === "_resolveComponent") {
+            if (n.init.arguments[0]?.value === comp.name && n.init.arguments[1])
+                self.add(n.id.name);
+        }
+        if (n.type === "CallExpression" && n.callee.type === "Identifier") {
+            const a = n.arguments;
+            if (n.callee.name === "_ssrRenderComponent") {
+                const child = resolve(a[0]);
+                if (child)
+                    calls.push({ child, passesAttrs: mentions(a[1], "_attrs"), within: a[4] ? within : null });
+                walk(a[2], child);
+                return;
+            }
+            if (n.callee.name === "_ssrRenderSlot" || n.callee.name === "_ssrRenderSlotInner") {
+                const id = a[6];
+                const passes = !id || id.type === "NullLiteral" ? "none" : id.type === "Identifier" && id.name === "_scopeId" ? "forward" : "id";
+                outlets.push({ passes, within });
+            }
+        }
+        for (const [key, v] of Object.entries(n))
+            if (key !== "loc" && key !== "start" && key !== "end")
+                walk(v, within);
+    };
+    walk(parseJs(ssr, { sourceType: "module" }).program, null);
+    return { calls, outlets };
+}
+function scopeFlow(read) {
+    const flows = read.map((r) => ({ comp: r.comp, ...flowOf(r.comp, r.ssr, r.children) }));
+    const byName = new Map(read.map((r) => [r.comp.name, r.comp]));
+    const passes = (name) => (name !== null && byName.get(name)?.passesSlotIds) ?? false;
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const f of flows) {
+            if (!f.comp.passesSlotIds && f.outlets.some((o) => o.passes === "id" || (o.passes === "forward" && passes(o.within)))) {
+                f.comp.passesSlotIds = changed = true;
+            }
+        }
+    }
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const f of flows) {
+            for (const c of f.calls) {
+                const child = byName.get(c.child);
+                if (!child || child.inherits)
+                    continue;
+                if (scopeIdOf(f.comp) !== null || (c.passesAttrs && f.comp.inherits && child.inheritAttrs) || passes(c.within)) {
+                    child.inherits = changed = true;
+                }
+            }
+        }
+    }
+}
+function childIds(s, child, passesAttrs, inSlot, n) {
+    const base = passesAttrs && child.inheritAttrs ? s.attrs : null;
+    const own = scopeIdOf(s.comp);
+    const slotted = inSlot ? s.sid : null;
+    let code;
+    if (base === null && slotted === null)
+        code = own === null ? null : rustStr(` ${own}`);
+    else if (own === null && slotted === null)
+        code = base;
+    else
+        code = `&fv::scope_attrs(${base ?? '""'}, ${own === null ? '""' : rustStr(own)}, ${slotted ?? '""'})`;
+    if (code !== null && !child.inherits)
+        fail(s.comp, `${child.name} is handed scope ids its render does not take`, n);
+    return code;
+}
+export const scoped = {
+    name: "scoped",
+    configure: (config, root) => ({
+        mode: config.scopeId ?? "filepath-source",
+        viteRoot: resolvePath(root, config.viteRoot ?? "."),
+        ids: new Map(),
+        slotted: new Set(),
+    }),
+    sfc(comp, descriptor, file, source) {
+        const run = runOf(scoped);
+        if (descriptor.styles.some((st) => st.scoped))
+            run.ids.set(comp, `data-v-${scopeHash(file, source)}`);
+        if (descriptor.slotted)
+            run.slotted.add(comp);
+    },
+    templateOptions(comp) {
+        const id = scopeIdOf(comp);
+        return { id: id ?? comp.name, scoped: id !== null, slotted: runOf(scoped).slotted.has(comp) };
+    },
+    analyse: (read) => scopeFlow(read),
+    childIds,
+};

package/dist/plugins/shared-types.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "../plugin.ts";
+export declare const sharedTypes: Plugin;

package/dist/plugins/shared-types.js

@@ -0,0 +1,7 @@
+import { ctx } from "../context.js";
+import { typesSource } from "../rust.js";
+import {} from "../plugin.js";
+export const sharedTypes = {
+    name: "types",
+    modules: () => (ctx.typeStructs.size ? [["types.rs", typesSource()]] : []),
+};

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 {};