@linguanahq/vite 0.1.0 → 0.1.2

package/dist/preview.test.d.ts

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

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/transform";
+function react() {
+  return {
+    id: "react",
+    version: "0.1.2",
+    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/transform";
+function solid() {
+  return {
+    id: "solid",
+    version: "0.1.2",
+    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.2",
+    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;

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.2",
+    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
+};