@linguanahq/vite 0.1.0 → 0.1.2

package/dist/adapters.test.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { type SourceAdapter, type StrictPolicy } from "@linguanahq/build-core";
+import { type Plugin } from "vite";
+export type LinguanaViteAdapter = SourceAdapter;
+export type LinguanaViteOptions = {
+    /** Live development preview. The dashboard can disable it; false always opts out. */
+    hotReload?: boolean;
+    /** Per-preview request ceiling in USD micros, additionally limited by the project and organization. */
+    previewMaxChargeMicros?: number;
+    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,622 @@
+// src/index.ts
+import { isAbsolute, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  BuildSession as BuildSession2
+} from "@linguanahq/build-core";
+import {
+  createFilter,
+  normalizePath,
+  version as viteVersion
+} from "vite";
+
+// src/preview.ts
+import {
+  BuildSession
+} from "@linguanahq/build-core";
+import { contentHash } from "@linguanahq/catalog";
+var messageKey = (message) => `${message.id}:${message.contentHash}`;
+var terminal = /* @__PURE__ */ new Set([
+  "succeeded",
+  "failed",
+  "canceled",
+  "review_required"
+]);
+var LocalPreview = class {
+  files = /* @__PURE__ */ new Map();
+  locales = /* @__PURE__ */ new Set();
+  states = /* @__PURE__ */ new Map();
+  jobs = /* @__PURE__ */ new Map();
+  config;
+  configAt = 0;
+  timer;
+  running = false;
+  dirty = false;
+  disposed = false;
+  generation = 0;
+  retrySequence = 0;
+  controllers = /* @__PURE__ */ new Set();
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  collect(file, result) {
+    if (result) this.files.set(file, structuredClone(result));
+    else this.files.delete(file);
+    this.prune();
+    this.schedule(250);
+  }
+  watch(locales) {
+    this.locales = new Set(
+      locales.filter((locale) => locale !== this.options.session.sourceLocale).slice(0, 10)
+    );
+    for (const locale of this.locales) this.state(locale);
+    this.schedule(0);
+  }
+  refresh() {
+    this.retrySequence += 1;
+    for (const job of this.jobs.values())
+      if (["failed", "canceled", "review_required"].includes(job.status)) {
+        for (const key of job.keys)
+          this.state(job.locale).submitted.delete(key);
+        this.jobs.delete(job.id);
+      }
+    for (const state of this.states.values()) {
+      state.status = "ready";
+      state.message = void 0;
+    }
+    this.configAt = 0;
+    this.schedule(0);
+  }
+  dispose() {
+    this.disposed = true;
+    clearTimeout(this.timer);
+    for (const controller of this.controllers) controller.abort();
+    this.controllers.clear();
+    this.files.clear();
+    this.jobs.clear();
+    this.states.clear();
+  }
+  state(locale) {
+    let state = this.states.get(locale);
+    if (!state) {
+      state = { submitted: /* @__PURE__ */ new Set(), entries: /* @__PURE__ */ new Map(), status: "ready" };
+      this.states.set(locale, state);
+    }
+    return state;
+  }
+  messages() {
+    const messages = /* @__PURE__ */ new Map();
+    const conflicts = /* @__PURE__ */ new Set();
+    for (const file of this.files.values())
+      for (const message of file.messages) {
+        if (messages.has(message.id) && messages.get(message.id)?.contentHash !== message.contentHash)
+          conflicts.add(message.id);
+        messages.set(message.id, message);
+      }
+    for (const id of conflicts) messages.delete(id);
+    return messages;
+  }
+  prune() {
+    const current = this.messages();
+    const keys = new Set([...current.values()].map(messageKey));
+    for (const [locale, state] of this.states) {
+      for (const [id, entry] of state.entries)
+        if (current.get(id)?.contentHash !== entry.contentHash)
+          state.entries.delete(id);
+      for (const key of state.submitted)
+        if (!keys.has(key)) state.submitted.delete(key);
+      this.emit(locale);
+    }
+    for (const [id, job] of this.jobs)
+      if (![...job.keys].some((key) => keys.has(key))) this.jobs.delete(id);
+  }
+  emit(locale) {
+    if (this.disposed || !this.locales.has(locale)) return;
+    const state = this.state(locale);
+    this.options.emit({
+      projectId: this.options.session.projectId,
+      environment: this.options.session.environment,
+      locale,
+      entries: [...state.entries.values()],
+      sources: [...this.messages().values()].map(({ id, source }) => ({
+        id,
+        source
+      })),
+      status: state.status,
+      total: this.messages().size,
+      message: state.message
+    });
+  }
+  schedule(ms) {
+    if (this.disposed) return;
+    if (this.running) {
+      this.dirty = true;
+      return;
+    }
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      void this.tick();
+    }, ms);
+    this.timer.unref?.();
+  }
+  async request(path, init = {}) {
+    const controller = new AbortController();
+    this.controllers.add(controller);
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const response = await (this.options.fetch ?? fetch)(
+        `${this.options.apiUrl.replace(/\/$/, "")}${path}`,
+        {
+          ...init,
+          signal: controller.signal,
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.options.token}`,
+            ...init.headers
+          }
+        }
+      );
+      const body = await response.json();
+      if (!response.ok)
+        throw Object.assign(
+          new Error(body.message ?? "Preview request failed."),
+          { code: body.code ?? `HTTP_${response.status}` }
+        );
+      return body;
+    } finally {
+      clearTimeout(timeout);
+      this.controllers.delete(controller);
+    }
+  }
+  async tick() {
+    if (this.running || this.disposed || !this.locales.size) return;
+    this.running = true;
+    this.dirty = false;
+    try {
+      if (Date.now() - this.configAt >= 5e3) {
+        const config2 = await this.request(
+          "/api/v1/preview/config"
+        );
+        if (config2.projectId !== this.options.session.projectId || config2.environment !== "development" || config2.sourceLocale !== this.options.session.sourceLocale)
+          throw new Error("Preview configuration does not match this project.");
+        if (this.config && this.config.policyKey !== config2.policyKey) {
+          this.generation += 1;
+          this.jobs.clear();
+          for (const state of this.states.values()) {
+            state.submitted.clear();
+            state.entries.clear();
+            state.status = "ready";
+          }
+        }
+        this.config = config2;
+        this.configAt = Date.now();
+      }
+      if (!this.config?.hotReload) {
+        for (const locale of this.locales) {
+          const state = this.state(locale);
+          state.entries.clear();
+          state.status = "disabled";
+          this.emit(locale);
+        }
+        return;
+      }
+      const config = this.config;
+      for (const locale of this.locales) {
+        const state = this.state(locale);
+        if (!config.locales.includes(locale)) {
+          state.status = "disabled";
+          state.message = "Enable this language in the dashboard.";
+          this.emit(locale);
+          continue;
+        }
+        if (state.status === "disabled") state.status = "ready";
+        const missing = [...this.messages().values()].filter(
+          (message) => !state.submitted.has(messageKey(message))
+        );
+        const outstanding = [...this.jobs.values()].filter(
+          (job) => !terminal.has(job.status)
+        ).length;
+        if (missing.length && outstanding < 2 && !["budget_blocked", "failed"].includes(state.status)) {
+          const batch = [];
+          let characters = 0;
+          for (const message of missing) {
+            const size = [...message.source].length;
+            if (batch.length && (batch.length >= 20 || characters + size > 2500))
+              break;
+            if (size > 12e3) {
+              state.status = "failed";
+              state.message = "A source string exceeds the 12,000-character preview limit.";
+              break;
+            }
+            batch.push(message);
+            characters += size;
+          }
+          if (batch.length) await this.enqueue(locale, batch, config);
+        }
+      }
+      const now = Date.now();
+      const due = [...this.jobs.values()].filter(
+        (job) => this.locales.has(job.locale) && now - job.lastPoll >= (terminal.has(job.status) ? 5e3 : 600)
+      );
+      await Promise.all(due.slice(0, 8).map((job) => this.poll(job)));
+      for (const locale of this.locales) this.emit(locale);
+    } catch (error) {
+      if (!this.disposed)
+        for (const locale of this.locales) {
+          const state = this.state(locale);
+          const code = error.code ?? "PREVIEW_UNAVAILABLE";
+          state.status = /CAP|BILLING|BUDGET/.test(code) ? "budget_blocked" : "failed";
+          state.message = `${code}. Check the dashboard, then retry preview.`;
+          this.emit(locale);
+        }
+    } finally {
+      this.running = false;
+      this.schedule(this.dirty ? 250 : 750);
+    }
+  }
+  async enqueue(locale, batch, config) {
+    const session = new BuildSession(this.options.session);
+    session.collect({ code: "", map: null, messages: batch, diagnostics: [] });
+    const manifest = session.manifest();
+    manifest.sourceRevision = "linguana-local-preview-v1";
+    const controller = new AbortController();
+    this.controllers.add(controller);
+    const timeout = setTimeout(() => controller.abort(), 15e3);
+    let registration;
+    try {
+      registration = await session.upload(manifest, {
+        apiUrl: this.options.apiUrl,
+        token: this.options.token,
+        preview: true,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeout);
+      this.controllers.delete(controller);
+    }
+    if (this.disposed || !this.locales.has(locale)) return;
+    const created = await this.request(`/api/v1/manifests/${registration.manifestId}/translations`, {
+      method: "POST",
+      headers: {
+        "idempotency-key": contentHash({
+          manifest: registration.manifestId,
+          locale,
+          policy: config.policyKey,
+          preview: true,
+          retry: this.retrySequence
+        })
+      },
+      body: JSON.stringify({
+        preview: true,
+        previewRetry: this.retrySequence > 0,
+        targetLocales: [locale],
+        maxChargeMicros: Math.min(
+          config.maxChargeMicros,
+          this.options.maxChargeMicros ?? config.maxChargeMicros
+        )
+      })
+    });
+    const keys = new Set(batch.map(messageKey));
+    for (const job of created.jobs)
+      this.jobs.set(job.id, {
+        id: job.id,
+        locale,
+        keys,
+        status: "queued",
+        lastPoll: 0
+      });
+    const state = this.state(locale);
+    for (const key of keys) state.submitted.add(key);
+    state.status = "translating";
+    state.message = void 0;
+    this.emit(locale);
+  }
+  async poll(job) {
+    job.lastPoll = Date.now();
+    const generation = this.generation;
+    const update = await this.request(`/api/v1/preview/jobs/${job.id}`);
+    if (generation !== this.generation || this.disposed || !this.locales.has(job.locale))
+      return;
+    if (update.projectId !== this.options.session.projectId || update.environment !== this.options.session.environment || update.locale !== job.locale)
+      throw new Error("Invalid preview response scope.");
+    job.status = update.status;
+    const state = this.state(job.locale);
+    const current = this.messages();
+    for (const entry of update.entries)
+      if (current.get(entry.id)?.contentHash === entry.contentHash && current.get(entry.id)?.source === entry.source)
+        state.entries.set(entry.id, entry);
+    if (update.status === "disabled") {
+      state.entries.clear();
+      state.status = "disabled";
+    } else if (["failed", "canceled"].includes(update.status)) {
+      state.status = /CAP|BILLING/.test(update.errorCode ?? "") ? "budget_blocked" : "failed";
+      state.message = update.errorCode ?? "Translation failed. Retry from the preview bar.";
+    } else if (update.status === "review_required")
+      state.status = "review_required";
+    else if (!["failed", "budget_blocked", "review_required"].includes(state.status))
+      state.status = [...this.jobs.values()].some(
+        (other) => other.locale === job.locale && !terminal.has(other.status)
+      ) ? "translating" : "ready";
+  }
+};
+
+// src/preview-client.ts
+function previewClientSource(coreModule, projectId, sourceLocale) {
+  return `
+import { installDevelopmentPreview } from ${JSON.stringify(coreModule)};
+const hot = import.meta.hot;
+if (hot && typeof document !== "undefined") {
+  let scopes = [], original = false, hidden = false, host;
+  const bridge = installDevelopmentPreview({ watch(next) {
+    scopes = next.filter(scope => scope.projectId === ${JSON.stringify(projectId)} && scope.environment === "development" && scope.locale !== ${JSON.stringify(sourceLocale)});
+    hot.send("linguana:preview:watch", { locales: scopes.map(scope => scope.locale) });
+    if (host) host.hidden = hidden || scopes.length === 0;
+  } });
+  let disposed = false, configTimer;
+  const configScope = { projectId: ${JSON.stringify(projectId)}, environment: "development" };
+  const refreshConfig = async () => {
+    try { await bridge.refreshConfig(configScope); }
+    finally { if (!disposed) configTimer = setTimeout(refreshConfig, 5000); }
+  };
+  void refreshConfig();
+  const mount = () => {
+    host = document.createElement("div");
+    host.setAttribute("data-linguana-preview", "");
+    host.style.cssText = "position:fixed;inset:auto 12px 12px auto;z-index:2147483000;max-width:calc(100vw - 24px)";
+    const root = host.attachShadow({ mode: "open" });
+    root.innerHTML = '<style>:host{color-scheme:light dark}aside{display:flex;flex-wrap:wrap;gap:9px;align-items:center;max-width:520px;padding:10px 12px;border:1px solid #b7c8bc;border-radius:10px;background:#f7fbf8;color:#193327;box-shadow:0 3px 18px #0002;font:12px/1.4 system-ui,sans-serif;text-align:left;direction:ltr}strong{font-weight:650}span{flex:1;min-width:90px}button{cursor:pointer;border:1px solid #b7c8bc;border-radius:5px;background:transparent;color:inherit;font:inherit;padding:4px 7px}button:focus-visible{outline:2px solid #19653b;outline-offset:2px}@media(prefers-color-scheme:dark){aside{background:#17271e;color:#eaf5ed;border-color:#4e6858}button{border-color:#4e6858}}</style><aside aria-label="Linguana local preview"><strong>Local preview</strong><span role="status" aria-live="polite">Connecting\u2026</span><button type="button" data-original aria-pressed="false">Show original</button><button type="button" data-retry>Refresh</button><button type="button" data-hide aria-label="Hide preview controls">\xD7</button></aside>';
+    root.querySelector('[data-original]').onclick = (event) => {
+      original = !original; bridge.original(original);
+      event.currentTarget.textContent = original ? 'Show translation' : 'Show original';
+      event.currentTarget.setAttribute('aria-pressed', String(original));
+    };
+    root.querySelector('[data-retry]').onclick = () => { void bridge.refreshConfig(configScope); hot.send('linguana:preview:refresh', {}); };
+    root.querySelector('[data-hide]').onclick = () => { hidden = true; host.hidden = true; };
+    document.body.append(host); host.hidden = hidden || scopes.length === 0;
+  };
+  if (document.body) mount(); else document.addEventListener('DOMContentLoaded', mount, { once: true });
+  const onUpdate = (update) => {
+    if (update.projectId !== ${JSON.stringify(projectId)} || update.environment !== 'development') return;
+    bridge.update(update);
+    const label = host?.shadowRoot?.querySelector('[role="status"]');
+    const statuses = { ready: 'Up to date', translating: 'Translating', disabled: 'Off in dashboard', failed: 'Preview unavailable', budget_blocked: 'Spending limit reached', review_required: 'Needs review' };
+    if (label) {
+      label.textContent = update.locale + ' \xB7 ' + (statuses[update.status] || 'Waiting') + ' \xB7 ' + update.entries.length + '/' + update.total;
+      label.title = update.message || 'Validated draft wording. Publishing is a separate action.';
+    }
+  };
+  const reconnect = () => { void bridge.refreshConfig(configScope); hot.send('linguana:preview:watch', { locales: scopes.map(scope => scope.locale) }); };
+  hot.on('linguana:preview:update', onUpdate);
+  hot.on('vite:ws:connect', reconnect);
+  hot.dispose(() => { disposed = true; clearTimeout(configTimer); bridge.dispose(); host?.remove(); document.removeEventListener('DOMContentLoaded', mount); hot.off('linguana:preview:update', onUpdate); hot.off('vite:ws:connect', reconnect); });
+}
+`;
+}
+
+// src/index.ts
+var VERSION = "0.1.2";
+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."
+    );
+  if (options.previewMaxChargeMicros !== void 0 && (!Number.isSafeInteger(options.previewMaxChargeMicros) || options.previewMaxChargeMicros <= 0))
+    throw new Error("previewMaxChargeMicros must be a positive safe integer.");
+  const previewEnabled = options.hotReload !== false && environment === "development" && Boolean(options.token) && options.upload !== false;
+  const virtualPreview = "virtual:linguana-preview";
+  const virtualId = `\0${virtualPreview}`;
+  let preview;
+  let isServe = false;
+  let base = "/";
+  const coreEntry = normalizePath(
+    fileURLToPath(import.meta.resolve("@linguanahq/core"))
+  );
+  const previewEntry = normalizePath(
+    fileURLToPath(import.meta.resolve("@linguanahq/core/preview"))
+  );
+  let root = process.cwd();
+  let session;
+  let filter;
+  let sawSsr = false;
+  let processSource;
+  const plugin = {
+    name: "linguana:vite",
+    enforce: "pre",
+    config(_, context) {
+      if (previewEnabled && context.command === "serve")
+        return {
+          optimizeDeps: {
+            exclude: [
+              "@linguanahq/core",
+              "@linguanahq/react",
+              "@linguanahq/vue",
+              "@linguanahq/solid",
+              "@linguanahq/svelte"
+            ]
+          }
+        };
+    },
+    resolveId(id) {
+      if (isServe && previewEnabled && id === virtualPreview) return virtualId;
+    },
+    load(id) {
+      if (isServe && previewEnabled && id === virtualId)
+        return previewClientSource(
+          `${base}@fs/${previewEntry}`,
+          options.projectId,
+          sourceLocale
+        );
+    },
+    transformIndexHtml() {
+      if (isServe && previewEnabled)
+        return [
+          {
+            tag: "script",
+            attrs: {
+              type: "module",
+              src: `${base}@id/__x00__${virtualPreview}`
+            },
+            injectTo: "head"
+          }
+        ];
+    },
+    configureServer(server) {
+      if (!previewEnabled || !options.token) return;
+      const clients = /* @__PURE__ */ new Map();
+      preview = new LocalPreview({
+        session: session.options,
+        apiUrl: options.apiUrl ?? "https://api.linguana.dev",
+        token: options.token,
+        maxChargeMicros: options.previewMaxChargeMicros,
+        emit(update) {
+          for (const [client, locales] of clients)
+            if (locales.has(update.locale))
+              client.send("linguana:preview:update", update);
+        }
+      });
+      const watch = (data, client) => {
+        if (!Array.isArray(data?.locales)) return;
+        const locales = data.locales.filter(
+          (locale) => typeof locale === "string" && /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/.test(locale)
+        ).slice(0, 10);
+        if (!clients.has(client))
+          client.socket.once("close", () => {
+            clients.delete(client);
+            preview?.watch([
+              ...new Set([...clients.values()].flatMap((value) => [...value]))
+            ]);
+          });
+        clients.set(client, new Set(locales));
+        preview?.watch([
+          ...new Set([...clients.values()].flatMap((value) => [...value]))
+        ]);
+      };
+      const refresh = () => preview?.refresh();
+      const remove = (file) => preview?.collect(normalizePath(file), null);
+      server.ws.on("linguana:preview:watch", watch);
+      server.ws.on("linguana:preview:refresh", refresh);
+      server.watcher.on("unlink", remove);
+      server.httpServer?.once("close", () => {
+        preview?.dispose();
+        server.ws.off("linguana:preview:watch", watch);
+        server.ws.off("linguana:preview:refresh", refresh);
+        server.watcher.off("unlink", remove);
+      });
+    },
+    closeBundle() {
+      preview?.dispose();
+    },
+    configResolved(config) {
+      root = config.root;
+      isServe = config.command === "serve";
+      base = config.base;
+      filter = createFilter(
+        options.include ?? options.adapter.extensions.map((extension) => `**/*${extension}`),
+        options.exclude ?? ["**/node_modules/**", "**/*.test.*", "**/*.spec.*"]
+      );
+      session = new BuildSession2({
+        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
+        });
+        preview?.collect(cleanId, result);
+        if (!result) return null;
+        if (!isServe) session.collect(result);
+        return {
+          code: result.code,
+          map: result.map
+        };
+      };
+    },
+    async transform(code, id, transformOptions) {
+      if (isServe && previewEnabled && !transformOptions?.ssr && normalizePath(id.split("?")[0] ?? id) === coreEntry)
+        return { code: `import "${virtualPreview}";
+${code}`, map: null };
+      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/preview-client.d.ts

@@ -0,0 +1,2 @@
+/** This module is emitted only by Vite's development server. */
+export declare function previewClientSource(coreModule: string, projectId: string, sourceLocale: string): string;

package/dist/preview.d.ts

@@ -0,0 +1,41 @@
+import { type SourceTransformResult } from "@linguanahq/build-core";
+export type PreviewConfig = {
+    projectId: string;
+    environment: string;
+    sourceLocale: string;
+    hotReload: boolean;
+    maxChargeMicros: number;
+    locales: string[];
+    policyKey: string;
+};
+/** Owns only dev-server memory. Every paid task is durably enqueued by the authenticated API. */
+export declare class LocalPreview {
+    private files;
+    private locales;
+    private states;
+    private jobs;
+    private config?;
+    private configAt;
+    private timer?;
+    private running;
+    private dirty;
+    private disposed;
+    private generation;
+    private retrySequence;
+    private controllers;
+    private options;
+    constructor(options: LocalPreview["options"]);
+    collect(file: string, result: SourceTransformResult | null): void;
+    watch(locales: string[]): void;
+    refresh(): void;
+    dispose(): void;
+    private state;
+    private messages;
+    private prune;
+    private emit;
+    private schedule;
+    private request;
+    private tick;
+    private enqueue;
+    private poll;
+}