@linguanahq/vite 0.1.0 → 0.1.1

package/dist/adapters.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { type SourceAdapter, type StrictPolicy } from "@linguanahq/build-core";
+import { type Plugin } 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";
+    };
+};
+export declare function linguana(options: LinguanaViteOptions): Plugin;
+export default linguana;

package/dist/index.js

@@ -0,0 +1,131 @@
+// src/index.ts
+import { isAbsolute, relative, resolve } from "node:path";
+import {
+  BuildSession
+} from "@linguanahq/build-core";
+import {
+  createFilter,
+  normalizePath,
+  version as viteVersion
+} from "vite";
+var VERSION = "0.1.1";
+var OFFICIAL_PLUGINS = {
+  react: [
+    "vite:react-babel",
+    "vite:react-refresh",
+    "react-refresh/babel",
+    "tanstack-start"
+  ],
+  solid: ["solid"],
+  vue: ["vite:vue"],
+  svelte: ["vite-plugin-svelte"]
+};
+function linguana(options) {
+  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;
+  let filter;
+  let sawSsr = false;
+  let processSource;
+  const plugin = {
+    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 === void 0 && (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
+        };
+      };
+    },
+    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;
+}
+var index_default = linguana;
+export {
+  index_default as default,
+  linguana
+};

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+import type { SourceAdapter } from "@linguanahq/build-core";
+export declare function react(): SourceAdapter;

package/dist/react.js

@@ -0,0 +1,19 @@
+// src/react.ts
+import { transformSource } from "@linguanahq/compiler";
+function react() {
+  return {
+    id: "react",
+    version: "0.1.1",
+    extensions: [".jsx", ".tsx"],
+    runtimeModule: "@linguanahq/react/compiler-runtime",
+    async transform(input) {
+      return transformSource(input.code, input.filename, {
+        sourceLocale: input.sourceLocale,
+        root: input.root
+      });
+    }
+  };
+}
+export {
+  react
+};

package/dist/shared.d.ts

@@ -0,0 +1,34 @@
+import { type Diagnostic, type ManifestMessage } from "@linguanahq/catalog";
+export declare const EXCLUDED_ELEMENTS: Set<string>;
+export declare const TRANSLATABLE_ATTRIBUTES: Set<string>;
+export declare function renderedText(value: string): string;
+export declare function escapeAttribute(value: string): string;
+export declare function message(input: {
+    source: string;
+    filename: string;
+    root: string;
+    line: number;
+    column: number;
+    sourceLocale: string;
+    element: string;
+}): ManifestMessage;
+export declare function attributeMessage(input: {
+    source: string;
+    filename: string;
+    root: string;
+    line: number;
+    column: number;
+    sourceLocale: string;
+    element: string;
+    attribute: string;
+}): ManifestMessage;
+export declare function explicitMessage(input: {
+    source: string;
+    explicitId?: string;
+    filename: string;
+    root: string;
+    line: number;
+    column: number;
+    sourceLocale: string;
+}): ManifestMessage;
+export declare function unsafeDiagnostic(item: ManifestMessage): Diagnostic | undefined;

package/dist/solid.d.ts

@@ -0,0 +1,2 @@
+import type { SourceAdapter } from "@linguanahq/build-core";
+export declare function solid(): SourceAdapter;

package/dist/solid.js

@@ -0,0 +1,21 @@
+// src/solid.ts
+import { transformSource } from "@linguanahq/compiler";
+function solid() {
+  return {
+    id: "solid",
+    version: "0.1.1",
+    extensions: [".jsx", ".tsx"],
+    runtimeModule: "@linguanahq/solid/compiler-runtime",
+    async transform(input) {
+      return transformSource(input.code, input.filename, {
+        sourceLocale: input.sourceLocale,
+        root: input.root,
+        runtimePackage: "@linguanahq/solid",
+        compilerRuntime: "@linguanahq/solid/compiler-runtime"
+      });
+    }
+  };
+}
+export {
+  solid
+};

package/dist/svelte.d.ts

@@ -0,0 +1,2 @@
+import type { SourceAdapter } from "@linguanahq/build-core";
+export declare function svelte(): SourceAdapter;

package/dist/svelte.js

@@ -0,0 +1,282 @@
+// src/svelte.ts
+import MagicString from "magic-string";
+import { parse } from "svelte/compiler";
+
+// 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/svelte.ts
+function position(code, offset) {
+  const before = code.slice(0, offset).split("\n");
+  return { line: before.length, column: (before.at(-1) ?? "").length };
+}
+function svelte() {
+  return {
+    id: "svelte",
+    version: "0.1.1",
+    extensions: [".svelte"],
+    runtimeModule: "@linguanahq/svelte/compiler-runtime",
+    async transform(input) {
+      const ast = parse(input.code, {
+        filename: input.filename,
+        modern: true
+      });
+      const output = new MagicString(input.code);
+      const messages = [];
+      const diagnostics = [];
+      const seen = /* @__PURE__ */ new Set();
+      const visit = (node, excluded = false, parentTag = "svelte:fragment") => {
+        if (!node || typeof node !== "object" || seen.has(node)) return;
+        seen.add(node);
+        const tag = ["RegularElement", "Component"].includes(node.type) ? String(node.name) : parentTag;
+        const nextExcluded = excluded || EXCLUDED_ELEMENTS.has(tag.toLowerCase()) || (node.attributes ?? []).some(
+          (attribute) => ["data-no-translate", "hidden"].includes(attribute.name)
+        );
+        if (node.type === "Component" && ["T", "LinguanaMessage"].includes(tag)) {
+          const literal = (name) => {
+            const attribute = (node.attributes ?? []).find(
+              (item) => item.type === "Attribute" && item.name === name
+            );
+            const value = attribute?.value;
+            if (Array.isArray(value) && value.length === 1 && value[0]?.type === "Text")
+              return value[0].data;
+            const expression = (Array.isArray(value) ? value[0] : value)?.expression;
+            return expression?.type === "Literal" && typeof expression.value === "string" ? expression.value : void 0;
+          };
+          const source = literal("defaultMessage");
+          if (source) {
+            const loc = position(input.code, node.start);
+            messages.push(
+              explicitMessage({
+                source,
+                explicitId: literal("id"),
+                filename: input.filename,
+                root: input.root,
+                line: loc.line,
+                column: loc.column,
+                sourceLocale: input.sourceLocale
+              })
+            );
+          }
+          return;
+        }
+        const fragmentChildren = node.fragment?.nodes ?? [];
+        if (node.type === "RegularElement" && fragmentChildren.some(
+          (child) => child.type === "Text" && Boolean(renderedText(child.data ?? ""))
+        ) && fragmentChildren.some(
+          (child) => child.type !== "Text"
+        )) {
+          const loc = position(input.code, node.start);
+          diagnostics.push({
+            code: "ambiguous-rich-text",
+            severity: "warning",
+            message: "Mixed text and Svelte template nodes require an explicit <T> message.",
+            location: {
+              file: input.filename.slice(input.root.length + 1),
+              line: loc.line,
+              column: loc.column
+            },
+            remediation: "Use <T defaultMessage> or data-no-translate."
+          });
+          return;
+        }
+        if (node.type === "RegularElement" && !nextExcluded) {
+          for (const attribute of node.attributes ?? []) {
+            const text = attribute.type === "Attribute" && Array.isArray(attribute.value) && attribute.value.length === 1 && attribute.value[0]?.type === "Text" ? attribute.value[0] : void 0;
+            if (!text || typeof text.data !== "string" || !TRANSLATABLE_ATTRIBUTES.has(attribute.name))
+              continue;
+            const loc = position(input.code, attribute.start);
+            const item = attributeMessage({
+              source: text.data,
+              filename: input.filename,
+              root: input.root,
+              line: loc.line,
+              column: loc.column,
+              sourceLocale: input.sourceLocale,
+              element: tag,
+              attribute: attribute.name
+            });
+            messages.push(item);
+            output.overwrite(
+              attribute.start,
+              attribute.end,
+              `${attribute.name}={String(__linguana.translate(${JSON.stringify(item.id)}, ${JSON.stringify(text.data)}))}`
+            );
+          }
+        }
+        if (node.type === "Text" && !nextExcluded) {
+          const source = renderedText(
+            node.data ?? input.code.slice(node.start, node.end)
+          );
+          if (source) {
+            const loc = position(input.code, node.start);
+            const item = message({
+              source,
+              filename: input.filename,
+              root: input.root,
+              line: loc.line,
+              column: loc.column,
+              sourceLocale: input.sourceLocale,
+              element: parentTag
+            });
+            const unsafe = unsafeDiagnostic(item);
+            if (unsafe) diagnostics.push(unsafe);
+            else {
+              messages.push(item);
+              output.overwrite(
+                node.start,
+                node.end,
+                `<LinguanaMessage id="${item.id}" defaultMessage="${escapeAttribute(source)}" />`
+              );
+            }
+          }
+        }
+        for (const [key, value] of Object.entries(node)) {
+          if (["parent", "metadata", "attributes"].includes(key)) continue;
+          if (Array.isArray(value))
+            for (const child of value)
+              visit(child, nextExcluded, tag);
+          else if (value && typeof value === "object" && "type" in value)
+            visit(value, nextExcluded, tag);
+        }
+      };
+      visit(ast.fragment);
+      if (!messages.length && !diagnostics.length) return null;
+      if (messages.length) {
+        const importStatement = `
+<script>
+import LinguanaMessage from "@linguanahq/svelte/compiler-runtime";
+import { getLinguana } from "@linguanahq/svelte";
+const __linguana = getLinguana();
+</script>
+`;
+        const instance = ast.instance;
+        if (instance?.content?.start !== void 0)
+          output.appendLeft(
+            instance.content.start,
+            `
+import LinguanaMessage from "@linguanahq/svelte/compiler-runtime";
+import { getLinguana as __getLinguana } from "@linguanahq/svelte";
+const __linguana = __getLinguana();`
+          );
+        else output.prepend(importStatement);
+      }
+      return {
+        code: output.toString(),
+        map: output.generateMap({
+          hires: true,
+          source: input.filename,
+          includeContent: true
+        }),
+        messages,
+        diagnostics
+      };
+    }
+  };
+}
+export {
+  svelte
+};

package/dist/vue.d.ts

@@ -0,0 +1,2 @@
+import type { SourceAdapter } from "@linguanahq/build-core";
+export declare function vue(): SourceAdapter;