dialekt 0.1.0 → 0.1.1

package/src/sdk/file-io.ts

@@ -1,5 +1,5 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Effect } from 'effect';
+import { FileSystem, Path } from "@effect/platform";
+import { Effect } from "effect";
 
 export function readFileIfExists(path: string) {
   return Effect.gen(function* () {

package/src/sdk/node-layer.test.ts

@@ -1,12 +1,12 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { FileSystem } from '@effect/platform/FileSystem';
-import { Path } from '@effect/platform/Path';
-import { CommandExecutor } from '@effect/platform/CommandExecutor';
-import { NodePlatformLayer } from './node-layer.js';
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { FileSystem } from "@effect/platform/FileSystem";
+import { Path } from "@effect/platform/Path";
+import { CommandExecutor } from "@effect/platform/CommandExecutor";
+import { NodePlatformLayer } from "./node-layer.js";
 
-describe('NodePlatformLayer', () => {
-  it('provides a working FileSystem service', async () => {
+describe("NodePlatformLayer", () => {
+  it("provides a working FileSystem service", async () => {
     const program = Effect.gen(function* () {
       const fs = yield* FileSystem;
       return yield* fs.exists(process.cwd());
@@ -15,17 +15,17 @@ describe('NodePlatformLayer', () => {
     expect(result).toBe(true);
   });
 
-  it('provides a working Path service', async () => {
+  it("provides a working Path service", async () => {
     const program = Effect.gen(function* () {
       const path = yield* Path;
-      return path.join('a', 'b');
+      return path.join("a", "b");
     });
     const result = await Effect.runPromise(Effect.provide(program, NodePlatformLayer));
-    expect(result).toContain('a');
-    expect(result).toContain('b');
+    expect(result).toContain("a");
+    expect(result).toContain("b");
   });
 
-  it('provides a working CommandExecutor service', async () => {
+  it("provides a working CommandExecutor service", async () => {
     const program = Effect.gen(function* () {
       const executor = yield* CommandExecutor;
       return executor !== undefined;
@@ -34,19 +34,19 @@ describe('NodePlatformLayer', () => {
     expect(result).toBe(true);
   });
 
-  it('can read a real file', async () => {
+  it("can read a real file", async () => {
     const program = Effect.gen(function* () {
       const fs = yield* FileSystem;
-      return yield* fs.readFileString(process.cwd() + '/package.json');
+      return yield* fs.readFileString(process.cwd() + "/package.json");
     });
     const result = await Effect.runPromise(Effect.provide(program, NodePlatformLayer));
-    expect(result).toContain('name');
+    expect(result).toContain("name");
   });
 
-  it('reports missing files correctly', async () => {
+  it("reports missing files correctly", async () => {
     const program = Effect.gen(function* () {
       const fs = yield* FileSystem;
-      return yield* fs.exists('/nonexistent/path/that/should/not/exist');
+      return yield* fs.exists("/nonexistent/path/that/should/not/exist");
     });
     const result = await Effect.runPromise(Effect.provide(program, NodePlatformLayer));
     expect(result).toBe(false);

package/src/sdk/node-layer.ts

@@ -1,5 +1,5 @@
-import { NodeContext } from '@effect/platform-node';
-import { Layer } from 'effect';
+import { NodeContext } from "@effect/platform-node";
+import { Layer } from "effect";
 
 /**
  * The only file in this package (besides cli/main.ts) permitted to know

package/src/sdk/php-array-reader.test.ts

@@ -1,89 +1,95 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Either } from 'effect';
-import { CommandExecutor, Command } from '@effect/platform';
-import { NodePlatformLayer } from './node-layer.js';
-import { readPhpArrayAsJson, PhpExecutionError } from './php-array-reader.js';
-import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { execSync } from 'node:child_process';
+import { describe, expect, it } from "vitest";
+import { Effect, Either } from "effect";
+import { CommandExecutor, Command } from "@effect/platform";
+import { NodePlatformLayer } from "./node-layer.js";
+import { readPhpArrayAsJson, PhpExecutionError } from "./php-array-reader.js";
+import { writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
 
 function hasPhpBinary(): boolean {
   try {
-    execSync('php -v', { stdio: 'ignore' });
+    execSync("php -v", { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
 
-describe('readPhpArrayAsJson', () => {
+describe("readPhpArrayAsJson", () => {
   const testDir = join(tmpdir(), `dialekt-php-test-${Date.now()}`);
 
-  it.skipIf(!hasPhpBinary())('reads a PHP array file as JSON', async () => {
+  it.skipIf(!hasPhpBinary())("reads a PHP array file as JSON", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'test.php');
+    const filePath = join(testDir, "test.php");
     writeFileSync(filePath, "<?php return ['email' => 'Email address'];");
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
     const result = await Effect.runPromise(program);
-    expect(result).toEqual({ email: 'Email address' });
+    expect(result).toEqual({ email: "Email address" });
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it.skipIf(!hasPhpBinary())('returns PhpExecutionError for a nonexistent file', async () => {
-    const program = Effect.provide(readPhpArrayAsJson('/nonexistent/file.php'), NodePlatformLayer);
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, PhpExecutionError>;
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('PhpExecutionError');
-      expect(exit.left.path).toBe('/nonexistent/file.php');
+  it.skipIf(!hasPhpBinary())("returns PhpExecutionError for a nonexistent file", async () => {
+    const program = Effect.provide(readPhpArrayAsJson("/nonexistent/file.php"), NodePlatformLayer);
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      unknown,
+      PhpExecutionError
+    >;
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("PhpExecutionError");
+      expect(exit.left.path).toBe("/nonexistent/file.php");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it.skipIf(!hasPhpBinary())('reads nested PHP arrays', async () => {
+  it.skipIf(!hasPhpBinary())("reads nested PHP arrays", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'nested.php');
-    writeFileSync(filePath, "<?php return ['validation' => ['email' => 'Email address', 'required' => 'Required field']];");
+    const filePath = join(testDir, "nested.php");
+    writeFileSync(
+      filePath,
+      "<?php return ['validation' => ['email' => 'Email address', 'required' => 'Required field']];",
+    );
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      validation: { email: 'Email address', required: 'Required field' },
+      validation: { email: "Email address", required: "Required field" },
     });
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it.skipIf(!hasPhpBinary())('reads PHP arrays with numeric keys as JS arrays', async () => {
+  it.skipIf(!hasPhpBinary())("reads PHP arrays with numeric keys as JS arrays", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'numeric.php');
+    const filePath = join(testDir, "numeric.php");
     writeFileSync(filePath, "<?php return ['first', 'second', 'third'];");
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
     const result = await Effect.runPromise(program);
-    expect(result).toEqual(['first', 'second', 'third']);
+    expect(result).toEqual(["first", "second", "third"]);
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it.skipIf(!hasPhpBinary())('reads PHP arrays with unicode values', async () => {
+  it.skipIf(!hasPhpBinary())("reads PHP arrays with unicode values", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'unicode.php');
+    const filePath = join(testDir, "unicode.php");
     writeFileSync(filePath, "<?php return ['greeting' => 'Héllo 🌍 — 日本語'];");
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
     const result = await Effect.runPromise(program);
-    expect(result).toEqual({ greeting: 'Héllo 🌍 — 日本語' });
+    expect(result).toEqual({ greeting: "Héllo 🌍 — 日本語" });
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it.skipIf(!hasPhpBinary())('reads empty PHP array as empty JS array', async () => {
+  it.skipIf(!hasPhpBinary())("reads empty PHP array as empty JS array", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'empty.php');
+    const filePath = join(testDir, "empty.php");
     writeFileSync(filePath, "<?php return [];");
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
@@ -93,22 +99,25 @@ describe('readPhpArrayAsJson', () => {
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it.skipIf(!hasPhpBinary())('returns PhpExecutionError for malformed PHP', async () => {
+  it.skipIf(!hasPhpBinary())("returns PhpExecutionError for malformed PHP", async () => {
     mkdirSync(testDir, { recursive: true });
-    const filePath = join(testDir, 'bad.php');
+    const filePath = join(testDir, "bad.php");
     writeFileSync(filePath, "<?php this is not valid php");
 
     const program = Effect.provide(readPhpArrayAsJson(filePath), NodePlatformLayer);
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, PhpExecutionError>;
-    expect(exit._tag).toBe('Left');
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('PhpExecutionError');
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      unknown,
+      PhpExecutionError
+    >;
+    expect(exit._tag).toBe("Left");
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("PhpExecutionError");
     }
 
     rmSync(testDir, { recursive: true, force: true });
   });
 
-  it('is skipped when php is unavailable', () => {
+  it("is skipped when php is unavailable", () => {
     expect(hasPhpBinary()).toBe(true); // meta-test: if php IS available, this proves skipIf works
   });
 });

package/src/sdk/php-array-reader.ts

@@ -1,8 +1,8 @@
-import { Command } from '@effect/platform';
-import type { CommandExecutor } from '@effect/platform/CommandExecutor';
-import { Effect, Data } from 'effect';
+import { Command } from "@effect/platform";
+import type { CommandExecutor } from "@effect/platform/CommandExecutor";
+import { Effect, Data } from "effect";
 
-export class PhpExecutionError extends Data.TaggedError('PhpExecutionError')<{
+export class PhpExecutionError extends Data.TaggedError("PhpExecutionError")<{
   readonly path: string;
   readonly cause: unknown;
 }> {}
@@ -14,7 +14,7 @@ export function readPhpArrayAsJson(
   absolutePath: string,
 ): Effect.Effect<Record<string, unknown>, PhpExecutionError, CommandExecutor> {
   return Effect.gen(function* () {
-    const cmd = Command.make('php', '-r', DUMP_SCRIPT, '--', absolutePath);
+    const cmd = Command.make("php", "-r", DUMP_SCRIPT, "--", absolutePath);
     const output = yield* Command.string(cmd).pipe(
       Effect.mapError((cause) => new PhpExecutionError({ path: absolutePath, cause })),
     );

package/src/translation/chunking.test.ts

@@ -1,16 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import { chunkKeys } from './chunking.js';
+import { describe, expect, it } from "vitest";
+import { chunkKeys } from "./chunking.js";
 
-describe('chunkKeys', () => {
-  it('keeps a small key set in a single chunk', () => {
-    const source = { a: 'A', b: 'B' };
+describe("chunkKeys", () => {
+  it("keeps a small key set in a single chunk", () => {
+    const source = { a: "A", b: "B" };
     const target = {};
-    const chunks = chunkKeys(['a', 'b'], source, target, { maxTokens: 3000, charsPerToken: 3.0 });
+    const chunks = chunkKeys(["a", "b"], source, target, { maxTokens: 3000, charsPerToken: 3.0 });
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['a', 'b']);
+    expect(chunks[0]).toEqual(["a", "b"]);
   });
 
-  it('splits a large key set into multiple chunks', () => {
+  it("splits a large key set into multiple chunks", () => {
     const source: Record<string, string> = {};
     for (let i = 0; i < 150; i++) {
       source[`key_${i}`] = `This is the value number ${i} with some extra text to make it longer`;
@@ -24,10 +24,10 @@ describe('chunkKeys', () => {
     expect(new Set(allKeys).size).toBe(keys.length);
   });
 
-  it('preserves all keys across chunks without loss or duplication', () => {
+  it("preserves all keys across chunks without loss or duplication", () => {
     const source: Record<string, string> = {};
     for (let i = 0; i < 60; i++) {
-      source[`k${i}`] = 'word '.repeat(10);
+      source[`k${i}`] = "word ".repeat(10);
     }
     const target = {};
     const keys = Object.keys(source);
@@ -36,18 +36,18 @@ describe('chunkKeys', () => {
     expect(flattened.sort()).toEqual([...keys].sort());
   });
 
-  it('keeps a single oversized key in its own chunk', () => {
-    const source = { long: 'x'.repeat(5000) };
+  it("keeps a single oversized key in its own chunk", () => {
+    const source = { long: "x".repeat(5000) };
     const target = {};
-    const chunks = chunkKeys(['long'], source, target, { maxTokens: 3000, charsPerToken: 3.0 });
+    const chunks = chunkKeys(["long"], source, target, { maxTokens: 3000, charsPerToken: 3.0 });
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['long']);
+    expect(chunks[0]).toEqual(["long"]);
   });
 
-  it('reduces effective chunk size when file context is huge', () => {
+  it("reduces effective chunk size when file context is huge", () => {
     const source: Record<string, string> = {};
     for (let i = 0; i < 26; i++) {
-      source[String.fromCharCode(97 + i)] = 'word '.repeat(50);
+      source[String.fromCharCode(97 + i)] = "word ".repeat(50);
     }
     const target = {};
     const keys = Object.keys(source).slice(0, 10);
@@ -55,45 +55,48 @@ describe('chunkKeys', () => {
     expect(chunks.length).toBeGreaterThan(0);
   });
 
-  it('falls back to one key per chunk when the context exceeds the limit', () => {
+  it("falls back to one key per chunk when the context exceeds the limit", () => {
     const source: Record<string, string> = {};
     for (let i = 0; i < 100; i++) {
-      source[`key_${i}`] = 'word '.repeat(100);
+      source[`key_${i}`] = "word ".repeat(100);
     }
     const target = { ...source };
-    const chunks = chunkKeys(['key_0', 'key_1'], source, target, { maxTokens: 10, charsPerToken: 3.0 });
-    expect(chunks[0]).toEqual(['key_0']);
-    expect(chunks[1]).toEqual(['key_1']);
+    const chunks = chunkKeys(["key_0", "key_1"], source, target, {
+      maxTokens: 10,
+      charsPerToken: 3.0,
+    });
+    expect(chunks[0]).toEqual(["key_0"]);
+    expect(chunks[1]).toEqual(["key_1"]);
   });
 
-  it('returns [] for empty keys', () => {
+  it("returns [] for empty keys", () => {
     expect(chunkKeys([], {}, {}, { maxTokens: 3000, charsPerToken: 3.0 })).toEqual([]);
   });
 
-  it('still includes keys not present in source (uses empty string as value)', () => {
-    const source = { a: 'A' };
-    const chunks = chunkKeys(['missing'], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
-    expect(chunks).toEqual([['missing']]);
+  it("still includes keys not present in source (uses empty string as value)", () => {
+    const source = { a: "A" };
+    const chunks = chunkKeys(["missing"], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
+    expect(chunks).toEqual([["missing"]]);
   });
 
-  it('handles keys with empty values', () => {
-    const source = { a: '', b: '' };
-    const chunks = chunkKeys(['a', 'b'], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
+  it("handles keys with empty values", () => {
+    const source = { a: "", b: "" };
+    const chunks = chunkKeys(["a", "b"], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['a', 'b']);
+    expect(chunks[0]).toEqual(["a", "b"]);
   });
 
-  it('handles single key', () => {
-    const source = { only: 'value' };
-    const chunks = chunkKeys(['only'], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
+  it("handles single key", () => {
+    const source = { only: "value" };
+    const chunks = chunkKeys(["only"], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['only']);
+    expect(chunks[0]).toEqual(["only"]);
   });
 
-  it('handles very large number of keys', () => {
+  it("handles very large number of keys", () => {
     const source: Record<string, string> = {};
     for (let i = 0; i < 1000; i++) {
-      source[`key_${i}`] = 'v';
+      source[`key_${i}`] = "v";
     }
     const keys = Object.keys(source);
     const chunks = chunkKeys(keys, source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
@@ -101,18 +104,23 @@ describe('chunkKeys', () => {
     expect(all).toHaveLength(1000);
   });
 
-  it('handles keys with special characters', () => {
-    const source = { 'key.with.dots': 'value', 'key-with-dashes': 'value2' };
-    const chunks = chunkKeys(['key.with.dots', 'key-with-dashes'], source, {}, { maxTokens: 3000, charsPerToken: 3.0 });
+  it("handles keys with special characters", () => {
+    const source = { "key.with.dots": "value", "key-with-dashes": "value2" };
+    const chunks = chunkKeys(
+      ["key.with.dots", "key-with-dashes"],
+      source,
+      {},
+      { maxTokens: 3000, charsPerToken: 3.0 },
+    );
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['key.with.dots', 'key-with-dashes']);
+    expect(chunks[0]).toEqual(["key.with.dots", "key-with-dashes"]);
   });
 
-  it('respects MIN_EFFECTIVE_MAX_CHARS even with zero maxTokens', () => {
-    const source = { a: 'A', b: 'B' };
-    const chunks = chunkKeys(['a', 'b'], source, {}, { maxTokens: 0, charsPerToken: 3.0 });
+  it("respects MIN_EFFECTIVE_MAX_CHARS even with zero maxTokens", () => {
+    const source = { a: "A", b: "B" };
+    const chunks = chunkKeys(["a", "b"], source, {}, { maxTokens: 0, charsPerToken: 3.0 });
     // MIN_EFFECTIVE_MAX_CHARS is 200, so both small keys fit in one chunk
     expect(chunks).toHaveLength(1);
-    expect(chunks[0]).toEqual(['a', 'b']);
+    expect(chunks[0]).toEqual(["a", "b"]);
   });
 });

package/src/translation/chunking.ts

@@ -24,7 +24,7 @@ export function chunkKeys(
   let currentChars = 0;
 
   for (const key of keys) {
-    const value = sourceMap[key] ?? '';
+    const value = sourceMap[key] ?? "";
     const itemChars = key.length + value.length + ITEM_JSON_OVERHEAD;
 
     // If a single key is larger than the entire chunk, force it through alone.