@walkinissue/angy 0.2.17

package/dist/plugin.js

@@ -0,0 +1,288 @@
+// src/lib/server/config.ts
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { transform } from "esbuild";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var CONFIG_FILENAMES = [
+  "angy.config.ts",
+  "angy.config.js",
+  "angy.config.mjs",
+  "angy.config.cjs"
+];
+function buildDefaultSystemMessage(sourceLocale, targetLocale) {
+  return `You are an expert product localization assistant translating ${sourceLocale} UI copy into polished ${targetLocale}. Keep already-${targetLocale} text unchanged. Preserve placeholders like {0}, {1}, ICU fragments, HTML-like markers such as <0/> and <strong>, line breaks, punctuation, capitalization, and button-like brevity. Prefer terminology and syntax that stay close to the translated examples so the product voice remains cohesive. Do not invent extra context, do not expand abbreviations unless the examples already do, and avoid semantic drift. Return only high-confidence translation suggestions for the provided untranslated strings.`;
+}
+function assertNonEmptyString(value, key) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[angy] ${key} is required and must be a non-empty string.`);
+  }
+}
+function validateRoutePath(routePath) {
+  if (routePath == null || routePath === "") return;
+  if (typeof routePath !== "string" || !routePath.startsWith("/")) {
+    throw new Error(`[angy] routePath must be an absolute path starting with "/".`);
+  }
+}
+function validateWatchIgnore(watchIgnore) {
+  if (watchIgnore == null) return;
+  if (!Array.isArray(watchIgnore) || watchIgnore.some((item) => typeof item !== "string")) {
+    throw new Error(`[angy] watchIgnore must be an array of strings.`);
+  }
+}
+function validateSuggestionProvider(suggestionProvider) {
+  if (suggestionProvider == null) return;
+  if (typeof suggestionProvider !== "function") {
+    throw new Error(`[angy] suggestionProvider must be a function.`);
+  }
+}
+var config = {
+  basePoPath: resolve(__dirname, "../../locales/en.po"),
+  workingPoPath: resolve(__dirname, "../../locales/en-working.po"),
+  sourceLocale: "sv",
+  targetLocale: "en",
+  routePath: "/api/translations",
+  apiKey: "",
+  systemMessage: buildDefaultSystemMessage("sv", "en"),
+  suggestionModel: "gpt-4.1-mini",
+  watchIgnore: ["**/en-working.po"]
+};
+var loadedConfigRoot = null;
+var workingCatalogWatchControllers = /* @__PURE__ */ new Set();
+function configureTranslationHelper(next) {
+  Object.assign(config, next);
+}
+function inferLocaleFromCatalogPath(path) {
+  const fileName = basename(path);
+  if (!fileName) return null;
+  return fileName.slice(0, fileName.length - extname(fileName).length) || null;
+}
+function resolveLocaleAlias(value, paths) {
+  if (value === "working") {
+    const locale = inferLocaleFromCatalogPath(paths.workingPoPath);
+    if (!locale) {
+      throw new Error("[angy] Unable to infer locale from workingPoPath.");
+    }
+    return locale;
+  }
+  if (value === "base") {
+    const locale = inferLocaleFromCatalogPath(paths.basePoPath);
+    if (!locale) {
+      throw new Error("[angy] Unable to infer locale from basePoPath.");
+    }
+    return locale;
+  }
+  return value;
+}
+function validateLocaleAliasUsage(sourceLocale, targetLocale) {
+  if (sourceLocale === "working") {
+    throw new Error('[angy] sourceLocale cannot be "working". Use an explicit source locale.');
+  }
+  if (targetLocale === "base") {
+    throw new Error('[angy] targetLocale cannot be "base". Use an explicit target locale or "working".');
+  }
+}
+function registerWorkingCatalogWatchController(controller) {
+  workingCatalogWatchControllers.add(controller);
+  return () => {
+    workingCatalogWatchControllers.delete(controller);
+  };
+}
+function normalizeTranslationHelperConfig(root, next) {
+  const normalized = { ...next };
+  if (normalized.basePoPath && !isAbsolute(normalized.basePoPath)) {
+    normalized.basePoPath = resolve(root, normalized.basePoPath);
+  }
+  if (normalized.workingPoPath && !isAbsolute(normalized.workingPoPath)) {
+    normalized.workingPoPath = resolve(root, normalized.workingPoPath);
+  }
+  return normalized;
+}
+function resolveConfiguredLocaleAliases(next) {
+  const rawSourceLocale = next.sourceLocale;
+  const rawTargetLocale = next.targetLocale;
+  const resolvedSourceLocale = resolveLocaleAlias(rawSourceLocale, next);
+  const resolvedTargetLocale = resolveLocaleAlias(rawTargetLocale, next);
+  const usesDefaultSystemMessage = next.systemMessage === buildDefaultSystemMessage(rawSourceLocale, rawTargetLocale);
+  return {
+    ...next,
+    sourceLocale: resolvedSourceLocale,
+    targetLocale: resolvedTargetLocale,
+    systemMessage: usesDefaultSystemMessage ? buildDefaultSystemMessage(resolvedSourceLocale, resolvedTargetLocale) : next.systemMessage
+  };
+}
+function completeAngyConfig(input) {
+  assertNonEmptyString(input.basePoPath, "basePoPath");
+  assertNonEmptyString(input.workingPoPath, "workingPoPath");
+  assertNonEmptyString(input.sourceLocale, "sourceLocale");
+  assertNonEmptyString(input.targetLocale, "targetLocale");
+  validateLocaleAliasUsage(input.sourceLocale, input.targetLocale);
+  if (typeof input.apiKey !== "string") {
+    throw new Error(`[angy] apiKey is required and must be a string. Use an empty string to disable suggestions.`);
+  }
+  validateRoutePath(input.routePath);
+  validateWatchIgnore(input.watchIgnore);
+  validateSuggestionProvider(input.suggestionProvider);
+  return {
+    basePoPath: input.basePoPath,
+    workingPoPath: input.workingPoPath,
+    sourceLocale: input.sourceLocale,
+    targetLocale: input.targetLocale,
+    routePath: input.routePath ?? "/api/translations",
+    apiKey: input.apiKey,
+    systemMessage: input.systemMessage ?? buildDefaultSystemMessage(input.sourceLocale, input.targetLocale),
+    suggestionModel: input.suggestionModel ?? "gpt-4.1-mini",
+    watchIgnore: input.watchIgnore ?? ["**/en-working.po"],
+    suggestionProvider: input.suggestionProvider
+  };
+}
+function defineAngyConfig(config2) {
+  return completeAngyConfig(config2);
+}
+async function fileExists(path) {
+  try {
+    await readFile(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTsConfigModule(path) {
+  const source = await readFile(path, "utf8");
+  const transformed = await transform(source, {
+    loader: "ts",
+    format: "esm",
+    target: "es2022"
+  });
+  const tempPath = `${path}.angy.tmp.mjs`;
+  await writeFile(tempPath, transformed.code, "utf8");
+  try {
+    return await import(`${pathToFileURL(tempPath).href}?t=${Date.now()}`);
+  } finally {
+    await unlink(tempPath).catch(() => void 0);
+  }
+}
+async function loadJsConfigModule(path) {
+  return import(pathToFileURL(path).href);
+}
+async function loadAngyConfigFromRoot(root) {
+  if (loadedConfigRoot === root) {
+    return config;
+  }
+  for (const filename of CONFIG_FILENAMES) {
+    const fullPath = `${root}/${filename}`.replace(/\\/g, "/");
+    if (!await fileExists(fullPath)) continue;
+    const module = filename.endsWith(".ts") ? await loadTsConfigModule(fullPath) : await loadJsConfigModule(fullPath);
+    const raw = module.default ?? module.config ?? {};
+    const next = resolveConfiguredLocaleAliases(
+      normalizeTranslationHelperConfig(root, completeAngyConfig(raw))
+    );
+    configureTranslationHelper(next);
+    loadedConfigRoot = root;
+    return config;
+  }
+  loadedConfigRoot = root;
+  return config;
+}
+
+// src/lib/plugin.ts
+import { basename as basename2, relative } from "node:path";
+function angy(options = {}) {
+  let root = process.cwd();
+  let resolvedConfig = options.config ?? null;
+  let unregisterWatchController = null;
+  const rewatchTimers = /* @__PURE__ */ new Map();
+  function normalizePath(path) {
+    return path.replace(/\\/g, "/");
+  }
+  return {
+    name: "angy",
+    apply: "serve",
+    async config(config2, env) {
+      root = config2.root ? `${process.cwd()}/${config2.root}`.replace(/\\/g, "/") : process.cwd().replace(/\\/g, "/");
+      if (env.mode !== "development") {
+        return;
+      }
+      resolvedConfig ??= await loadAngyConfigFromRoot(root);
+      if (!resolvedConfig) {
+        return;
+      }
+      const watchIgnore = resolvedConfig.watchIgnore ?? ["**/en-working.po"];
+      const workingPoPath = normalizePath(resolvedConfig.workingPoPath ?? "");
+      const workingPoRelative = workingPoPath ? normalizePath(relative(root, workingPoPath)) : "";
+      const workingPoName = workingPoPath ? basename2(workingPoPath) : "";
+      const localeRotation = Array.from(
+        new Set(
+          [
+            resolvedConfig.sourceLocale,
+            resolvedConfig.targetLocale,
+            workingPoPath ? inferLocaleFromCatalogPath(workingPoPath) : null
+          ].filter((locale) => Boolean(locale))
+        )
+      );
+      const filteredWatchIgnore = watchIgnore.filter((pattern) => {
+        const normalizedPattern = normalizePath(pattern);
+        if (!workingPoPath) return true;
+        if (normalizedPattern === workingPoPath || normalizedPattern === workingPoRelative) {
+          return false;
+        }
+        if (workingPoName && normalizedPattern.includes(workingPoName)) {
+          return false;
+        }
+        return true;
+      });
+      return {
+        define: {
+          __ANGY_ROUTE_PATH__: JSON.stringify(resolvedConfig.routePath ?? "/api/translations"),
+          __ANGY_LOCALES: JSON.stringify(localeRotation)
+        },
+        optimizeDeps: {
+          exclude: ["angy", "angy/client", "angy/plugin", "angy/server"]
+        },
+        server: {
+          watch: {
+            ignored: filteredWatchIgnore
+          }
+        }
+      };
+    },
+    configureServer(server) {
+      unregisterWatchController?.();
+      unregisterWatchController = registerWorkingCatalogWatchController((path, delayMs = 800) => {
+        const normalizedPath = normalizePath(path);
+        const existingTimer = rewatchTimers.get(normalizedPath);
+        if (existingTimer) {
+          clearTimeout(existingTimer);
+        } else {
+          server.watcher.unwatch(normalizedPath);
+        }
+        const timer = setTimeout(() => {
+          server.watcher.add(normalizedPath);
+          rewatchTimers.delete(normalizedPath);
+        }, delayMs);
+        rewatchTimers.set(normalizedPath, timer);
+      });
+    },
+    configResolved(config2) {
+      root = config2.root.replace(/\\/g, "/");
+      if (!resolvedConfig) {
+        config2.logger?.warn(
+          "[angy] No angy.config.(ts|js|mjs|cjs) found. The helper will stay disabled."
+        );
+      }
+    },
+    buildEnd() {
+      unregisterWatchController?.();
+      unregisterWatchController = null;
+      for (const timer of rewatchTimers.values()) {
+        clearTimeout(timer);
+      }
+      rewatchTimers.clear();
+    }
+  };
+}
+export {
+  angy,
+  defineAngyConfig
+};

package/dist/server/types.ts

@@ -0,0 +1,40 @@
+export type TranslationOrigin = "base" | "working";
+
+export type CommitBatchItem = {
+	resolvedMsgid: string;
+	resolvedMsgctxt: string | null;
+	translationValue: string;
+};
+
+export type PoComment = {
+	reference?: string;
+	extracted?: string;
+	flag?: string;
+	previous?: string;
+};
+
+export type PoTranslationEntry = {
+	msgid?: string;
+	msgid_plural?: string;
+	msgstr?: string[];
+	msgctxt?: string;
+	comments?: PoComment;
+	obsolete?: boolean;
+};
+
+export type NormalizedEntry = {
+	msgid: string;
+	msgctxt: string | null;
+	msgidPlural: string | null;
+	msgstr: string[];
+	references: string[];
+	extractedComments: string[];
+	flags: string[];
+	previous: string[];
+	obsolete: boolean;
+	searchText: string;
+	searchTokens: string[];
+	hasTranslation: boolean;
+	isFuzzy: boolean | undefined;
+	translationOrigin: TranslationOrigin;
+};

package/dist/server.d.ts

@@ -0,0 +1,95 @@
+import type { RequestHandler } from "@sveltejs/kit";
+
+export type TranslationOrigin = "base" | "working";
+
+export type TranslationEntry = {
+	msgid: string;
+	msgctxt: string | null;
+	msgidPlural: string | null;
+	msgstr: string[];
+	references: string[];
+	extractedComments: string[];
+	flags: string[];
+	previous: string[];
+	obsolete: boolean;
+	hasTranslation?: boolean;
+	isFuzzy?: boolean | null;
+	isCommittedToWorking?: boolean;
+	translationOrigin?: TranslationOrigin | null;
+};
+
+export type TranslationAlternative = {
+	msgid: string;
+	msgctxt: string | null;
+	score: number;
+	references: string[];
+	msgstr: string[];
+	hasTranslation: boolean;
+	isFuzzy: boolean | null | undefined;
+	isCommittedToWorking?: boolean;
+	translationOrigin?: TranslationOrigin | null;
+};
+
+export type TranslationContextResult = {
+	match: {
+		score: number;
+		via: string;
+	};
+	entry: TranslationEntry;
+	alternatives: TranslationAlternative[];
+};
+
+export type SuggestionRequestItem = {
+	msgid: string;
+	msgctxt: string | null;
+};
+
+export type SuggestionResponseItem = {
+	msgid: string;
+	msgctxt: string | null;
+	suggestion: string;
+};
+
+export type SuggestionProviderInput = {
+	context: TranslationContextResult;
+	items: SuggestionRequestItem[];
+	sourceLocale: string;
+	targetLocale: string;
+	systemMessage: string;
+	model: string;
+	apiKey: string;
+};
+
+export type SuggestionProvider = (
+	input: SuggestionProviderInput
+) => Promise<SuggestionResponseItem[]>;
+
+export type AngyConfigInput = {
+	basePoPath: string;
+	workingPoPath: string;
+	sourceLocale: string;
+	targetLocale: string;
+	routePath?: string;
+	apiKey: string;
+	systemMessage?: string;
+	suggestionModel?: string;
+	watchIgnore?: string[];
+	suggestionProvider?: SuggestionProvider;
+};
+
+export type AngyResolvedConfig = {
+	basePoPath: string;
+	workingPoPath: string;
+	sourceLocale: string;
+	targetLocale: string;
+	routePath: string;
+	apiKey: string;
+	systemMessage: string;
+	suggestionModel: string;
+	watchIgnore: string[];
+	suggestionProvider?: SuggestionProvider;
+};
+
+export declare function defineAngyConfig(config: AngyConfigInput): AngyResolvedConfig;
+
+export declare const handler: RequestHandler;