@linguanahq/vite 0.1.0 → 0.1.1

package/dist/vue.js

@@ -0,0 +1,241 @@
+// src/vue.ts
+import { NodeTypes } from "@vue/compiler-dom";
+import { parse } from "@vue/compiler-sfc";
+import MagicString from "magic-string";
+
+// src/shared.ts
+import { relative } from "node:path";
+import {
+  contentHash,
+  normalizeSource,
+  parseMessagePlaceholders,
+  stableMessageId
+} from "@linguanahq/catalog";
+var EXCLUDED_ELEMENTS = /* @__PURE__ */ new Set(["script", "style", "code", "pre"]);
+var TRANSLATABLE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "title",
+  "placeholder",
+  "aria-label",
+  "alt",
+  "label"
+]);
+function renderedText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
+}
+function message(input) {
+  const context = { kind: "text", element: input.element };
+  return {
+    id: stableMessageId({
+      sourceLocale: input.sourceLocale,
+      source: input.source,
+      context
+    }),
+    source: input.source,
+    normalized: normalizeSource(input.source),
+    contentHash: contentHash(input.source),
+    context,
+    placeholders: parseMessagePlaceholders(input.source),
+    confidence: "high",
+    locations: [
+      {
+        file: relative(input.root, input.filename).replaceAll("\\", "/"),
+        line: input.line,
+        column: input.column
+      }
+    ]
+  };
+}
+function attributeMessage(input) {
+  const context = {
+    kind: "attribute",
+    element: input.element,
+    attribute: input.attribute
+  };
+  return {
+    id: stableMessageId({
+      sourceLocale: input.sourceLocale,
+      source: input.source,
+      context
+    }),
+    source: input.source,
+    normalized: normalizeSource(input.source),
+    contentHash: contentHash(input.source),
+    context,
+    placeholders: parseMessagePlaceholders(input.source),
+    confidence: "high",
+    locations: [
+      {
+        file: relative(input.root, input.filename).replaceAll("\\", "/"),
+        line: input.line,
+        column: input.column
+      }
+    ]
+  };
+}
+function explicitMessage(input) {
+  const context = { kind: "explicit" };
+  return {
+    id: stableMessageId({
+      sourceLocale: input.sourceLocale,
+      source: input.source,
+      context,
+      explicitId: input.explicitId
+    }),
+    source: input.source,
+    normalized: normalizeSource(input.source),
+    contentHash: contentHash(input.source),
+    context,
+    placeholders: parseMessagePlaceholders(input.source),
+    confidence: "explicit",
+    locations: [
+      {
+        file: relative(input.root, input.filename).replaceAll("\\", "/"),
+        line: input.line,
+        column: input.column
+      }
+    ]
+  };
+}
+function unsafeDiagnostic(item) {
+  if (/^(?:https?:\/\/|mailto:|tel:|www\.)/i.test(item.normalized))
+    return {
+      code: "unsafe-static-copy",
+      severity: "info",
+      message: "URL-like or machine-readable text was excluded from extraction.",
+      location: item.locations[0]
+    };
+}
+
+// src/vue.ts
+function vue() {
+  return {
+    id: "vue",
+    version: "0.1.1",
+    extensions: [".vue"],
+    runtimeModule: "@linguanahq/vue/compiler-runtime",
+    async transform(input) {
+      const parsed = parse(input.code, {
+        filename: input.filename,
+        sourceMap: true
+      });
+      const template = parsed.descriptor.template;
+      if (!template?.ast) return null;
+      const output = new MagicString(input.code);
+      const messages = [];
+      const diagnostics = [];
+      const visit = (node, excluded = false, parentTag = "template") => {
+        const tag = node.type === NodeTypes.ELEMENT ? String(node.tag) : parentTag;
+        const nextExcluded = excluded || EXCLUDED_ELEMENTS.has(tag.toLowerCase()) || (node.props ?? []).some(
+          (prop) => prop.type === NodeTypes.ATTRIBUTE && ["data-no-translate", "hidden"].includes(prop.name)
+        );
+        if (node.type === NodeTypes.ELEMENT && ["T", "LinguanaMessage"].includes(tag)) {
+          const source = (node.props ?? []).find(
+            (prop) => prop.type === NodeTypes.ATTRIBUTE && ["default-message", "defaultMessage"].includes(prop.name)
+          )?.value?.content;
+          const explicitId = (node.props ?? []).find(
+            (prop) => prop.type === NodeTypes.ATTRIBUTE && prop.name === "id"
+          )?.value?.content;
+          if (source)
+            messages.push(
+              explicitMessage({
+                source,
+                explicitId,
+                filename: input.filename,
+                root: input.root,
+                line: node.loc.start.line,
+                column: node.loc.start.column - 1,
+                sourceLocale: input.sourceLocale
+              })
+            );
+          return;
+        }
+        if (node.type === NodeTypes.ELEMENT && (node.children ?? []).some(
+          (child) => child.type === NodeTypes.TEXT && Boolean(renderedText(child.content ?? ""))
+        ) && (node.children ?? []).some(
+          (child) => child.type !== NodeTypes.TEXT
+        )) {
+          diagnostics.push({
+            code: "ambiguous-rich-text",
+            severity: "warning",
+            message: "Mixed text and Vue template nodes require an explicit <T> message.",
+            location: {
+              file: input.filename.slice(input.root.length + 1),
+              line: node.loc.start.line,
+              column: node.loc.start.column - 1
+            },
+            remediation: "Use <T default-message> or data-no-translate."
+          });
+          return;
+        }
+        if (node.type === NodeTypes.ELEMENT && !nextExcluded) {
+          for (const prop of node.props ?? []) {
+            if (prop.type !== NodeTypes.ATTRIBUTE || !prop.value || !TRANSLATABLE_ATTRIBUTES.has(prop.name))
+              continue;
+            const item = attributeMessage({
+              source: prop.value.content,
+              filename: input.filename,
+              root: input.root,
+              line: prop.loc.start.line,
+              column: prop.loc.start.column - 1,
+              sourceLocale: input.sourceLocale,
+              element: tag,
+              attribute: prop.name
+            });
+            messages.push(item);
+            const expression = `$tAttr(${JSON.stringify(item.id)}, ${JSON.stringify(prop.value.content)})`;
+            const replacement = `:${prop.name}='${expression.replaceAll("&", "&amp;").replaceAll("'", "&#39;")}'`;
+            output.overwrite(
+              prop.loc.start.offset,
+              prop.loc.end.offset,
+              replacement
+            );
+          }
+        }
+        if (node.type === NodeTypes.TEXT && !nextExcluded) {
+          const source = renderedText(node.content ?? "");
+          if (source) {
+            const item = message({
+              source,
+              filename: input.filename,
+              root: input.root,
+              line: node.loc.start.line,
+              column: node.loc.start.column - 1,
+              sourceLocale: input.sourceLocale,
+              element: parentTag
+            });
+            const unsafe = unsafeDiagnostic(item);
+            if (unsafe) diagnostics.push(unsafe);
+            else {
+              messages.push(item);
+              output.overwrite(
+                node.loc.start.offset,
+                node.loc.end.offset,
+                `<LinguanaMessage id="${item.id}" default-message="${escapeAttribute(source)}" />`
+              );
+            }
+          }
+        }
+        for (const child of node.children ?? [])
+          visit(child, nextExcluded, tag);
+      };
+      visit(template.ast);
+      if (!messages.length && !diagnostics.length) return null;
+      return {
+        code: output.toString(),
+        map: output.generateMap({
+          hires: true,
+          source: input.filename,
+          includeContent: true
+        }),
+        messages,
+        diagnostics
+      };
+    }
+  };
+}
+export {
+  vue
+};

package/package.json

@@ -1,51 +1,65 @@
 {
-	"name": "@linguanahq/vite",
-	"version": "0.1.0",
-	"publishConfig": {
-		"access": "public"
-	},
-	"type": "module",
-	"exports": {
-		".": "./src/index.ts",
-		"./react": "./src/react.ts",
-		"./solid": "./src/solid.ts",
-		"./vue": "./src/vue.ts",
-		"./svelte": "./src/svelte.ts"
-	},
-	"imports": {
-		"#shared": "./src/shared.ts"
-	},
-	"scripts": {
-		"check-types": "tsc --noEmit",
-		"test": "bun test"
-	},
-	"dependencies": {
-		"@linguanahq/build-core": "0.1.0",
-		"@linguanahq/catalog": "0.1.0",
-		"@linguanahq/compiler": "0.1.0",
-		"magic-string": "^0.30.21"
-	},
-	"devDependencies": {
-		"@linguana/config": "0.0.0",
-		"@types/bun": "^1.3.14",
-		"@vue/compiler-dom": "^3.5.24",
-		"@vue/compiler-sfc": "^3.5.24",
-		"svelte": "^5.43.8",
-		"typescript": "^6",
-		"vite": "^8.1.3"
-	},
-	"peerDependencies": {
-		"vite": ">=7 <9"
-	},
-	"peerDependenciesMeta": {
-		"@vue/compiler-dom": {
-			"optional": true
-		},
-		"@vue/compiler-sfc": {
-			"optional": true
-		},
-		"svelte": {
-			"optional": true
-		}
-	}
+  "name": "@linguanahq/vite",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Linguana vite integration",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js",
+      "default": "./dist/react.js"
+    },
+    "./solid": {
+      "types": "./dist/solid.d.ts",
+      "import": "./dist/solid.js",
+      "default": "./dist/solid.js"
+    },
+    "./vue": {
+      "types": "./dist/vue.d.ts",
+      "import": "./dist/vue.js",
+      "default": "./dist/vue.js"
+    },
+    "./svelte": {
+      "types": "./dist/svelte.d.ts",
+      "import": "./dist/svelte.js",
+      "default": "./dist/svelte.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@linguanahq/build-core": "0.1.1",
+    "@linguanahq/catalog": "0.1.1",
+    "@linguanahq/compiler": "0.1.1",
+    "magic-string": "^0.30.21"
+  },
+  "peerDependencies": {
+    "vite": ">=7 <9",
+    "@vue/compiler-dom": ">=3.5 <4",
+    "@vue/compiler-sfc": ">=3.5 <4",
+    "svelte": ">=5 <6"
+  },
+  "peerDependenciesMeta": {
+    "@vue/compiler-dom": {
+      "optional": true
+    },
+    "@vue/compiler-sfc": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/index.ts

@@ -1,173 +0,0 @@
-import { isAbsolute, relative, resolve } from "node:path";
-
-import {
-	BuildSession,
-	type SourceAdapter,
-	type StrictPolicy,
-} from "@linguanahq/build-core";
-import {
-	createFilter,
-	normalizePath,
-	type Plugin,
-	type TransformResult,
-	version as viteVersion,
-} from "vite";
-
-export type LinguanaViteAdapter = SourceAdapter;
-export type LinguanaViteOptions = {
-	adapter: LinguanaViteAdapter;
-	projectId: string;
-	environment?: string;
-	sourceLocale?: string;
-	apiUrl?: string;
-	token?: string;
-	include?: string | string[];
-	exclude?: string | string[];
-	output?: string;
-	upload?: boolean;
-	strict?: StrictPolicy;
-	translation?:
-		| false
-		| {
-				enabled: true;
-				maxChargeMicros: number;
-				waitTimeoutMs?: number;
-				publish: "development";
-		  };
-};
-
-const VERSION = "0.1.0";
-const OFFICIAL_PLUGINS: Record<SourceAdapter["id"], string[]> = {
-	react: [
-		"vite:react-babel",
-		"vite:react-refresh",
-		"react-refresh/babel",
-		"tanstack-start",
-	],
-	solid: ["solid"],
-	vue: ["vite:vue"],
-	svelte: ["vite-plugin-svelte"],
-};
-
-export function linguana(options: LinguanaViteOptions): Plugin {
-	if (!options.adapter)
-		throw new Error("Linguana requires exactly one framework adapter.");
-	const environment = options.environment ?? "development";
-	const sourceLocale = options.sourceLocale ?? "en";
-	if (options.translation && (!options.token || environment !== "development"))
-		throw new Error(
-			"Build translation requires a token and the development environment.",
-		);
-	if (
-		options.translation &&
-		(!Number.isSafeInteger(options.translation.maxChargeMicros) ||
-			options.translation.maxChargeMicros <= 0)
-	)
-		throw new Error(
-			"translation.maxChargeMicros must be a positive safe integer.",
-		);
-	let root = process.cwd();
-	let session: BuildSession;
-	let filter: ReturnType<typeof createFilter>;
-	let sawSsr = false;
-	let processSource: (
-		code: string,
-		filename: string,
-		ssr?: boolean,
-	) => Promise<TransformResult | null>;
-
-	const plugin: Plugin & { api?: Record<string, unknown> } = {
-		name: "linguana:vite",
-		enforce: "pre",
-		configResolved(config) {
-			root = config.root;
-			filter = createFilter(
-				options.include ??
-					options.adapter.extensions.map((extension) => `**/*${extension}`),
-				options.exclude ?? ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"],
-			);
-			session = new BuildSession({
-				projectId: options.projectId,
-				environment,
-				sourceLocale,
-				compilerVersion: VERSION,
-				strict: options.strict,
-				integration: {
-					tool: "vite",
-					toolVersion: viteVersion,
-					framework: options.adapter.id,
-					adapterVersion: options.adapter.version,
-					ssr: false,
-				},
-			});
-			const ownIndex = config.plugins.findIndex(
-				(item) => item.name === "linguana:vite",
-			);
-			const frameworkIndex = config.plugins.findIndex((item) =>
-				OFFICIAL_PLUGINS[options.adapter.id].some((name) =>
-					item.name.includes(name),
-				),
-			);
-			if (frameworkIndex < 0)
-				throw new Error(
-					`Linguana ${options.adapter.id} adapter requires the official ${options.adapter.id} Vite plugin.`,
-				);
-			if (ownIndex > frameworkIndex)
-				throw new Error(
-					`Place linguana() before the official ${options.adapter.id} plugin in vite.config.ts.`,
-				);
-			processSource = async (code, filename, ssr = false) => {
-				const cleanId = normalizePath(filename.split("?", 1)[0] ?? filename);
-				const projectRelativeId = relative(root, cleanId);
-				if (
-					options.include === undefined &&
-					(projectRelativeId === ".." ||
-						projectRelativeId.startsWith("../") ||
-						projectRelativeId.startsWith("..\\") ||
-						isAbsolute(projectRelativeId))
-				)
-					return null;
-				if (!filter(cleanId)) return null;
-				if (ssr) {
-					sawSsr = true;
-					session.options.integration.ssr = true;
-				}
-				const result = await options.adapter.transform({
-					code,
-					filename: cleanId,
-					root,
-					sourceLocale,
-				});
-				if (!result) return null;
-				session.collect(result);
-				return {
-					code: result.code,
-					map: result.map as TransformResult["map"],
-				};
-			};
-		},
-		async transform(code, id, transformOptions) {
-			return processSource(code, id, Boolean(transformOptions?.ssr));
-		},
-		async writeBundle() {
-			const manifest = await session.write(
-				resolve(root, options.output ?? ".linguana/manifest.json"),
-			);
-			for (const item of session.diagnostics)
-				this[item.severity === "error" ? "error" : "warn"](
-					`${item.code}: ${item.message}`,
-				);
-			if ((options.upload ?? Boolean(options.token)) && options.token)
-				await session.upload(manifest, {
-					apiUrl: options.apiUrl ?? "https://api.linguana.dev",
-					token: options.token,
-					translation: options.translation,
-					onProgress: (message) => this.info(`[linguana] ${message}`),
-				});
-			void sawSsr;
-		},
-	};
-	return plugin;
-}
-
-export default linguana;

package/src/react.ts

@@ -1,19 +0,0 @@
-import type { SourceAdapter } from "@linguanahq/build-core";
-import { transformSource } from "@linguanahq/compiler";
-
-export function react(): SourceAdapter {
-	return {
-		id: "react",
-		version: "0.1.0",
-		extensions: [".jsx", ".tsx"],
-		runtimeModule: "@linguanahq/react/compiler-runtime",
-		async transform(input) {
-			return transformSource(input.code, input.filename, {
-				sourceLocale: input.sourceLocale,
-				root: input.root,
-			}) as ReturnType<SourceAdapter["transform"]> extends Promise<infer T>
-				? T
-				: never;
-		},
-	};
-}

package/src/shared.ts

@@ -1,145 +0,0 @@
-import { relative } from "node:path";
-
-import {
-	contentHash,
-	type Diagnostic,
-	type ManifestMessage,
-	normalizeSource,
-	parseMessagePlaceholders,
-	stableMessageId,
-} from "@linguanahq/catalog";
-
-export const EXCLUDED_ELEMENTS = new Set(["script", "style", "code", "pre"]);
-export const TRANSLATABLE_ATTRIBUTES = new Set([
-	"title",
-	"placeholder",
-	"aria-label",
-	"alt",
-	"label",
-]);
-
-export function renderedText(value: string) {
-	return value.replace(/\s+/g, " ").trim();
-}
-
-export function escapeAttribute(value: string) {
-	return value
-		.replaceAll("&", "&")
-		.replaceAll('"', """)
-		.replaceAll("<", "&lt;");
-}
-
-export function message(input: {
-	source: string;
-	filename: string;
-	root: string;
-	line: number;
-	column: number;
-	sourceLocale: string;
-	element: string;
-}): ManifestMessage {
-	const context = { kind: "text" as const, element: input.element };
-	return {
-		id: stableMessageId({
-			sourceLocale: input.sourceLocale,
-			source: input.source,
-			context,
-		}),
-		source: input.source,
-		normalized: normalizeSource(input.source),
-		contentHash: contentHash(input.source),
-		context,
-		placeholders: parseMessagePlaceholders(input.source),
-		confidence: "high",
-		locations: [
-			{
-				file: relative(input.root, input.filename).replaceAll("\\", "/"),
-				line: input.line,
-				column: input.column,
-			},
-		],
-	};
-}
-
-export function attributeMessage(input: {
-	source: string;
-	filename: string;
-	root: string;
-	line: number;
-	column: number;
-	sourceLocale: string;
-	element: string;
-	attribute: string;
-}): ManifestMessage {
-	const context = {
-		kind: "attribute" as const,
-		element: input.element,
-		attribute: input.attribute,
-	};
-	return {
-		id: stableMessageId({
-			sourceLocale: input.sourceLocale,
-			source: input.source,
-			context,
-		}),
-		source: input.source,
-		normalized: normalizeSource(input.source),
-		contentHash: contentHash(input.source),
-		context,
-		placeholders: parseMessagePlaceholders(input.source),
-		confidence: "high",
-		locations: [
-			{
-				file: relative(input.root, input.filename).replaceAll("\\", "/"),
-				line: input.line,
-				column: input.column,
-			},
-		],
-	};
-}
-
-export function explicitMessage(input: {
-	source: string;
-	explicitId?: string;
-	filename: string;
-	root: string;
-	line: number;
-	column: number;
-	sourceLocale: string;
-}): ManifestMessage {
-	const context = { kind: "explicit" as const };
-	return {
-		id: stableMessageId({
-			sourceLocale: input.sourceLocale,
-			source: input.source,
-			context,
-			explicitId: input.explicitId,
-		}),
-		source: input.source,
-		normalized: normalizeSource(input.source),
-		contentHash: contentHash(input.source),
-		context,
-		placeholders: parseMessagePlaceholders(input.source),
-		confidence: "explicit",
-		locations: [
-			{
-				file: relative(input.root, input.filename).replaceAll("\\", "/"),
-				line: input.line,
-				column: input.column,
-			},
-		],
-	};
-}
-
-export function unsafeDiagnostic(
-	item: ManifestMessage,
-): Diagnostic | undefined {
-	if (/^(?:https?:\/\/|mailto:|tel:|www\.)/i.test(item.normalized))
-		return {
-			code: "unsafe-static-copy",
-			severity: "info",
-			message:
-				"URL-like or machine-readable text was excluded from extraction.",
-			location: item.locations[0],
-		};
-}