vitempl 0.0.0 → 0.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Stepan Sotnikov
+Copyright (c) 2026 Stepan Sotnikov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -1,15 +1,13 @@
 # vitempl
 
-Vitempl (словосочетание от vite и template engine) разработка шаблонов на vite. Основные задачи:
+Vite-плагин: собирает шаблоны для серверного рендеринга (Handlebars, askama, Jinja) из компонентов Vue (SFC). Документация — в [docs](../../docs/index.md).
 
-- разработка шаблонов в компонентном стиле, например, разрабатывать в стиле vue, при билде получать шаблоны
-- типизация шаблонов
+## Скрипты
 
-## Использование
-
-Для веб приложений, которые используют шаблонизаторы.
-
-> WIP
+- `npm run dev` — сборка с пересборкой при изменении исходников (dev-режим)
+- `npm run build` — проверка типов и сборка в `dist/`
+- `npm run typecheck` — проверка типов
+- `npm run test` — запуск тестов
 
 ## Лицензия
 

package/dist/engine-BqkJbOwH.d.ts

@@ -0,0 +1,58 @@
+import { TemplateChildNode } from "@vue/compiler-core";
+//#region src/engine.d.ts
+/**
+ * Шаблонизатор, для которого собираются шаблоны.
+ *
+ * Исходники шаблонов всегда пишутся на Vue SFC, а шаблоны для сервера
+ * генерирует адаптер шаблонизатора. Для другого шаблонизатора
+ * (Jinja, Tera и т.п.) пишется свой адаптер, исходники и ядро плагина
+ * при этом не меняются.
+ */
+interface TemplateEngine {
+  /** Название шаблонизатора для сообщений */
+  name: string;
+  /** Расширение собранных шаблонов, например `.hbs` */
+  extension: string;
+  /**
+   * Разбирает шаблон до генерации. Нужен шаблонизаторам, где вызов
+   * компонента зависит от самого компонента: например, в Jinja и askama
+   * компонент становится макросом, и вызывающий должен знать его параметры.
+   */
+  analyze?(nodes: TemplateChildNode[], context: GenerateContext): TemplateInfo;
+  /** Генерирует шаблон из шаблона Vue SFC */
+  generate(nodes: TemplateChildNode[], context: GenerateContext): GenerateResult;
+}
+interface GenerateContext {
+  /** Импортированные компоненты: имя тега (`AppHeader`, `app-header`) → имя шаблона (`partials/AppHeader`) */
+  components: Map<string, string>;
+  /** Имя самого шаблона: путь от папки исходников без расширения */
+  name: string;
+  /** Шаблон — вход сборки (страница или фрагмент): его данные готовит сервер */
+  entry: boolean;
+  /**
+   * Результаты `analyze` по именам шаблонов. Во время `analyze` заполняется
+   * и полным становится только к генерации, а у шаблонизаторов без `analyze`
+   * и при проверке одного файла остаётся пустым.
+   */
+  templates: ReadonlyMap<string, TemplateInfo>;
+}
+interface TemplateInfo {
+  /** Данные, к которым обращается шаблон: props компонента, которые он использует */
+  params: string[];
+  /** В шаблоне есть слот */
+  hasSlot: boolean;
+}
+interface GenerateResult {
+  code: string;
+  errors: TemplateDiagnostic[];
+}
+interface TemplateLocation {
+  line: number;
+  column: number;
+}
+interface TemplateDiagnostic {
+  message: string;
+  loc: TemplateLocation;
+}
+//#endregion
+export { TemplateInfo as a, TemplateEngine as i, GenerateResult as n, TemplateLocation as o, TemplateDiagnostic as r, GenerateContext as t };

package/dist/engines/askama.d.ts

@@ -0,0 +1,12 @@
+import { i as TemplateEngine } from "../engine-BqkJbOwH.js";
+//#region src/engines/askama.d.ts
+/**
+ * askama: компилируемые в Rust шаблоны на основе Jinja.
+ *
+ * Шаблоны становятся частью бинарника при сборке сервера, данные приходят
+ * из структуры, поэтому выражения в них — выражения Rust: условие должно
+ * быть `bool`, а необязательное значение проверяется на null
+ * (`user != null` превращается в `{% if let Some(user) = user %}`).
+ */
+export declare function askama(): TemplateEngine;
+//#endregion

package/dist/engines/askama.js

@@ -0,0 +1,28 @@
+import { t as jinjaEngine } from "../jinja-like-BokTIprh.js";
+//#region src/engines/askama.ts
+/**
+* askama: компилируемые в Rust шаблоны на основе Jinja.
+*
+* Шаблоны становятся частью бинарника при сборке сервера, данные приходят
+* из структуры, поэтому выражения в них — выражения Rust: условие должно
+* быть `bool`, а необязательное значение проверяется на null
+* (`user != null` превращается в `{% if let Some(user) = user %}`).
+*/
+function askama() {
+	return jinjaEngine({
+		name: "askama",
+		extension: ".html",
+		elseIf: "else if",
+		assign: "let",
+		namespace: "::",
+		not: (condition) => `!${condition}`,
+		and: "&&",
+		or: "||",
+		some: (path, alias) => `let Some(${alias}) = ${path}`,
+		none: (path) => `${path}.is_none()`,
+		binds: true,
+		recursion: false
+	});
+}
+//#endregion
+export { askama };

package/dist/engines/handlebars.d.ts

@@ -0,0 +1,5 @@
+import { i as TemplateEngine } from "../engine-BqkJbOwH.js";
+//#region src/engines/handlebars.d.ts
+/** Handlebars: компоненты становятся partials, слот по умолчанию — partial-блоком */
+export declare function handlebars(): TemplateEngine;
+//#endregion

package/dist/engines/handlebars.js

@@ -0,0 +1,383 @@
+import { camelize, escapeHtml, isBooleanAttr, isGloballyAllowed, isVoidTag } from "@vue/shared";
+import { ElementTypes, NodeTypes } from "@vue/compiler-core";
+//#region src/engines/handlebars.ts
+/** Директивы, которые обрабатываются на уровне элемента */
+const STRUCTURAL = /* @__PURE__ */ new Set([
+	"if",
+	"else-if",
+	"else",
+	"for"
+]);
+/** Handlebars: компоненты становятся partials, слот по умолчанию — partial-блоком */
+function handlebars() {
+	return {
+		name: "handlebars",
+		extension: ".hbs",
+		generate: generateHandlebars
+	};
+}
+/**
+* Генерирует шаблон Handlebars из шаблона Vue SFC.
+*
+* Поддерживается подмножество Vue, которое однозначно переводится
+* в Handlebars: пути к данным, v-if/v-else-if/v-else, v-for по массивам,
+* атрибуты, компоненты (partials) и слот по умолчанию (partial-блок).
+* Всё остальное — ошибка компиляции.
+*/
+function generateHandlebars(nodes, { components }) {
+	const errors = [];
+	const error = (message, loc) => {
+		errors.push({
+			message,
+			loc: {
+				line: loc.start.line,
+				column: loc.start.column
+			}
+		});
+		return "";
+	};
+	function children(nodes, scope) {
+		let out = "";
+		for (let i = 0; i < nodes.length; i++) {
+			const node = nodes[i];
+			if (node.type !== NodeTypes.ELEMENT) {
+				out += child(node, scope);
+				continue;
+			}
+			const vIf = findDirective(node, "if");
+			if (!vIf) {
+				const vElse = findDirective(node, "else-if") ?? findDirective(node, "else");
+				out += vElse ? error("v-else без v-if", vElse.loc) : element(node, scope);
+				continue;
+			}
+			const chain = [{
+				node,
+				directive: vIf
+			}];
+			for (let j = i + 1; j < nodes.length; j++) {
+				const next = nodes[j];
+				if (isBlank(next)) continue;
+				const directive = next.type === NodeTypes.ELEMENT ? findDirective(next, "else-if") ?? findDirective(next, "else") : void 0;
+				if (next.type !== NodeTypes.ELEMENT || !directive) break;
+				chain.push({
+					node: next,
+					directive
+				});
+				i = j;
+				if (directive.name === "else") break;
+			}
+			out += ifChain(chain, scope);
+		}
+		return out;
+	}
+	function child(node, scope) {
+		switch (node.type) {
+			case NodeTypes.TEXT: return escapeMustache(node.loc.source);
+			case NodeTypes.COMMENT: return "";
+			case NodeTypes.INTERPOLATION: {
+				const path = toPath(node.content, scope, node.loc);
+				return path ? `{{${path}}}` : "";
+			}
+			default: return error("неподдерживаемый узел шаблона", node.loc);
+		}
+	}
+	function ifChain(chain, scope) {
+		let helper = "if";
+		let out = "";
+		chain.forEach(({ node, directive }, index) => {
+			const body = element(node, scope);
+			if (directive.name === "else") {
+				out += `{{else}}${body}`;
+				return;
+			}
+			const condition = toCondition(directive.exp, scope, directive.loc);
+			if (!condition) return;
+			if (index === 0) {
+				helper = condition.helper;
+				out += `{{#${condition.helper} ${condition.path}}}${body}`;
+			} else out += `{{else ${condition.helper} ${condition.path}}}${body}`;
+		});
+		return `${out}{{/${helper}}}`;
+	}
+	function element(node, scope) {
+		const vFor = findDirective(node, "for");
+		return vFor ? forLoop(node, vFor, scope) : elementBody(node, scope);
+	}
+	function forLoop(node, directive, scope) {
+		const result = directive.forParseResult;
+		if (!result) return error("не удалось разобрать v-for", directive.loc);
+		if (result.index) return error("v-for с тремя переменными (обход объекта) не поддерживается", directive.loc);
+		const params = [];
+		for (const param of [result.value, result.key]) {
+			if (!param) continue;
+			if (!isIdentifier(param)) return error("в v-for поддерживаются только простые имена переменных", directive.loc);
+			params.push(param.content);
+		}
+		const source = toPath(result.source, scope, directive.loc);
+		if (!source) return "";
+		const inner = {
+			...scope,
+			locals: /* @__PURE__ */ new Set([...scope.locals, ...params]),
+			depth: scope.depth + 1
+		};
+		return `{{#each ${source}${params.length ? ` as |${params.join(" ")}|` : ""}}}${elementBody(node, inner)}{{/each}}`;
+	}
+	function elementBody(node, scope) {
+		switch (node.tagType) {
+			case ElementTypes.ELEMENT: {
+				const open = `<${node.tag}${attributes(node, scope)}>`;
+				return isVoidTag(node.tag) ? open : `${open}${children(node.children, scope)}</${node.tag}>`;
+			}
+			case ElementTypes.TEMPLATE:
+				checkDirectives(node);
+				return children(node.children, scope);
+			case ElementTypes.COMPONENT: return component(node, scope);
+			case ElementTypes.SLOT: return slot(node);
+		}
+	}
+	function checkDirectives(node) {
+		for (const prop of node.props) if (prop.type === NodeTypes.DIRECTIVE && !STRUCTURAL.has(prop.name)) error(`директива v-${prop.name} здесь не поддерживается`, prop.loc);
+	}
+	function attributes(node, scope) {
+		const staticClass = node.props.find((prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === "class");
+		const hasBoundClass = node.props.some((prop) => prop.type === NodeTypes.DIRECTIVE && bindName(prop) === "class");
+		let out = "";
+		for (const prop of node.props) {
+			if (prop.type === NodeTypes.ATTRIBUTE) {
+				if (prop !== staticClass || !hasBoundClass) out += ` ${escapeMustache(prop.loc.source)}`;
+				continue;
+			}
+			if (STRUCTURAL.has(prop.name)) continue;
+			const name = bindArgument(prop);
+			if (!name || name === "key") continue;
+			if (name === "class") {
+				const value = classValue(prop, scope);
+				const base = staticClass?.type === NodeTypes.ATTRIBUTE && staticClass.value ? `${escapeHtml(staticClass.value.content)} ` : "";
+				out += ` class="${base}${value}"`;
+				continue;
+			}
+			if (name === "style") {
+				error(":style не поддерживается", prop.loc);
+				continue;
+			}
+			out += boundAttribute(name, prop, scope);
+		}
+		return out;
+	}
+	/** Имя атрибута из v-bind, для остальных директив — ошибка */
+	function bindArgument(directive) {
+		if (directive.name !== "bind") {
+			error(`директива v-${directive.name} не поддерживается`, directive.loc);
+			return;
+		}
+		const name = bindName(directive);
+		if (!name) {
+			error("v-bind без имени атрибута и с вычисляемым именем не поддерживается", directive.loc);
+			return;
+		}
+		if (directive.modifiers.length) {
+			error("модификаторы v-bind не поддерживаются", directive.loc);
+			return;
+		}
+		return name;
+	}
+	function classValue(directive, scope) {
+		const exp = directive.exp;
+		const ast = exp?.ast;
+		if (ast && ast.type === "ObjectExpression") {
+			const parts = [];
+			for (const property of ast.properties) {
+				const key = property.type === "ObjectProperty" && !property.computed ? property.key.type === "Identifier" ? property.key.name : property.key.type === "StringLiteral" ? property.key.value : void 0 : void 0;
+				const condition = key && property.type === "ObjectProperty" ? toConditionNode(property.value, scope) : void 0;
+				if (!key || !condition) {
+					error(":class поддерживает объект вида { имя: путь } или { имя: !путь }", directive.loc);
+					continue;
+				}
+				parts.push(`{{#${condition.helper} ${condition.path}}}${escapeHtml(key)}{{/${condition.helper}}}`);
+			}
+			return parts.join(" ");
+		}
+		if (ast && ast.type === "StringLiteral") return escapeHtml(ast.value);
+		const path = toPath(exp, scope, directive.loc);
+		return path ? `{{${path}}}` : "";
+	}
+	function boundAttribute(name, directive, scope) {
+		const exp = sameNameShorthand(directive, name);
+		const ast = exp.ast;
+		if (isBooleanAttr(name)) {
+			if (ast && ast.type === "BooleanLiteral") return ast.value ? ` ${name}` : "";
+			const condition = toCondition(exp, scope, directive.loc);
+			return condition ? `{{#${condition.helper} ${condition.path}}} ${name}{{/${condition.helper}}}` : "";
+		}
+		if (ast && (ast.type === "StringLiteral" || ast.type === "NumericLiteral" || ast.type === "BooleanLiteral")) return ` ${name}="${escapeMustache(escapeHtml(String(ast.value)))}"`;
+		if (ast && ast.type === "TemplateLiteral") {
+			let value = "";
+			ast.quasis.forEach((quasi, index) => {
+				value += escapeMustache(escapeHtml(quasi.value.cooked ?? ""));
+				const expression = ast.expressions[index];
+				if (expression) {
+					const path = toPathNode(expression, scope, directive.loc);
+					value += path ? `{{${path}}}` : "";
+				}
+			});
+			return ` ${name}="${value}"`;
+		}
+		const path = toPath(exp, scope, directive.loc);
+		return path ? ` ${name}="{{${path}}}"` : "";
+	}
+	function component(node, scope) {
+		const name = components.get(node.tag);
+		if (!name) return error(`компонент <${node.tag}> не импортирован в <script setup>`, node.loc);
+		const hash = [];
+		for (const prop of node.props) {
+			if (prop.type === NodeTypes.ATTRIBUTE) {
+				const key = camelize(prop.name);
+				hash.push(`${key}=${prop.value ? toStringLiteral(prop.value.content) : "true"}`);
+				continue;
+			}
+			if (STRUCTURAL.has(prop.name)) continue;
+			const argument = bindArgument(prop);
+			if (!argument || argument === "key") continue;
+			const key = camelize(argument);
+			const value = toHashValue(sameNameShorthand(prop, key), scope, prop.loc);
+			if (value) hash.push(`${key}=${value}`);
+		}
+		const call = [
+			name,
+			"null",
+			...hash
+		].join(" ");
+		const content = node.children.filter((child) => !isBlank(child));
+		for (const child of content) if (child.type === NodeTypes.ELEMENT && child.tagType === ElementTypes.TEMPLATE && findDirective(child, "slot")) error("именованные слоты не поддерживаются", child.loc);
+		return `{{#> ${call}}}${children(content.length ? node.children : [], {
+			...scope,
+			depth: scope.depth + 1
+		})}{{/${name}}}`;
+	}
+	function slot(node) {
+		if (!node.props.every((prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === "name" && prop.value?.content === "default")) return error("поддерживается только слот по умолчанию без параметров", node.loc);
+		if (node.children.some((child) => !isBlank(child))) return error("запасное содержимое слота не поддерживается", node.loc);
+		return "{{#if @partial-block}}{{> @partial-block}}{{/if}}";
+	}
+	function toCondition(exp, scope, loc) {
+		const ast = exp?.ast;
+		if (ast) {
+			const condition = toConditionNode(ast, scope);
+			if (!condition) error(`условие «${exp?.loc.source}» не поддерживается: допустимы путь к данным или его отрицание (!путь)`, loc);
+			return condition;
+		}
+		const path = toPath(exp, scope, loc);
+		return path ? {
+			helper: "if",
+			path
+		} : void 0;
+	}
+	function toConditionNode(node, scope) {
+		if (node.type === "UnaryExpression" && node.operator === "!") {
+			const path = pathOf(node.argument, scope);
+			return path ? {
+				helper: "unless",
+				path
+			} : void 0;
+		}
+		const path = pathOf(node, scope);
+		return path ? {
+			helper: "if",
+			path
+		} : void 0;
+	}
+	function toHashValue(exp, scope, loc) {
+		const ast = exp.ast;
+		if (ast && ast.type === "StringLiteral") return toStringLiteral(ast.value);
+		if (ast && (ast.type === "NumericLiteral" || ast.type === "BooleanLiteral")) return String(ast.value);
+		if (ast && ast.type === "NullLiteral") return "null";
+		return toPath(exp, scope, loc);
+	}
+	function toPath(exp, scope, loc) {
+		if (!exp || exp.type !== NodeTypes.SIMPLE_EXPRESSION) {
+			error("не удалось разобрать выражение", loc);
+			return;
+		}
+		if (exp.ast === null) return root([exp.content.trim()], scope, loc);
+		if (exp.ast === false || exp.ast === void 0) {
+			error(`не удалось разобрать выражение «${exp.content}»`, loc);
+			return;
+		}
+		return toPathNode(exp.ast, scope, loc, exp.content);
+	}
+	function toPathNode(node, scope, loc, source) {
+		const segments = segmentsOf(node);
+		if (!segments) {
+			error(`выражение${source ? ` «${source}»` : ""} не поддерживается: допустимы только пути к данным (a.b.c)`, loc);
+			return;
+		}
+		return root(segments, scope, loc);
+	}
+	/** Путь Handlebars для выражения вида a.b.c, иначе undefined без ошибки */
+	function pathOf(node, scope) {
+		const segments = segmentsOf(node);
+		return segments && root(segments, scope);
+	}
+	function root(segments, scope, loc) {
+		const [head] = segments;
+		if (head.startsWith("$") || isGloballyAllowed(head)) {
+			if (loc) error(`"${head}" не поддерживается: допустимы только данные шаблона`, loc);
+			return;
+		}
+		if (scope.locals.has(head)) return segments.join(".");
+		return "../".repeat(scope.depth) + segments.join(".");
+	}
+	return {
+		code: children(nodes, {
+			locals: /* @__PURE__ */ new Set(),
+			depth: 0
+		}),
+		errors
+	};
+}
+function segmentsOf(node) {
+	switch (node.type) {
+		case "Identifier": return [node.name];
+		case "MemberExpression":
+		case "OptionalMemberExpression": {
+			const object = segmentsOf(node.object);
+			if (!object) return;
+			if (!node.computed && node.property.type === "Identifier") return [...object, node.property.name];
+			if (node.computed && node.property.type === "NumericLiteral") return [...object, `[${node.property.value}]`];
+			return;
+		}
+	}
+}
+function findDirective(node, name) {
+	return node.props.find((prop) => prop.type === NodeTypes.DIRECTIVE && prop.name === name);
+}
+function bindName(directive) {
+	const arg = directive.arg;
+	return arg?.type === NodeTypes.SIMPLE_EXPRESSION && arg.isStatic ? arg.content : void 0;
+}
+/** `:title` без значения — сокращение для `:title="title"` */
+function sameNameShorthand(directive, name) {
+	return directive.exp ?? {
+		type: NodeTypes.SIMPLE_EXPRESSION,
+		content: camelize(name),
+		isStatic: false,
+		constType: 0,
+		ast: null,
+		loc: directive.loc
+	};
+}
+function isIdentifier(exp) {
+	return exp.type === NodeTypes.SIMPLE_EXPRESSION && /^[A-Za-z_$][\w$]*$/.test(exp.content.trim());
+}
+function isBlank(node) {
+	return node.type === NodeTypes.COMMENT || node.type === NodeTypes.TEXT && !node.content.trim();
+}
+/** Экранирует `{{` в статическом тексте, чтобы Handlebars вывел его как есть */
+function escapeMustache(text) {
+	return text.replaceAll("{{", "\\{{");
+}
+function toStringLiteral(value) {
+	return `"${value.replaceAll("\"", "\\\"")}"`;
+}
+//#endregion
+export { handlebars };

package/dist/engines/jinja.d.ts

@@ -0,0 +1,11 @@
+import { i as TemplateEngine } from "../engine-BqkJbOwH.js";
+//#region src/engines/jinja.d.ts
+/**
+ * Jinja: шаблоны для Jinja2 (Python) и совместимых с ним движков.
+ *
+ * Шаблоны читаются во время работы сервера, данные — словарь, поэтому
+ * условие может быть любым значением, а экранирование включается
+ * на стороне сервера (`autoescape`).
+ */
+export declare function jinja(): TemplateEngine;
+//#endregion

package/dist/engines/jinja.js

@@ -0,0 +1,27 @@
+import { t as jinjaEngine } from "../jinja-like-BokTIprh.js";
+//#region src/engines/jinja.ts
+/**
+* Jinja: шаблоны для Jinja2 (Python) и совместимых с ним движков.
+*
+* Шаблоны читаются во время работы сервера, данные — словарь, поэтому
+* условие может быть любым значением, а экранирование включается
+* на стороне сервера (`autoescape`).
+*/
+function jinja() {
+	return jinjaEngine({
+		name: "jinja",
+		extension: ".html",
+		elseIf: "elif",
+		assign: "set",
+		namespace: ".",
+		not: (condition) => `not ${condition}`,
+		and: "and",
+		or: "or",
+		some: (path) => `${path} is not none`,
+		none: (path) => `${path} is none`,
+		binds: false,
+		recursion: true
+	});
+}
+//#endregion
+export { jinja };

package/dist/index.d.ts

@@ -1,3 +1,60 @@
-declare const _default: {};
-
-export { _default as default };
+import { a as TemplateInfo, i as TemplateEngine, n as GenerateResult, o as TemplateLocation, r as TemplateDiagnostic, t as GenerateContext } from "./engine-BqkJbOwH.js";
+import { Plugin } from "vite";
+//#region src/check.d.ts
+/**
+ * Проверяет исходник шаблона без сборки: ошибки разбора SFC и синтаксис,
+ * который не поддерживает шаблонизатор. Те же ошибки выдаёт сборка —
+ * функция нужна инструментам вроде линтера.
+ */
+export declare function checkSource(source: string, engine: TemplateEngine): TemplateDiagnostic[];
+//#endregion
+//#region src/index.d.ts
+export interface VitemplOptions {
+  /** Шаблонизатор, для которого собираются шаблоны */
+  engine: TemplateEngine;
+  /**
+   * Папка исходников шаблонов относительно root
+   * @default "src"
+   */
+  srcDir?: string;
+  /**
+   * Папка страниц относительно srcDir: страницы оборачиваются в shell и обрабатываются Vite как HTML
+   * @default "pages"
+   */
+  pagesDir?: string;
+  /**
+   * Папка фрагментов относительно srcDir: фрагменты рендерятся сервером отдельно, без shell
+   * @default "fragments"
+   */
+  fragmentsDir?: string;
+  /**
+   * HTML-документ относительно root, в который оборачивается каждая страница.
+   * Пишется на языке шаблонизатора. Ссылки на ассеты в нём должны быть
+   * от корня (`/src/main.ts`), так как после обёртки они разрешаются
+   * от папки страницы.
+   * @default "index.html"
+   */
+  shell?: string;
+  /**
+   * Место в shell, куда вставляется страница
+   * @default "<!--app-html-->"
+   */
+  placeholder?: string;
+  /**
+   * Папка собранных шаблонов относительно root
+   * @default "dist/templates"
+   */
+  outDir?: string;
+}
+/**
+ * Собирает шаблоны для SSR на сервере.
+ *
+ * Исходники шаблонов — Vue SFC, от страниц и фрагментов обходятся импорты
+ * компонентов, и в сборку попадают только используемые. Каждый шаблон
+ * генерируется для заданного шаблонизатора, а страницы дополнительно
+ * подаются в Vite как HTML-входы: подключения скриптов и стилей
+ * заменяются на собранные ассеты.
+ */
+export default function vitempl(options: VitemplOptions): Plugin;
+//#endregion
+export type { GenerateContext, GenerateResult, TemplateDiagnostic, TemplateEngine, TemplateInfo, TemplateLocation };