ferrovue 0.1.0 → 0.2.0

package/dist/testing.d.ts

@@ -1,23 +1,3 @@
-import { type App, type Component } from "vue";
-export interface Fixture {
-    props: Record<string, unknown>;
-    slots: Record<string, string>;
-    route: string;
-    stores: Record<string, unknown>;
-}
-/** A fixture's JSON, split into the props and the rest. */
-export declare function readFixture(json: Record<string, unknown>): Fixture;
+import type { Component } from "vue";
+export { fixtureApp, readFixture, routeRecords, type Fixture, type RouteEntry, type RouterOptions } from "./fixture.ts";
 export declare function attachSsrRender(file: string, name: string, component: Component): void;
-/** A route as a routes file lists it: a path, or a path and a name. */
-export type RouteEntry = string | {
-    path: string;
-    name?: string;
-};
-/** The router options ferrovue reproduces, as the project's configuration gives them. */
-export interface RouterOptions {
-    base?: string;
-    linkActiveClass?: string;
-    linkExactActiveClass?: string;
-}
-/** An app rendering one fixture of `component`: with a router over `routes` when there are any. */
-export declare function fixtureApp(component: Component, fixture: Fixture, routes: RouteEntry[] | null, options?: RouterOptions): Promise<App>;

package/dist/testing.js

@@ -1,30 +1,10 @@
 /* What a conformance suite needs from Vue: a component's real server render, and an app that
- * renders one fixture — its props, its slots' content, and the location it is rendered at, under
- * the real vue-router.
- *
- * A fixture is a JSON object of props, plus two keys that are not props:
- * - `$slots`: each slot's content as HTML, rendered as a static node so both sides write it
- *   exactly as given; `routerView` is the page `<RouterView>` shows.
- * - `$route`: the reader's location, `/` when absent.
- * - `$stores`: Pinia's state, by store id — every store the component reads, in full, because a
- *   store absent here is built from its own `state()`, which the server never runs. */
+ * renders one fixture (`fixture.ts`, which describes a fixture's keys). */
 import { readFileSync } from "node:fs";
 import { compileScript, compileTemplate, parse as parseSfc } from "@vue/compiler-sfc";
 import * as vue from "vue";
-import { createSSRApp, createStaticVNode, defineComponent, h } from "vue";
 import * as serverRenderer from "vue/server-renderer";
-import { createPinia } from "pinia";
-import { createMemoryHistory, createRouter } from "vue-router";
-/** A fixture's JSON, split into the props and the rest. */
-export function readFixture(json) {
-    const { $slots, $route, $stores, ...props } = json;
-    return {
-        props,
-        slots: ($slots ?? {}),
-        route: $route ?? "/",
-        stores: ($stores ?? {}),
-    };
-}
+export { fixtureApp, readFixture, routeRecords } from "./fixture.js";
 /* A bundler compiles a `.vue` file for the browser, and `renderToString` on a component without
  * `ssrRender` falls back to rendering its virtual DOM — a different path with different output
  * (attribute order, `v-model` state, comment markers). So each component is given the `ssrRender`
@@ -32,10 +12,18 @@ export function readFixture(json) {
 export function attachSsrRender(file, name, component) {
     const { descriptor } = parseSfc(readFileSync(file, "utf8"), { filename: file });
     const script = compileScript(descriptor, { id: name });
+    // A `<style scoped>` component's id is the one `@vitejs/plugin-vue` gave it, which its client
+    // build carries and which ferrovue computes the same way.
+    const scopeId = component.__scopeId;
+    if (!scopeId && descriptor.styles.some((st) => st.scoped)) {
+        throw new Error(`${file}: a \`<style scoped>\` component without \`__scopeId\`: load it through \`@vitejs/plugin-vue\``);
+    }
     const { code } = compileTemplate({
         source: descriptor.template.content,
         filename: file,
-        id: name,
+        id: scopeId ?? name,
+        scoped: !!scopeId,
+        slotted: descriptor.slotted,
         ssr: true,
         ssrCssVars: [],
         compilerOptions: { bindingMetadata: script.bindings },
@@ -47,35 +35,3 @@ export function attachSsrRender(file, name, component) {
     // eslint-disable-next-line @typescript-eslint/no-implied-eval
     component.ssrRender = new Function("__vue", "__sr", body)(vue, serverRenderer);
 }
-/** The top-level nodes in a piece of HTML, which a static node needs to hydrate. */
-function nodeCount(html) {
-    const t = document.createElement("template");
-    t.innerHTML = html;
-    return t.content.childNodes.length;
-}
-const staticNode = (html) => createStaticVNode(html, nodeCount(html));
-/** An app rendering one fixture of `component`: with a router over `routes` when there are any. */
-export async function fixtureApp(component, fixture, routes, options = {}) {
-    const slots = Object.fromEntries(Object.entries(fixture.slots)
-        .filter(([name]) => name !== "routerView")
-        .map(([name, html]) => [name, () => [staticNode(html)]]));
-    const app = createSSRApp({ render: () => h(component, fixture.props, slots) });
-    // As the client hydrates: the state the server rendered with, set before any store is first used.
-    const pinia = createPinia();
-    pinia.state.value = structuredClone(fixture.stores);
-    app.use(pinia);
-    if (routes) {
-        const view = fixture.slots.routerView ?? "";
-        const View = defineComponent({ render: () => staticNode(view) });
-        const router = createRouter({
-            history: createMemoryHistory(options.base),
-            routes: routes.map((r) => (typeof r === "string" ? { path: r, component: View } : { ...r, component: View })),
-            ...(options.linkActiveClass !== undefined ? { linkActiveClass: options.linkActiveClass } : {}),
-            ...(options.linkExactActiveClass !== undefined ? { linkExactActiveClass: options.linkExactActiveClass } : {}),
-        });
-        app.use(router);
-        await router.push(fixture.route);
-        await router.isReady();
-    }
-    return app;
-}

package/dist/types.d.ts

@@ -2,4 +2,5 @@ declare const trusted: unique symbol;
 export type TrustedHtml = string & {
     readonly [trusted]: true;
 };
+export type Float = number;
 export {};

package/dist/typescript.d.ts

@@ -0,0 +1,31 @@
+import { type Component, type Field, type N, type Struct, type Ty } from "./model.ts";
+/** The local names \`TrustedHtml\` and \`Float\` are imported under from \`ferrovue/types\`. */
+export declare function typesImports(comp: Component, body: N[]): void;
+export declare function tyOfTs(comp: Component, t: N, structs: Map<string, Struct>, seen?: Set<string>): Ty;
+/** Every local name an interface or object type alias declares a struct for, and every other
+ * alias: what a type in that block may name. */
+export declare function declareTypes(comp: Component, body: N[], structs: Map<string, Struct>, aliases: Map<string, N>): N[];
+/** A relative import's file, resolved as a bundler resolves a TypeScript import. */
+export declare function resolveImport(fromFile: string, spec: string): string | null;
+/** A shared `.ts` file of types, read once: its interfaces and object types become structs in
+ * `types.rs`, its other aliases are resolved where they are used. */
+export declare function readTypeFile(file: string): void;
+/** A type read in the file that declares it, marked with where it lives for readers elsewhere. */
+export declare function markHome(ty: Ty, home: string): Ty;
+/** Where a struct type is declared: its fields, the component whose types its fields name, and
+ * the path the generated code names it by. */
+export declare function lookupStruct(comp: Component, ty: Ty & {
+    k: "struct";
+}): {
+    st: Struct | undefined;
+    owner: Component;
+    path: string;
+};
+export declare function structOf(comp: Component, name: string, members: N[], structs: Map<string, Struct>): Struct;
+/** The type literal (or interface) `defineProps<...>()` was given, seen through `withDefaults`. */
+export declare function definePropsType(call: N): N | null;
+/** The `default` of each prop in the runtime declaration `compileScript` wrote, by prop name. */
+export declare function runtimeDefaults(comp: Component, content: string): Map<string, N>;
+/** A prop's default as a Rust value of its type: a literal, or an empty list from `() => []`. */
+export declare function defaultValue(comp: Component, f: Field, node: N): string;
+export declare function markStore(ty: Ty): Ty;

package/dist/typescript.js

@@ -0,0 +1,310 @@
+/* TypeScript types read as Rust ones: props, interfaces, aliases, shared type files, defaults. */
+import { parse as parseJs } from "@babel/parser";
+import { readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { BOOL, fail, FLOAT, INT, opt, RUST_PRELUDE, rustStr, sameTy, snake, STR, tagAst } from "./model.js";
+import { CONFIG_FILE, ctx, TYPES_MODULE } from "./context.js";
+import { childOf } from "./expr.js";
+import { storeHome } from "./stores.js";
+/** The local names \`TrustedHtml\` and \`Float\` are imported under from \`ferrovue/types\`. */
+export function typesImports(comp, body) {
+    for (const s of body) {
+        if (s.type !== "ImportDeclaration" || s.source.value !== TYPES_MODULE)
+            continue;
+        for (const sp of s.specifiers) {
+            if (sp.type !== "ImportSpecifier")
+                continue;
+            const name = sp.imported.name ?? sp.imported.value;
+            if (name === "TrustedHtml")
+                comp.trustedName = sp.local.name;
+            if (name === "Float")
+                comp.floatName = sp.local.name;
+        }
+    }
+}
+export function tyOfTs(comp, t, structs, seen = new Set()) {
+    switch (t.type) {
+        case "TSStringKeyword":
+            return STR;
+        case "TSNumberKeyword":
+            return INT;
+        case "TSBooleanKeyword":
+            return BOOL;
+        case "TSArrayType":
+            return { k: "list", of: tyOfTs(comp, t.elementType, structs, seen) };
+        case "TSParenthesizedType":
+            return tyOfTs(comp, t.typeAnnotation, structs, seen);
+        case "TSTypeLiteral": {
+            // `{ [key: string]: T }`, which is `Record<string, T>`. Any other object type is an interface.
+            const [sig] = t.members;
+            const key = sig?.parameters?.[0]?.typeAnnotation?.typeAnnotation;
+            if (t.members.length === 1 && sig.type === "TSIndexSignature" && key?.type === "TSStringKeyword" && sig.typeAnnotation) {
+                return recordOf(comp, sig.typeAnnotation.typeAnnotation, structs, seen);
+            }
+            return fail(comp, "an object type in place: declare it as an interface, or as `{ [key: string]: T }` for a dictionary", t);
+        }
+        case "TSTypeOperator":
+            // `readonly string[]`: the same list, which the server never writes to anyway.
+            if (t.operator === "readonly")
+                return tyOfTs(comp, t.typeAnnotation, structs, seen);
+            break;
+        case "TSLiteralType":
+            // A literal type is a value of its kind: `"sm"` a string, `3` a number.
+            if (t.literal.type === "StringLiteral" || t.literal.type === "TemplateLiteral")
+                return STR;
+            if (t.literal.type === "NumericLiteral")
+                return Number.isInteger(t.literal.value) ? INT : FLOAT;
+            if (t.literal.type === "BooleanLiteral")
+                return BOOL;
+            break;
+        case "TSUnionType": {
+            // `"sm" | "md"` is a string; `T | undefined` is an optional `T`. `null` is a different value.
+            const parts = t.types.filter((u) => u.type !== "TSUndefinedKeyword");
+            if (t.types.some((u) => u.type === "TSNullKeyword" || (u.type === "TSLiteralType" && u.literal.type === "NullLiteral"))) {
+                return fail(comp, "`null` in a type: use `undefined`, which is what an absent value is", t);
+            }
+            const tys = parts.map((u) => tyOfTs(comp, u, structs, seen));
+            const first = tys[0];
+            if (!first || tys.some((x) => !sameTy(x, first)))
+                return fail(comp, "a union of different types has no Rust type", t);
+            return parts.length < t.types.length ? opt(first) : first;
+        }
+        case "TSTypeReference": {
+            const name = t.typeName.type === "Identifier" ? t.typeName.name : undefined;
+            if (name === undefined)
+                break;
+            // `Array<T>` and `ReadonlyArray<T>`, as `T[]`.
+            if ((name === "Array" || name === "ReadonlyArray") && t.typeParameters?.params?.length === 1) {
+                return { k: "list", of: tyOfTs(comp, t.typeParameters.params[0], structs, seen) };
+            }
+            // `Record<string, T>`, an object used as a dictionary.
+            if (name === "Record" && t.typeParameters?.params?.length === 2) {
+                const [key, value] = t.typeParameters.params;
+                if (key.type !== "TSStringKeyword")
+                    fail(comp, "a `Record` is keyed by `string`", key);
+                return recordOf(comp, value, structs, seen);
+            }
+            if (structs.has(name))
+                return { k: "struct", name };
+            if (comp.childProps.has(name))
+                return { k: "child", name: comp.childProps.get(name) };
+            if (comp.floatName !== null && name === comp.floatName)
+                return FLOAT;
+            if (comp.trustedName !== null && name === comp.trustedName) {
+                if (ctx.trustedHtml === null) {
+                    fail(comp, `a \`TrustedHtml\` prop needs \`trustedHtml\` in ${CONFIG_FILE}: the Rust type it is`, t);
+                }
+                return { k: "html" };
+            }
+            const imported = comp.importedTypes.get(name);
+            if (imported)
+                return imported;
+            const alias = comp.aliases.get(name);
+            if (alias) {
+                if (seen.has(name))
+                    fail(comp, `type \`${name}\` refers to itself through an alias`, t);
+                return tyOfTs(comp, alias, structs, new Set(seen).add(name));
+            }
+            return fail(comp, `unsupported prop type \`${name}\`: declare it as an interface in the component, or import it from a \`.ts\` file`, t);
+        }
+    }
+    return fail(comp, `unsupported prop type \`${t.type}\``, t);
+}
+/** A dictionary's type: its values strings, numbers, booleans, objects or lists of those. A value
+ * may not be optional: JSON has no `undefined` to hold. */
+function recordOf(comp, value, structs, seen) {
+    const of = tyOfTs(comp, value, structs, seen);
+    const plain = (t) => ["str", "int", "float", "bool", "struct", "child"].includes(t.k) || (t.k === "list" && plain(t.of));
+    if (!plain(of))
+        fail(comp, "a `Record`'s values are strings, numbers, booleans, objects or lists of those", value);
+    return { k: "record", of };
+}
+/** Every local name an interface or object type alias declares a struct for, and every other
+ * alias: what a type in that block may name. */
+export function declareTypes(comp, body, structs, aliases) {
+    const decls = [];
+    for (const st of body) {
+        const d = st.type === "ExportNamedDeclaration" ? st.declaration : st;
+        if (d?.type === "TSInterfaceDeclaration")
+            decls.push({ name: d.id.name, members: d.body.body, node: d });
+        else if (d?.type === "TSTypeAliasDeclaration") {
+            // An object type is a struct — but for a dictionary, `{ [key: string]: T }`, an alias of its own.
+            const dictionary = d.typeAnnotation.members?.some((m) => m.type === "TSIndexSignature");
+            if (d.typeAnnotation.type === "TSTypeLiteral" && !dictionary)
+                decls.push({ name: d.id.name, members: d.typeAnnotation.members, node: d });
+            else
+                aliases.set(d.id.name, d.typeAnnotation);
+        }
+    }
+    for (const d of decls) {
+        if (RUST_PRELUDE.has(d.name)) {
+            fail(comp, `an interface called \`${d.name}\` would hide Rust's own \`${d.name}\` in the generated code; rename it`, d.node);
+        }
+        structs.set(d.name, { name: d.name, fields: [] });
+    }
+    return decls;
+}
+/** A relative import's file, resolved as a bundler resolves a TypeScript import. */
+export function resolveImport(fromFile, spec) {
+    if (!spec.startsWith("."))
+        return null;
+    const base = resolve(ctx.rootDir, dirname(fromFile), spec);
+    for (const candidate of [base, `${base}.ts`, join(base, "index.ts"), base.replace(/\.js$/, ".ts")]) {
+        try {
+            if (statSync(candidate).isFile() && candidate.endsWith(".ts"))
+                return candidate;
+        }
+        catch {
+            // not this one
+        }
+    }
+    return null;
+}
+/** A shared `.ts` file of types, read once: its interfaces and object types become structs in
+ * `types.rs`, its other aliases are resolved where they are used. */
+export function readTypeFile(file) {
+    if (ctx.typeRead.has(file))
+        return;
+    ctx.typeRead.add(file);
+    const rel = relative(ctx.rootDir, file);
+    const home = storeHome(rel);
+    home.structs = ctx.typeStructs;
+    home.aliases = ctx.typeAliases;
+    home.source = readFileSync(file, "utf8");
+    const body = parseJs(home.source, { sourceType: "module", plugins: ["typescript"] }).program.body;
+    tagAst(body, "source");
+    typesImports(home, body);
+    const before = new Set(ctx.typeStructs.keys());
+    const local = new Map();
+    const decls = declareTypes(home, body, local, ctx.typeAliases);
+    for (const d of decls) {
+        if (before.has(d.name))
+            fail(home, `\`${d.name}\` is declared by ${ctx.typeFiles.get(d.name)} too`, d.node);
+        ctx.typeStructs.set(d.name, local.get(d.name));
+        ctx.typeFiles.set(d.name, rel);
+    }
+    for (const d of decls) {
+        const st = structOf(home, d.name, d.members, ctx.typeStructs);
+        for (const f of st.fields)
+            f.ty = markHome(f.ty, "types");
+        ctx.typeStructs.set(d.name, st);
+    }
+}
+/** A type read in the file that declares it, marked with where it lives for readers elsewhere. */
+export function markHome(ty, home) {
+    if (ty.k === "struct" && !ty.store && !ty.home && ty.name !== "Props")
+        return { ...ty, home };
+    if (ty.k === "opt" || ty.k === "list" || ty.k === "record")
+        return { ...ty, of: markHome(ty.of, home) };
+    return ty;
+}
+/** Where a struct type is declared: its fields, the component whose types its fields name, and
+ * the path the generated code names it by. */
+export function lookupStruct(comp, ty) {
+    // Named from the module being written: plainly within its own, by path from any other.
+    if (ty.store)
+        return { st: ctx.storeStructs.get(ty.name), owner: comp, path: comp.module === "stores" ? "" : "super::stores::" };
+    if (ty.home === "types")
+        return { st: ctx.typeStructs.get(ty.name), owner: comp, path: comp.module === "types" ? "" : "super::types::" };
+    if (ty.home !== undefined && ty.home !== comp.name) {
+        const owner = childOf(ty.home);
+        return { st: owner.structs.get(ty.name), owner, path: `super::${owner.module}::` };
+    }
+    return { st: ty.name === "Props" ? comp.props : comp.structs.get(ty.name), owner: comp, path: "" };
+}
+export function structOf(comp, name, members, structs) {
+    const fields = [];
+    for (const m of members) {
+        if (m.type !== "TSPropertySignature" || m.key.type !== "Identifier") {
+            fail(comp, `\`${name}\` may only hold plain named fields`, m);
+        }
+        const base = tyOfTs(comp, m.typeAnnotation.typeAnnotation, structs);
+        if (m.optional && base.k === "opt") {
+            fields.push({ js: m.key.name, rust: snake(m.key.name), ty: base });
+            continue;
+        }
+        fields.push({ js: m.key.name, rust: snake(m.key.name), ty: m.optional ? opt(base) : base });
+    }
+    return { name, fields };
+}
+/** The type literal (or interface) `defineProps<...>()` was given, seen through `withDefaults`. */
+export function definePropsType(call) {
+    if (call?.type === "CallExpression" && call.callee.type === "Identifier" && call.callee.name === "withDefaults") {
+        return definePropsType(call.arguments[0]);
+    }
+    if (call?.type === "CallExpression" &&
+        call.callee.type === "Identifier" &&
+        call.callee.name === "defineProps") {
+        return call.typeParameters?.params?.[0] ?? null;
+    }
+    return null;
+}
+/** The `default` of each prop in the runtime declaration `compileScript` wrote, by prop name. */
+export function runtimeDefaults(comp, content) {
+    const out = new Map();
+    let program;
+    try {
+        program = parseJs(content, { sourceType: "module", plugins: ["typescript"] }).program.body;
+    }
+    catch {
+        return out;
+    }
+    /** An object literal's properties, with `...{ … }` spreads opened, as `defineModel` writes them. */
+    const props = (o) => o?.type !== "ObjectExpression"
+        ? []
+        : o.properties.flatMap((p) => (p.type === "SpreadElement" ? props(p.argument) : [p]));
+    const visit = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        if (n.type === "ObjectProperty" && !n.computed && (n.key.name ?? n.key.value) === "props") {
+            // `props: { … }`, or `_mergeModels({ … }, { … })` when there is a `defineModel`.
+            const objects = n.value.type === "CallExpression" ? n.value.arguments : [n.value];
+            for (const o of objects) {
+                for (const p of props(o)) {
+                    if (p.type !== "ObjectProperty")
+                        continue;
+                    const d = props(p.value).find((q) => q.type === "ObjectProperty" && (q.key.name ?? q.key.value) === "default");
+                    if (d)
+                        out.set(p.key.name ?? p.key.value, d.value);
+                }
+            }
+            return;
+        }
+        for (const k of Object.keys(n)) {
+            if (k === "loc" || k === "start" || k === "end")
+                continue;
+            const v = n[k];
+            if (Array.isArray(v))
+                v.forEach(visit);
+            else if (v && typeof v === "object" && typeof v.type === "string")
+                visit(v);
+        }
+    };
+    program.forEach(visit);
+    void comp;
+    return out;
+}
+/** A prop's default as a Rust value of its type: a literal, or an empty list from `() => []`. */
+export function defaultValue(comp, f, node) {
+    const of = f.ty.k === "opt" ? f.ty.of : f.ty;
+    if (of.k === "str" && node.type === "StringLiteral")
+        return rustStr(node.value);
+    if (of.k === "int" && node.type === "NumericLiteral" && Number.isInteger(node.value))
+        return `${node.value}i64`;
+    if (of.k === "int" && node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral" && Number.isInteger(node.argument.value)) {
+        return `-${node.argument.value}i64`;
+    }
+    if (of.k === "bool" && node.type === "BooleanLiteral")
+        return String(node.value);
+    if (of.k === "list" && node.type === "ArrowFunctionExpression" && node.body.type === "ArrayExpression" && node.body.elements.length === 0) {
+        return "&[]";
+    }
+    return fail(comp, `the default of \`${f.js}\` must be a literal of its type, or \`() => []\` for a list`, node);
+}
+export 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;
+}

package/dist/vite.d.ts

@@ -0,0 +1,23 @@
+import type { Plugin, ResolvedConfig } from "vite";
+export interface FerrovueOptions {
+    /** The directory holding `ferrovue.config.json`: Vite's working directory by default. */
+    root?: string;
+}
+/** Whether a changed file can change what is generated: a component, a store or type file, the
+ * routes or the configuration — anything but the output itself, dependencies and build output. */
+export declare function affects(root: string, file: string): boolean;
+/** How `@vitejs/plugin-vue`, as this build configures it, computes a `<style scoped>` id: from the
+ * path alone or the path and source, hashed from Vite's root. `null` without the plugin, or with an
+ * id generator of its own. */
+export declare function vueScopeIds(config: ResolvedConfig): {
+    mode: "filepath" | "filepath-source";
+    root: string;
+} | null;
+/** Why the server's scope ids would differ from the client's, when a component has `<style scoped>`
+ * and `ferrovue.config.json` computes them otherwise than plugin-vue: a page would hydrate cleanly
+ * and show unstyled. */
+export declare function scopeIdMismatch(root: string, vue: {
+    mode: string;
+    root: string;
+} | null): string | null;
+export default function ferrovue(options?: FerrovueOptions): Plugin;

package/dist/vite.js

@@ -0,0 +1,114 @@
+/* `ferrovue/vite`: the Rust renderers regenerated as part of a Vite build and its dev server.
+ *
+ *   import ferrovue from "ferrovue/vite";
+ *   export default defineConfig({ plugins: [vue(), ferrovue()] });
+ *
+ * A build regenerates them once and fails on a construct ferrovue refuses, naming the line in the
+ * `.vue` file. The dev server regenerates them whenever a component, store, type file, the routes
+ * or the configuration changes, and shows a refusal in its error overlay. Only files whose text
+ * changed are rewritten, so `cargo watch` rebuilds no more than it must. */
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { CONFIG_FILE, GenError, loadConfig, write } from "./compiler.js";
+/** Whether a changed file can change what is generated: a component, a store or type file, the
+ * routes or the configuration — anything but the output itself, dependencies and build output. */
+export function affects(root, file) {
+    const rel = relative(root, file);
+    if (rel.startsWith("..") || !/\.(vue|ts|json)$/.test(rel))
+        return false;
+    let out = "";
+    try {
+        out = loadConfig(root).out;
+    }
+    catch {
+        // A broken configuration ignores nothing; regenerating reports it.
+    }
+    const parts = rel.split(sep);
+    if (parts.some((p) => p === "node_modules" || p === "target" || p === ".git" || p === "dist"))
+        return false;
+    return out === "" || !(rel === out || rel.startsWith(out + sep));
+}
+/** How `@vitejs/plugin-vue`, as this build configures it, computes a `<style scoped>` id: from the
+ * path alone or the path and source, hashed from Vite's root. `null` without the plugin, or with an
+ * id generator of its own. */
+export function vueScopeIds(config) {
+    const vue = config.plugins.find((p) => p.name === "vite:vue");
+    const generator = vue?.api?.options?.features?.componentIdGenerator;
+    if (!vue || (generator !== undefined && generator !== "filepath" && generator !== "filepath-source"))
+        return null;
+    return { mode: generator ?? (config.isProduction ? "filepath-source" : "filepath"), root: resolve(config.root) };
+}
+/** Why the server's scope ids would differ from the client's, when a component has `<style scoped>`
+ * and `ferrovue.config.json` computes them otherwise than plugin-vue: a page would hydrate cleanly
+ * and show unstyled. */
+export function scopeIdMismatch(root, vue) {
+    if (!vue)
+        return null;
+    const config = loadConfig(root);
+    const mode = config.scopeId ?? "filepath-source";
+    const viteRoot = resolve(root, config.viteRoot ?? ".");
+    if (mode === vue.mode && viteRoot === vue.root)
+        return null;
+    let files = [];
+    try {
+        files = readdirSync(join(root, config.components)).filter((f) => f.endsWith(".vue"));
+    }
+    catch {
+        // No components: generating reports it.
+    }
+    if (!files.some((f) => /<style\b[^>]*\bscoped\b/.test(readFileSync(join(root, config.components, f), "utf8"))))
+        return null;
+    return `\`<style scoped>\` ids: @vitejs/plugin-vue hashes "${vue.mode}" from ${vue.root}, ${CONFIG_FILE} "${mode}" from ${viteRoot}; set \`scopeId\` and \`viteRoot\` to match, or plugin-vue's \`features.componentIdGenerator\``;
+}
+export default function ferrovue(options = {}) {
+    const root = resolve(options.root ?? process.cwd());
+    const regenerate = () => write(root, loadConfig(root));
+    let vue = null;
+    let building = true;
+    return {
+        name: "ferrovue",
+        configResolved(config) {
+            vue = vueScopeIds(config);
+            building = config.command === "build";
+        },
+        buildStart() {
+            try {
+                regenerate();
+                // A build whose styles would not apply to the server's pages fails, as a refusal does; the
+                // dev server warns.
+                const mismatch = scopeIdMismatch(root, vue);
+                if (mismatch && building)
+                    this.error(`ferrovue: ${mismatch}`);
+                if (mismatch)
+                    this.warn(`ferrovue: ${mismatch}`);
+            }
+            catch (e) {
+                if (e instanceof GenError || e instanceof SyntaxError)
+                    this.error(e.message);
+                throw e;
+            }
+        },
+        configureServer(server) {
+            server.watcher.add(resolve(root, CONFIG_FILE));
+            const onChange = (file) => {
+                if (!affects(root, file))
+                    return;
+                try {
+                    const { changed, removed } = regenerate();
+                    if (changed.length || removed.length) {
+                        server.config.logger.info(`ferrovue: ${changed.length} changed, ${removed.length} removed`, { timestamp: true });
+                    }
+                }
+                catch (e) {
+                    if (!(e instanceof GenError || e instanceof SyntaxError))
+                        throw e;
+                    server.config.logger.error(`ferrovue: ${e.message}`, { timestamp: true });
+                    server.ws.send({ type: "error", err: { message: `ferrovue: ${e.message}`, stack: "", plugin: "ferrovue" } });
+                }
+            };
+            server.watcher.on("change", onChange);
+            server.watcher.on("add", onChange);
+            server.watcher.on("unlink", onChange);
+        },
+    };
+}