@dialekt/adapter-paraglide 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,37 @@
+<div>
+  <img src="../../resources/icon.svg" align="left" width="175">
+</div>
+
+# `@dialekt/adapter-paraglide`
+
+Paraglide adapter for [dialekt](https://github.com/mateffy/dialekt). Reads and writes inlang message-format JSON files (`messages/{locale}.json`), scans `.ts`, `.svelte`, and `.vue` source files for `m.key()` references, and reports unused keys.
+
+<br>
+
+## Install
+
+```bash
+npm install -D @dialekt/adapter-paraglide
+```
+
+## Use
+
+```ts
+import { defineConfig } from "dialekt";
+import { paraglide } from "@dialekt/adapter-paraglide";
+
+export default defineConfig({
+  sourceLocale: "en",
+  targetLocales: ["de", "fr", "es"],
+  adapters: [
+    paraglide({
+      messagesDir: "./messages",
+      scanPaths: ["./src"],
+    }),
+  ],
+});
+```
+
+## Full documentation
+
+See the [dialekt GitHub README](https://github.com/mateffy/dialekt) for commands, translation strategies, and the programmatic API.

package/TESTING.md

@@ -2,11 +2,11 @@
 
 ## Tested Areas Map
 
-| Export | Test File | Status |
-|--------|-----------|--------|
-| `paraglide()` adapter | `src/adapter.test.ts` | ✅ |
-| `readMessageFile` / `writeMessageFile` | `src/message-file.test.ts` | ✅ |
-| `findUnusedParaglideKeys` | `src/unused-keys.test.ts` | ✅ |
+| Export                                 | Test File                  | Status |
+| -------------------------------------- | -------------------------- | ------ |
+| `paraglide()` adapter                  | `src/adapter.test.ts`      | ✅     |
+| `readMessageFile` / `writeMessageFile` | `src/message-file.test.ts` | ✅     |
+| `findUnusedParaglideKeys`              | `src/unused-keys.test.ts`  | ✅     |
 
 ## Known Coverage Gaps
 

package/dist/index.d.mts

@@ -7,4 +7,4 @@ interface ParaglideAdapterOptions {
 }
 declare function paraglide(options: ParaglideAdapterOptions): TranslationAdapter;
 //#endregion
-export { type ParaglideAdapterOptions, paraglide };
+export { type ParaglideAdapterOptions, paraglide };

package/dist/index.mjs

@@ -1,127 +1,187 @@
 import { Effect } from "effect";
 import { Path } from "@effect/platform/Path";
 import { FileSystem } from "@effect/platform/FileSystem";
-import { AdapterReadError, AdapterWriteError, NodePlatformLayer, flattenObject, unflattenObject } from "dialekt";
+import {
+  AdapterReadError,
+  AdapterWriteError,
+  NodePlatformLayer,
+  flattenObject,
+  unflattenObject,
+} from "dialekt";
 import { FileSystem as FileSystem$1, Path as Path$1 } from "@effect/platform";
 //#region src/message-file.ts
 function readMessageFile(path) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem$1.FileSystem;
-		if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false)))) return {
-			translations: {},
-			meta: {}
-		};
-		const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => "{}"));
-		const parsed = yield* Effect.try({
-			try: () => JSON.parse(content),
-			catch: () => ({})
-		}).pipe(Effect.orElseSucceed(() => ({})));
-		const meta = {};
-		const translations = {};
-		for (const [key, value] of Object.entries(parsed)) if (key.startsWith("$")) meta[key] = value;
-		else if (typeof value === "string") translations[key] = value;
-		else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-			const flattened = flattenObject(value);
-			for (const [flatKey, flatValue] of Object.entries(flattened)) if (typeof flatValue === "string") translations[`${key}.${flatKey}`] = flatValue;
-		}
-		return {
-			translations,
-			meta
-		};
-	});
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem$1.FileSystem;
+    if (!(yield* fs.exists(path).pipe(Effect.orElseSucceed(() => false))))
+      return {
+        translations: {},
+        meta: {},
+      };
+    const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => "{}"));
+    const parsed = yield* Effect.try({
+      try: () => JSON.parse(content),
+      catch: () => ({}),
+    }).pipe(Effect.orElseSucceed(() => ({})));
+    const meta = {};
+    const translations = {};
+    for (const [key, value] of Object.entries(parsed))
+      if (key.startsWith("$")) meta[key] = value;
+      else if (typeof value === "string") translations[key] = value;
+      else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const flattened = flattenObject(value);
+        for (const [flatKey, flatValue] of Object.entries(flattened))
+          if (typeof flatValue === "string") translations[`${key}.${flatKey}`] = flatValue;
+      }
+    return {
+      translations,
+      meta,
+    };
+  });
 }
 function writeMessageFile(path, translations, meta) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem$1.FileSystem;
-		const dir = (yield* Path$1.Path).dirname(path);
-		yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orElseSucceed(() => void 0));
-		const unflattened = unflattenObject(translations);
-		const output = { ...meta };
-		for (const [key, value] of Object.entries(unflattened)) output[key] = value;
-		yield* fs.writeFileString(path, JSON.stringify(output, null, 2) + "\n").pipe(Effect.orElseSucceed(() => void 0));
-	});
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem$1.FileSystem;
+    const dir = (yield* Path$1.Path).dirname(path);
+    yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orElseSucceed(() => void 0));
+    const unflattened = unflattenObject(translations);
+    const output = { ...meta };
+    for (const [key, value] of Object.entries(unflattened)) output[key] = value;
+    yield* fs
+      .writeFileString(path, JSON.stringify(output, null, 2) + "\n")
+      .pipe(Effect.orElseSucceed(() => void 0));
+  });
 }
 //#endregion
 //#region src/unused-keys.ts
 function findUnusedParaglideKeys(scanPaths, keys) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem$1.FileSystem;
-		const path = yield* Path$1.Path;
-		const referenced = /* @__PURE__ */ new Set();
-		for (const scanPath of scanPaths) {
-			if (!(yield* fs.exists(scanPath).pipe(Effect.orElseSucceed(() => false)))) continue;
-			const entries = yield* fs.readDirectory(scanPath, { recursive: true }).pipe(Effect.orElseSucceed(() => []));
-			for (const relativePath of entries) {
-				if (!relativePath.endsWith(".ts") && !relativePath.endsWith(".tsx") && !relativePath.endsWith(".js") && !relativePath.endsWith(".jsx") && !relativePath.endsWith(".svelte") && !relativePath.endsWith(".vue")) continue;
-				const filePath = path.join(scanPath, relativePath);
-				const content = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ""));
-				for (const key of keys) if (new RegExp(`\\bm\\.${key}\\b`).test(content)) referenced.add(key);
-			}
-		}
-		return keys.filter((key) => !referenced.has(key));
-	}).pipe(Effect.mapError((cause) => new AdapterReadError({
-		adapter: "paraglide",
-		locale: "",
-		resource: "messages",
-		cause
-	})));
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem$1.FileSystem;
+    const path = yield* Path$1.Path;
+    const referenced = /* @__PURE__ */ new Set();
+    for (const scanPath of scanPaths) {
+      if (!(yield* fs.exists(scanPath).pipe(Effect.orElseSucceed(() => false)))) continue;
+      const entries = yield* fs
+        .readDirectory(scanPath, { recursive: true })
+        .pipe(Effect.orElseSucceed(() => []));
+      for (const relativePath of entries) {
+        if (
+          !relativePath.endsWith(".ts") &&
+          !relativePath.endsWith(".tsx") &&
+          !relativePath.endsWith(".js") &&
+          !relativePath.endsWith(".jsx") &&
+          !relativePath.endsWith(".svelte") &&
+          !relativePath.endsWith(".vue")
+        )
+          continue;
+        const filePath = path.join(scanPath, relativePath);
+        const content = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ""));
+        for (const key of keys)
+          if (new RegExp(`\\bm\\.${key}\\b`).test(content)) referenced.add(key);
+      }
+    }
+    return keys.filter((key) => !referenced.has(key));
+  }).pipe(
+    Effect.mapError(
+      (cause) =>
+        new AdapterReadError({
+          adapter: "paraglide",
+          locale: "",
+          resource: "messages",
+          cause,
+        }),
+    ),
+  );
 }
 //#endregion
 //#region src/adapter.ts
 function paraglide(options) {
-	const { messagesDir, scanPaths = [] } = options;
-	return {
-		name: "paraglide",
-		capabilities: {
-			canCreateResource: true,
-			unusedKeyDetection: true
-		},
-		listLocales: () => Effect.gen(function* () {
-			const fs = yield* FileSystem;
-			yield* Path;
-			if (!(yield* fs.exists(messagesDir).pipe(Effect.orElseSucceed(() => false)))) return [];
-			const entries = yield* fs.readDirectory(messagesDir).pipe(Effect.orElseSucceed(() => []));
-			const locales = [];
-			for (const entry of entries) if (entry.endsWith(".json")) locales.push(entry.replace(/\.json$/, ""));
-			return locales;
-		}).pipe(Effect.mapError((cause) => new AdapterReadError({
-			adapter: "paraglide",
-			locale: "",
-			resource: "",
-			cause
-		})), Effect.provide([NodePlatformLayer])),
-		listResources: () => Effect.succeed([{
-			key: "messages",
-			label: "messages"
-		}]),
-		readResource: (locale, resource) => Effect.gen(function* () {
-			return (yield* readMessageFile((yield* Path).join(messagesDir, `${locale}.json`)).pipe(Effect.mapError((cause) => new AdapterReadError({
-				adapter: "paraglide",
-				locale,
-				resource: resource.key,
-				cause
-			})))).translations;
-		}).pipe(Effect.provide([NodePlatformLayer])),
-		writeResource: (locale, resource, entries) => Effect.gen(function* () {
-			const filePath = (yield* Path).join(messagesDir, `${locale}.json`);
-			yield* writeMessageFile(filePath, entries, (yield* readMessageFile(filePath).pipe(Effect.orElseSucceed(() => ({
-				translations: {},
-				meta: {}
-			})))).meta).pipe(Effect.mapError((cause) => new AdapterWriteError({
-				adapter: "paraglide",
-				locale,
-				resource: resource.key,
-				cause
-			})));
-		}).pipe(Effect.provide([NodePlatformLayer])),
-		findUnusedKeys: (locale, resource) => Effect.gen(function* () {
-			const path = yield* Path;
-			return yield* findUnusedParaglideKeys(scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, "..")], yield* Effect.gen(function* () {
-				const map = yield* paraglide(options).readResource(locale, resource);
-				return Object.keys(map);
-			}));
-		}).pipe(Effect.provide([NodePlatformLayer]))
-	};
+  const { messagesDir, scanPaths = [] } = options;
+  return {
+    name: "paraglide",
+    capabilities: {
+      canCreateResource: true,
+      unusedKeyDetection: true,
+    },
+    listLocales: () =>
+      Effect.gen(function* () {
+        const fs = yield* FileSystem;
+        yield* Path;
+        if (!(yield* fs.exists(messagesDir).pipe(Effect.orElseSucceed(() => false)))) return [];
+        const entries = yield* fs.readDirectory(messagesDir).pipe(Effect.orElseSucceed(() => []));
+        const locales = [];
+        for (const entry of entries)
+          if (entry.endsWith(".json")) locales.push(entry.replace(/\.json$/, ""));
+        return locales;
+      }).pipe(
+        Effect.mapError(
+          (cause) =>
+            new AdapterReadError({
+              adapter: "paraglide",
+              locale: "",
+              resource: "",
+              cause,
+            }),
+        ),
+        Effect.provide([NodePlatformLayer]),
+      ),
+    listResources: () =>
+      Effect.succeed([
+        {
+          key: "messages",
+          label: "messages",
+        },
+      ]),
+    readResource: (locale, resource) =>
+      Effect.gen(function* () {
+        return (yield* readMessageFile((yield* Path).join(messagesDir, `${locale}.json`)).pipe(
+          Effect.mapError(
+            (cause) =>
+              new AdapterReadError({
+                adapter: "paraglide",
+                locale,
+                resource: resource.key,
+                cause,
+              }),
+          ),
+        )).translations;
+      }).pipe(Effect.provide([NodePlatformLayer])),
+    writeResource: (locale, resource, entries) =>
+      Effect.gen(function* () {
+        const filePath = (yield* Path).join(messagesDir, `${locale}.json`);
+        yield* writeMessageFile(
+          filePath,
+          entries,
+          (yield* readMessageFile(filePath).pipe(
+            Effect.orElseSucceed(() => ({
+              translations: {},
+              meta: {},
+            })),
+          )).meta,
+        ).pipe(
+          Effect.mapError(
+            (cause) =>
+              new AdapterWriteError({
+                adapter: "paraglide",
+                locale,
+                resource: resource.key,
+                cause,
+              }),
+          ),
+        );
+      }).pipe(Effect.provide([NodePlatformLayer])),
+    findUnusedKeys: (locale, resource) =>
+      Effect.gen(function* () {
+        const path = yield* Path;
+        return yield* findUnusedParaglideKeys(
+          scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, "..")],
+          yield* Effect.gen(function* () {
+            const map = yield* paraglide(options).readResource(locale, resource);
+            return Object.keys(map);
+          }),
+        );
+      }).pipe(Effect.provide([NodePlatformLayer])),
+  };
 }
 //#endregion
 export { paraglide };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dialekt/adapter-paraglide",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "exports": {
     ".": {
@@ -11,7 +11,7 @@
   "dependencies": {
     "@effect/platform": "^0.96.0",
     "effect": "^3.21.0",
-    "dialekt": "0.1.0"
+    "dialekt": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",

package/src/adapter.test.ts

@@ -1,102 +1,109 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { NodePlatformLayer } from 'dialekt';
-import { paraglide } from './adapter.js';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('paraglide adapter', () => {
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { NodePlatformLayer } from "dialekt";
+import { paraglide } from "./adapter.js";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("paraglide adapter", () => {
   const testDir = join(tmpdir(), `paraglide-adapter-test-${Date.now()}`);
 
-  it('reads a message resource', async () => {
+  it("reads a message resource", async () => {
     mkdirSync(testDir, { recursive: true });
-    writeFileSync(join(testDir, 'en.json'), JSON.stringify({ greeting: 'Hello' }));
+    writeFileSync(join(testDir, "en.json"), JSON.stringify({ greeting: "Hello" }));
 
     const adapter = paraglide({ messagesDir: testDir, scanPaths: [testDir] });
-    const program = adapter.readResource('en', { key: 'messages', label: 'messages' }).pipe(
-      Effect.provide(NodePlatformLayer),
-    );
+    const program = adapter
+      .readResource("en", { key: "messages", label: "messages" })
+      .pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(program);
-    expect(result).toEqual({ greeting: 'Hello' });
+    expect(result).toEqual({ greeting: "Hello" });
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('lists locales from filenames', async () => {
+  it("lists locales from filenames", async () => {
     mkdirSync(testDir, { recursive: true });
-    writeFileSync(join(testDir, 'en.json'), '{}');
-    writeFileSync(join(testDir, 'de.json'), '{}');
+    writeFileSync(join(testDir, "en.json"), "{}");
+    writeFileSync(join(testDir, "de.json"), "{}");
 
     const adapter = paraglide({ messagesDir: testDir });
     const program = adapter.listLocales().pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(program);
-    expect(result).toContain('en');
-    expect(result).toContain('de');
+    expect(result).toContain("en");
+    expect(result).toContain("de");
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('lists exactly one resource', async () => {
+  it("lists exactly one resource", async () => {
     const adapter = paraglide({ messagesDir: testDir });
-    const program = adapter.listResources('en').pipe(Effect.provide(NodePlatformLayer));
+    const program = adapter.listResources("en").pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(program);
     expect(result).toHaveLength(1);
-    expect(result[0]).toEqual({ key: 'messages', label: 'messages' });
+    expect(result[0]).toEqual({ key: "messages", label: "messages" });
   });
 
-  it('round-trips write and read preserving meta', async () => {
+  it("round-trips write and read preserving meta", async () => {
     mkdirSync(testDir, { recursive: true });
     writeFileSync(
-      join(testDir, 'de.json'),
-      JSON.stringify({ $schema: 'https://inlang.com/schema', greeting: 'Hallo' }),
+      join(testDir, "de.json"),
+      JSON.stringify({ $schema: "https://inlang.com/schema", greeting: "Hallo" }),
     );
 
     const adapter = paraglide({ messagesDir: testDir });
     const writeProgram = adapter
-      .writeResource('de', { key: 'messages', label: 'messages' }, { greeting: 'Hallo!', farewell: 'Tschüss' })
+      .writeResource(
+        "de",
+        { key: "messages", label: "messages" },
+        { greeting: "Hallo!", farewell: "Tschüss" },
+      )
       .pipe(Effect.provide(NodePlatformLayer));
     await Effect.runPromise(writeProgram);
 
-    const readProgram = adapter.readResource('de', { key: 'messages', label: 'messages' }).pipe(
-      Effect.provide(NodePlatformLayer),
-    );
+    const readProgram = adapter
+      .readResource("de", { key: "messages", label: "messages" })
+      .pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(readProgram);
-    expect(result).toEqual({ greeting: 'Hallo!', farewell: 'Tschüss' });
+    expect(result).toEqual({ greeting: "Hallo!", farewell: "Tschüss" });
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('finds unused keys', async () => {
+  it("finds unused keys", async () => {
     mkdirSync(testDir, { recursive: true });
-    writeFileSync(join(testDir, 'en.json'), JSON.stringify({ greeting: 'Hello', farewell: 'Goodbye' }));
-    mkdirSync(join(testDir, 'src'), { recursive: true });
-    writeFileSync(join(testDir, 'src', 'page.ts'), 'm.greeting();');
+    writeFileSync(
+      join(testDir, "en.json"),
+      JSON.stringify({ greeting: "Hello", farewell: "Goodbye" }),
+    );
+    mkdirSync(join(testDir, "src"), { recursive: true });
+    writeFileSync(join(testDir, "src", "page.ts"), "m.greeting();");
 
-    const adapter = paraglide({ messagesDir: testDir, scanPaths: [join(testDir, 'src')] });
-    const program = adapter
-      .findUnusedKeys!('en', { key: 'messages', label: 'messages' })
-      .pipe(Effect.provide(NodePlatformLayer));
+    const adapter = paraglide({ messagesDir: testDir, scanPaths: [join(testDir, "src")] });
+    const program = adapter.findUnusedKeys!("en", { key: "messages", label: "messages" }).pipe(
+      Effect.provide(NodePlatformLayer),
+    );
     const result = await Effect.runPromise(program);
-    expect(result).toEqual(['farewell']);
+    expect(result).toEqual(["farewell"]);
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('returns empty for missing locale file', async () => {
+  it("returns empty for missing locale file", async () => {
     mkdirSync(testDir, { recursive: true });
 
     const adapter = paraglide({ messagesDir: testDir });
-    const program = adapter.readResource('missing', { key: 'messages', label: 'messages' }).pipe(
-      Effect.provide(NodePlatformLayer),
-    );
+    const program = adapter
+      .readResource("missing", { key: "messages", label: "messages" })
+      .pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(program);
     expect(result).toEqual({});
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('handles empty messages directory', async () => {
+  it("handles empty messages directory", async () => {
     mkdirSync(testDir, { recursive: true });
 
     const adapter = paraglide({ messagesDir: testDir });
@@ -107,48 +114,48 @@ describe('paraglide adapter', () => {
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('handles capabilities flags', () => {
+  it("handles capabilities flags", () => {
     const adapter = paraglide({ messagesDir: testDir });
     expect(adapter.capabilities.canCreateResource).toBe(true);
     expect(adapter.capabilities.unusedKeyDetection).toBe(true);
   });
 
-  it('reports adapter name', () => {
+  it("reports adapter name", () => {
     const adapter = paraglide({ messagesDir: testDir });
-    expect(adapter.name).toBe('paraglide');
+    expect(adapter.name).toBe("paraglide");
   });
 
-  it('ignores non-JSON files', async () => {
+  it("ignores non-JSON files", async () => {
     mkdirSync(testDir, { recursive: true });
-    writeFileSync(join(testDir, 'README.md'), '# Messages');
-    writeFileSync(join(testDir, 'en.json'), '{}');
+    writeFileSync(join(testDir, "README.md"), "# Messages");
+    writeFileSync(join(testDir, "en.json"), "{}");
 
     const adapter = paraglide({ messagesDir: testDir });
     const program = adapter.listLocales().pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(program);
-    expect(result).toEqual(['en']);
+    expect(result).toEqual(["en"]);
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('preserves meta keys on write', async () => {
+  it("preserves meta keys on write", async () => {
     mkdirSync(testDir, { recursive: true });
     writeFileSync(
-      join(testDir, 'de.json'),
-      JSON.stringify({ $schema: 'https://inlang.com/schema', module: 'messages' }),
+      join(testDir, "de.json"),
+      JSON.stringify({ $schema: "https://inlang.com/schema", module: "messages" }),
     );
 
     const adapter = paraglide({ messagesDir: testDir });
     const writeProgram = adapter
-      .writeResource('de', { key: 'messages', label: 'messages' }, { hello: 'Hallo' })
+      .writeResource("de", { key: "messages", label: "messages" }, { hello: "Hallo" })
       .pipe(Effect.provide(NodePlatformLayer));
     await Effect.runPromise(writeProgram);
 
-    const readProgram = adapter.readResource('de', { key: 'messages', label: 'messages' }).pipe(
-      Effect.provide(NodePlatformLayer),
-    );
+    const readProgram = adapter
+      .readResource("de", { key: "messages", label: "messages" })
+      .pipe(Effect.provide(NodePlatformLayer));
     const result = await Effect.runPromise(readProgram);
-    expect(result).toEqual({ hello: 'Hallo' });
+    expect(result).toEqual({ hello: "Hallo" });
 
     rmSync(testDir, { recursive: true, force: true });
   });

package/src/adapter.ts

@@ -1,19 +1,14 @@
-import { Effect } from 'effect';
-import { Path } from '@effect/platform/Path';
-import { FileSystem } from '@effect/platform/FileSystem';
-import type {
-  ResourceRef,
-  TranslationAdapter,
-  AdapterReadError,
-  AdapterWriteError,
-} from 'dialekt';
+import { Effect } from "effect";
+import { Path } from "@effect/platform/Path";
+import { FileSystem } from "@effect/platform/FileSystem";
+import type { ResourceRef, TranslationAdapter, AdapterReadError, AdapterWriteError } from "dialekt";
 import {
   AdapterReadError as AdapterReadErrorClass,
   AdapterWriteError as AdapterWriteErrorClass,
   NodePlatformLayer,
-} from 'dialekt';
-import { readMessageFile, writeMessageFile } from './message-file.js';
-import { findUnusedParaglideKeys } from './unused-keys.js';
+} from "dialekt";
+import { readMessageFile, writeMessageFile } from "./message-file.js";
+import { findUnusedParaglideKeys } from "./unused-keys.js";
 
 export interface ParaglideAdapterOptions {
   readonly messagesDir: string;
@@ -24,7 +19,7 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
   const { messagesDir, scanPaths = [] } = options;
 
   return {
-    name: 'paraglide',
+    name: "paraglide",
     capabilities: {
       canCreateResource: true,
       unusedKeyDetection: true,
@@ -36,13 +31,13 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
         const path = yield* Path;
         const exists = yield* fs.exists(messagesDir).pipe(Effect.orElseSucceed(() => false));
         if (!exists) return [];
-        const entries = yield* fs.readDirectory(messagesDir).pipe(
-          Effect.orElseSucceed(() => [] as string[]),
-        );
+        const entries = yield* fs
+          .readDirectory(messagesDir)
+          .pipe(Effect.orElseSucceed(() => [] as string[]));
         const locales: string[] = [];
         for (const entry of entries) {
-          if (entry.endsWith('.json')) {
-            locales.push(entry.replace(/\.json$/, ''));
+          if (entry.endsWith(".json")) {
+            locales.push(entry.replace(/\.json$/, ""));
           }
         }
         return locales;
@@ -50,17 +45,16 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
         Effect.mapError(
           (cause) =>
             new AdapterReadErrorClass({
-              adapter: 'paraglide',
-              locale: '',
-              resource: '',
+              adapter: "paraglide",
+              locale: "",
+              resource: "",
               cause,
             }) as AdapterReadError,
         ),
         Effect.provide([NodePlatformLayer]),
       ) as Effect.Effect<readonly string[], AdapterReadError, never>,
 
-    listResources: () =>
-      Effect.succeed([{ key: 'messages', label: 'messages' }]),
+    listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
 
     readResource: (locale, resource) =>
       Effect.gen(function* () {
@@ -70,7 +64,7 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
           Effect.mapError(
             (cause) =>
               new AdapterReadErrorClass({
-                adapter: 'paraglide',
+                adapter: "paraglide",
                 locale,
                 resource: resource.key,
                 cause,
@@ -78,21 +72,27 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
           ),
         );
         return result.translations;
-      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<Record<string, string>, AdapterReadError, never>,
+      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<
+        Record<string, string>,
+        AdapterReadError,
+        never
+      >,
 
     writeResource: (locale, resource, entries) =>
       Effect.gen(function* () {
         const path = yield* Path;
         const filePath = path.join(messagesDir, `${locale}.json`);
-        const existing = yield* readMessageFile(filePath).pipe(Effect.orElseSucceed(() => ({
-          translations: {},
-          meta: {},
-        })));
+        const existing = yield* readMessageFile(filePath).pipe(
+          Effect.orElseSucceed(() => ({
+            translations: {},
+            meta: {},
+          })),
+        );
         yield* writeMessageFile(filePath, entries, existing.meta).pipe(
           Effect.mapError(
             (cause) =>
               new AdapterWriteErrorClass({
-                adapter: 'paraglide',
+                adapter: "paraglide",
                 locale,
                 resource: resource.key,
                 cause,
@@ -105,12 +105,16 @@ export function paraglide(options: ParaglideAdapterOptions): TranslationAdapter
       Effect.gen(function* () {
         const path = yield* Path;
         const adapterScanPaths =
-          scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, '..')];
+          scanPaths.length > 0 ? scanPaths : [path.resolve(messagesDir, "..")];
         const keys = yield* Effect.gen(function* () {
           const map = yield* paraglide(options).readResource(locale, resource);
           return Object.keys(map);
         });
         return yield* findUnusedParaglideKeys(adapterScanPaths, keys);
-      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<readonly string[], AdapterReadError, never>,
+      }).pipe(Effect.provide([NodePlatformLayer])) as Effect.Effect<
+        readonly string[],
+        AdapterReadError,
+        never
+      >,
   };
 }

package/src/index.ts

@@ -1,2 +1,2 @@
-export { paraglide } from './adapter.js';
-export type { ParaglideAdapterOptions } from './adapter.js';
+export { paraglide } from "./adapter.js";
+export type { ParaglideAdapterOptions } from "./adapter.js";

package/src/message-file.test.ts

@@ -1,13 +1,13 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Layer } from 'effect';
-import { FileSystem, Path } from '@effect/platform';
-import { readMessageFile, writeMessageFile } from './message-file.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Layer } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+import { readMessageFile, writeMessageFile } from "./message-file.js";
 
 function makeFsLayer(files: Record<string, string>) {
   const stub = FileSystem.makeNoop({
     exists: (path) => Effect.succeed(path in files),
     readFileString: (path) =>
-      path in files ? Effect.succeed(files[path]!) : Effect.fail(new Error('ENOENT') as never),
+      path in files ? Effect.succeed(files[path]!) : Effect.fail(new Error("ENOENT") as never),
     writeFileString: (path, content) => {
       files[path] = content;
       return Effect.void;
@@ -17,50 +17,50 @@ function makeFsLayer(files: Record<string, string>) {
   return Layer.succeed(FileSystem.FileSystem, stub);
 }
 
-describe('readMessageFile', () => {
-  it('reads flat translations and preserves meta keys', async () => {
+describe("readMessageFile", () => {
+  it("reads flat translations and preserves meta keys", async () => {
     const files = {
-      '/messages/en.json': JSON.stringify({
-        $schema: 'https://inlang.com/schema',
-        greeting: 'Hello',
-        farewell: 'Goodbye',
+      "/messages/en.json": JSON.stringify({
+        $schema: "https://inlang.com/schema",
+        greeting: "Hello",
+        farewell: "Goodbye",
       }),
     };
-    const program = readMessageFile('/messages/en.json').pipe(Effect.provide(makeFsLayer(files)));
+    const program = readMessageFile("/messages/en.json").pipe(Effect.provide(makeFsLayer(files)));
     const result = await Effect.runPromise(program);
-    expect(result.translations).toEqual({ greeting: 'Hello', farewell: 'Goodbye' });
-    expect(result.meta).toEqual({ $schema: 'https://inlang.com/schema' });
+    expect(result.translations).toEqual({ greeting: "Hello", farewell: "Goodbye" });
+    expect(result.meta).toEqual({ $schema: "https://inlang.com/schema" });
   });
 
-  it('returns empty for missing file', async () => {
-    const program = readMessageFile('/messages/missing.json').pipe(Effect.provide(makeFsLayer({})));
+  it("returns empty for missing file", async () => {
+    const program = readMessageFile("/messages/missing.json").pipe(Effect.provide(makeFsLayer({})));
     const result = await Effect.runPromise(program);
     expect(result.translations).toEqual({});
     expect(result.meta).toEqual({});
   });
 
-  it('flattens nested objects', async () => {
+  it("flattens nested objects", async () => {
     const files = {
-      '/messages/en.json': JSON.stringify({
-        nav: { home: 'Home', about: 'About' },
+      "/messages/en.json": JSON.stringify({
+        nav: { home: "Home", about: "About" },
       }),
     };
-    const program = readMessageFile('/messages/en.json').pipe(Effect.provide(makeFsLayer(files)));
+    const program = readMessageFile("/messages/en.json").pipe(Effect.provide(makeFsLayer(files)));
     const result = await Effect.runPromise(program);
-    expect(result.translations).toEqual({ 'nav.home': 'Home', 'nav.about': 'About' });
+    expect(result.translations).toEqual({ "nav.home": "Home", "nav.about": "About" });
   });
 });
 
-describe('writeMessageFile', () => {
-  it('round-trips translations and meta', async () => {
+describe("writeMessageFile", () => {
+  it("round-trips translations and meta", async () => {
     const files: Record<string, string> = {};
     const program = writeMessageFile(
-      '/messages/de.json',
-      { greeting: 'Hallo' },
-      { $schema: 'https://inlang.com/schema' },
+      "/messages/de.json",
+      { greeting: "Hallo" },
+      { $schema: "https://inlang.com/schema" },
     ).pipe(Effect.provide(makeFsLayer(files)), Effect.provide(Path.layer));
     await Effect.runPromise(program);
-    expect(files['/messages/de.json']).toContain('Hallo');
-    expect(files['/messages/de.json']).toContain('$schema');
+    expect(files["/messages/de.json"]).toContain("Hallo");
+    expect(files["/messages/de.json"]).toContain("$schema");
   });
 });

package/src/message-file.ts

@@ -1,6 +1,6 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
-import { flattenObject, unflattenObject } from 'dialekt';
+import { FileSystem, Path } from "@effect/platform";
+import { Effect } from "effect";
+import { flattenObject, unflattenObject } from "dialekt";
 
 export interface MessageFileResult {
   readonly translations: Record<string, string>;
@@ -16,7 +16,7 @@ export function readMessageFile(
     if (!exists) {
       return { translations: {}, meta: {} };
     }
-    const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => '{}'));
+    const content = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => "{}"));
     const parsed = yield* Effect.try({
       try: () => JSON.parse(content) as Record<string, unknown>,
       catch: () => ({}),
@@ -26,14 +26,14 @@ export function readMessageFile(
     const translations: Record<string, string> = {};
 
     for (const [key, value] of Object.entries(parsed)) {
-      if (key.startsWith('$')) {
+      if (key.startsWith("$")) {
         meta[key] = value;
-      } else if (typeof value === 'string') {
+      } else if (typeof value === "string") {
         translations[key] = value;
-      } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         const flattened = flattenObject(value as Record<string, unknown>);
         for (const [flatKey, flatValue] of Object.entries(flattened)) {
-          if (typeof flatValue === 'string') {
+          if (typeof flatValue === "string") {
             translations[`${key}.${flatKey}`] = flatValue;
           }
         }
@@ -61,8 +61,8 @@ export function writeMessageFile(
       output[key] = value;
     }
 
-    yield* fs.writeFileString(path, JSON.stringify(output, null, 2) + '\n').pipe(
-      Effect.orElseSucceed(() => undefined),
-    );
+    yield* fs
+      .writeFileString(path, JSON.stringify(output, null, 2) + "\n")
+      .pipe(Effect.orElseSucceed(() => undefined));
   });
 }

package/src/unused-keys.test.ts

@@ -1,32 +1,32 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { NodePlatformLayer } from 'dialekt';
-import { findUnusedParaglideKeys } from './unused-keys.js';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-describe('findUnusedParaglideKeys', () => {
-  it('finds keys not referenced in source files', async () => {
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { NodePlatformLayer } from "dialekt";
+import { findUnusedParaglideKeys } from "./unused-keys.js";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("findUnusedParaglideKeys", () => {
+  it("finds keys not referenced in source files", async () => {
     const dir = join(tmpdir(), `paraglide-unused-${Date.now()}`);
-    mkdirSync(join(dir, 'src'), { recursive: true });
-    writeFileSync(join(dir, 'src', 'page.tsx'), "const t = m.greeting({ name: 'x' });");
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "page.tsx"), "const t = m.greeting({ name: 'x' });");
 
-    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greeting', 'farewell']).pipe(
+    const program = findUnusedParaglideKeys([join(dir, "src")], ["greeting", "farewell"]).pipe(
       Effect.provide(NodePlatformLayer),
     );
     const result = await Effect.runPromise(program);
-    expect(result).toEqual(['farewell']);
+    expect(result).toEqual(["farewell"]);
 
     rmSync(dir, { recursive: true, force: true });
   });
 
-  it('finds m.key reference without call parens', async () => {
+  it("finds m.key reference without call parens", async () => {
     const dir = join(tmpdir(), `paraglide-unused-ref-${Date.now()}`);
-    mkdirSync(join(dir, 'src'), { recursive: true });
-    writeFileSync(join(dir, 'src', 'util.ts'), 'export const msg = m.greeting;');
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "util.ts"), "export const msg = m.greeting;");
 
-    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greeting']).pipe(
+    const program = findUnusedParaglideKeys([join(dir, "src")], ["greeting"]).pipe(
       Effect.provide(NodePlatformLayer),
     );
     const result = await Effect.runPromise(program);
@@ -35,16 +35,16 @@ describe('findUnusedParaglideKeys', () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
-  it('does not treat prefixes as matches', async () => {
+  it("does not treat prefixes as matches", async () => {
     const dir = join(tmpdir(), `paraglide-unused-prefix-${Date.now()}`);
-    mkdirSync(join(dir, 'src'), { recursive: true });
-    writeFileSync(join(dir, 'src', 'page.ts'), 'm.greeting();');
+    mkdirSync(join(dir, "src"), { recursive: true });
+    writeFileSync(join(dir, "src", "page.ts"), "m.greeting();");
 
-    const program = findUnusedParaglideKeys([join(dir, 'src')], ['greet', 'greeting']).pipe(
+    const program = findUnusedParaglideKeys([join(dir, "src")], ["greet", "greeting"]).pipe(
       Effect.provide(NodePlatformLayer),
     );
     const result = await Effect.runPromise(program);
-    expect(result).toEqual(['greet']);
+    expect(result).toEqual(["greet"]);
 
     rmSync(dir, { recursive: true, force: true });
   });

package/src/unused-keys.ts

@@ -1,12 +1,9 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
-import type { AdapterReadError } from 'dialekt';
-import { AdapterReadError as AdapterReadErrorClass } from 'dialekt';
+import { FileSystem, Path } from "@effect/platform";
+import { Effect } from "effect";
+import type { AdapterReadError } from "dialekt";
+import { AdapterReadError as AdapterReadErrorClass } from "dialekt";
 
-export function findUnusedParaglideKeys(
-  scanPaths: readonly string[],
-  keys: readonly string[],
-) {
+export function findUnusedParaglideKeys(scanPaths: readonly string[], keys: readonly string[]) {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
@@ -17,23 +14,23 @@ export function findUnusedParaglideKeys(
       const exists = yield* fs.exists(scanPath).pipe(Effect.orElseSucceed(() => false));
       if (!exists) continue;
 
-      const entries = yield* fs.readDirectory(scanPath, { recursive: true }).pipe(
-        Effect.orElseSucceed(() => [] as string[]),
-      );
+      const entries = yield* fs
+        .readDirectory(scanPath, { recursive: true })
+        .pipe(Effect.orElseSucceed(() => [] as string[]));
 
       for (const relativePath of entries) {
         if (
-          !relativePath.endsWith('.ts') &&
-          !relativePath.endsWith('.tsx') &&
-          !relativePath.endsWith('.js') &&
-          !relativePath.endsWith('.jsx') &&
-          !relativePath.endsWith('.svelte') &&
-          !relativePath.endsWith('.vue')
+          !relativePath.endsWith(".ts") &&
+          !relativePath.endsWith(".tsx") &&
+          !relativePath.endsWith(".js") &&
+          !relativePath.endsWith(".jsx") &&
+          !relativePath.endsWith(".svelte") &&
+          !relativePath.endsWith(".vue")
         ) {
           continue;
         }
         const filePath = path.join(scanPath, relativePath);
-        const content = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ''));
+        const content = yield* fs.readFileString(filePath).pipe(Effect.orElseSucceed(() => ""));
 
         for (const key of keys) {
           const pattern = new RegExp(`\\bm\\.${key}\\b`);
@@ -49,9 +46,9 @@ export function findUnusedParaglideKeys(
     Effect.mapError(
       (cause) =>
         new AdapterReadErrorClass({
-          adapter: 'paraglide',
-          locale: '',
-          resource: 'messages',
+          adapter: "paraglide",
+          locale: "",
+          resource: "messages",
           cause,
         }) as AdapterReadError,
     ),

package/tsconfig.json

@@ -5,7 +5,5 @@
     "outDir": "dist"
   },
   "include": ["src"],
-  "references": [
-    { "path": "../dialekt" }
-  ]
+  "references": [{ "path": "../dialekt" }]
 }

package/tsdown.config.ts

@@ -1,7 +1,7 @@
-import { defineConfig } from 'tsdown';
+import { defineConfig } from "tsdown";
 
 export default defineConfig({
-  entry: ['src/index.ts'],
-  format: 'esm',
+  entry: ["src/index.ts"],
+  format: "esm",
   dts: true,
 });

package/vitest.config.ts

@@ -1,8 +1,8 @@
-import { defineConfig } from 'vitest/config';
+import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   test: {
-    include: ['src/**/*.test.ts'],
-    environment: 'node',
+    include: ["src/**/*.test.ts"],
+    environment: "node",
   },
 });