@inlang/paraglide-js 1.0.0-prerelease.2 → 1.0.0-prerelease.4

package/README.md

@@ -1,6 +1,9 @@
 # @inlang/paraglide-js
 
-## ATTENTION: Paraglide is in pre-release mode. Discuss the API at https://github.com/inlang/monorepo/discussions/1464
+<!-- ## ATTENTION: Paraglide is in pre-release mode. Discuss the API at https://github.com/inlang/monorepo/discussions/1464 -->
+<doc-links>
+    <doc-link title="ATTENTION: Paraglide is in pre-release mode." icon="mdi:github" href="https://github.com/inlang/monorepo/discussions/1464" description="Discuss the API on GitHub."></doc-link>
+</doc-links>
 
 <doc-gallery>TODO: adapter gallery</doc-gallery>
 
@@ -60,11 +63,16 @@ npm install @inlang/paraglide-js
 ```diff
 {
   "scripts": {
-+    "build": "paraglide-js compile --namespace <your project name>"
++    "build": "paraglide-js compile --namespace <namespace>"
   }
 }
 ```
 
+| compile | [options]   |          |                                  |
+|---------|-------------|----------|----------------------------------|
+|         | --project   | \<path\> | default: "./project.inlang.json" |
+|         | --namespace | \<name\> | required                         |
+
 
 # Architecture 
 

package/dist/cli/commands/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/compile.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAInC,eAAO,MAAM,cAAc,SAsBxB,CAAA"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/compile.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAInC,eAAO,MAAM,cAAc,SAgDxB,CAAA"}

package/dist/cli/commands/compile.js

@@ -4,32 +4,30 @@ import { compile } from "../../compiler/compile.js";
 import fs from "node:fs/promises";
 import { resolve } from "node:path";
 import { Command } from "commander";
-import { paraglideDirectory } from "../main.js";
+import { paraglideDirectory } from "../state.js";
 import dedent from "dedent";
 export const compileCommand = new Command()
     .name("compile")
-    .summary("Compiles an inlang project into an importable library.")
+    .summary("Compiles inlang Paraglide-JS.")
     .requiredOption("--project <path>", "The path to the project settings file.", "./project.inlang.json")
     .requiredOption("--namespace <name>", dedent `
 		The import namespace of the compiled library. 
 		\nExample: --namespace frontend
 		-> import * as m from "@inlang/paraglide-js/frontend/messages"
 		\n`)
-    .action((options) => {
-    runCompileCommand({
-        projectPath: options.project,
-        namespace: options.namespace,
-        paraglideDirectory,
-    });
-});
-const runCompileCommand = async (args) => {
-    consola.info(`Compiling inlang project at "${args.projectPath}".`);
-    const project = exitIfErrors(await loadProject({ settingsFilePath: resolve(process.cwd(), args.projectPath), nodeishFs: fs }));
+    .action(async (options) => {
+    consola.info(`Compiling inlang project at "${options.project}".`);
+    const path = resolve(process.cwd(), options.project);
+    const project = exitIfErrors(await loadProject({
+        settingsFilePath: path,
+        nodeishFs: fs,
+    }));
     const output = compile({
         messages: project.query.messages.getAll(),
         settings: project.settings(),
     });
-    const outputDirectory = `${args.paraglideDirectory}/dist/compiled-output` + (args.namespace ? `/${args.namespace}` : "");
+    const outputDirectory = `${paraglideDirectory}/dist/compiled-output` +
+        (options.namespace ? `/${options.namespace}` : "");
     for (const [fileName, fileContent] of Object.entries(output)) {
         // create the compiled-output directory if it doesn't exist
         await fs.access(outputDirectory).catch(async () => {
@@ -40,17 +38,16 @@ const runCompileCommand = async (args) => {
         });
     }
     consola.success("Successfully compiled the project.");
-};
+});
 /**
  * Utility function to exit when the project has errors.
  */
 const exitIfErrors = (project) => {
     if (project.errors().length > 0) {
-        // two console statements for better output formatting
-        // because project.errors() internal .toString() method
-        // is better than manual processing.
-        consola.error(`The project has errors:`);
-        consola.log(project.errors());
+        consola.warn(`The project has errors:`);
+        for (const error of project.errors()) {
+            consola.error(error);
+        }
         process.exit(1);
     }
     return project;

package/dist/cli/commands/compile.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compile.test.d.ts.map

package/dist/cli/commands/compile.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.test.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/compile.test.ts"],"names":[],"mappings":""}

package/dist/cli/commands/compile.test.js

@@ -0,0 +1,77 @@
+import consola from "consola";
+import { vi, test, expect, beforeEach } from "vitest";
+import memfs from "memfs";
+import mockedFs from "node:fs/promises";
+import fs from "node:fs";
+import { compileCommand } from "./compile.js";
+import { createMessage } from "@inlang/sdk/test-utilities";
+import { resolve } from "node:path";
+import { _setStateForTest } from "../state.js";
+beforeEach(() => {
+    vi.resetAllMocks();
+    // Re-mock consola before each test call to remove calls from before
+    consola.mockTypes(() => vi.fn());
+    // set the current working directory to some mock value to prevent
+    // the tests from failing when running in a different environment
+    process.cwd = () => "/";
+    // spy on commonly used functions to prevent console output
+    // and allow expecations
+    vi.spyOn(consola, "log").mockImplementation(() => undefined);
+    vi.spyOn(consola, "info").mockImplementation(() => undefined);
+    vi.spyOn(consola, "success").mockImplementation(() => undefined);
+    vi.spyOn(consola, "error").mockImplementation(() => undefined);
+    vi.spyOn(consola, "warn").mockImplementation(() => undefined);
+    vi.spyOn(process, "exit").mockImplementation(() => {
+        throw "PROCESS.EXIT()";
+    });
+});
+test("it should exit if the project has errors", async () => {
+    mockFs({
+        "/project.inlang.json": JSON.stringify({
+            // invalid source language tag
+            sourceLanguageTag: "en-EN-EN",
+            languageTags: [],
+            modules: [],
+        }),
+    });
+    expect(compileCommand.parseAsync(["--project", "./project.inlang.json", "--namespace", "frontend"])).rejects.toEqual("PROCESS.EXIT()");
+});
+test("it should compile a project with a namespace", async () => {
+    const name = "frontend";
+    _setStateForTest({ paraglideDirectory: "/node_modules/paraglide-js" });
+    const _fs = mockFs({
+        "/plugin.js": fs.readFileSync(
+        // using the inlang-message-format plugin
+        resolve(__dirname, "../../../../../plugins/inlang-message-format/dist/index.js"), { encoding: "utf-8" }),
+        "/project.inlang.json": JSON.stringify({
+            sourceLanguageTag: "en",
+            languageTags: ["de", "en"],
+            modules: ["/plugin.js"],
+            "plugin.inlang.messageFormat": {
+                filePath: "/messages.json",
+            },
+        }),
+        "/messages.json": JSON.stringify({
+            $schema: "https://inlang.com/schema/inlang-message-format",
+            data: [
+                createMessage("loginButton", {
+                    en: "Login",
+                    de: "Anmelden",
+                }),
+            ],
+        }),
+    });
+    await compileCommand.parseAsync(["--project", "./project.inlang.json", "--namespace", name]);
+    expect(_fs.existsSync(`/node_modules/paraglide-js/dist/compiled-output/${name}/messages.js`)).toBe(true);
+});
+const mockFs = (files) => {
+    const _memfs = memfs.createFsFromVolume(memfs.Volume.fromJSON(files));
+    for (const prop in mockedFs) {
+        // @ts-ignore - memfs has the same interface as node:fs/promises
+        if (typeof mockedFs[prop] !== "function")
+            continue;
+        // @ts-ignore - memfs has the same interface as node:fs/promises
+        vi.spyOn(mockedFs, prop).mockImplementation(_memfs.promises[prop]);
+    }
+    return _memfs;
+};

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import { type ProjectSettings } from "@inlang/sdk";
+export declare const initCommand: Command;
+export declare const initializeInlangProject: () => Promise<string>;
+export declare const addParaglideJsToDependencies: () => Promise<void>;
+export declare const promptForNamespace: () => Promise<string>;
+export declare const findExistingInlangProjectPath: () => Promise<string | undefined>;
+export declare const existingProjectFlow: (args: {
+    existingProjectPath: string;
+}) => Promise<undefined>;
+export declare const createNewProjectFlow: () => Promise<undefined>;
+export declare const newProjectTemplate: ProjectSettings;
+export declare const checkIfPackageJsonExists: () => Promise<undefined>;
+export declare const checkIfUncommittedChanges: () => Promise<void>;
+export declare const addCompileStepToPackageJSON: (args: {
+    projectPath: string;
+    namespace: string;
+}) => Promise<undefined>;
+/**
+ * Ensures that the moduleResolution compiler option is set to "bundler" or similar in the tsconfig.json.
+ *
+ * Otherwise, types defined in `package.exports` are not resolved by TypeScript. Leading to type
+ * errors with Paraglide-JS.
+ */
+export declare const adjustTsConfigIfNecessary: () => Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,aAAa,CAAA;AAgB/D,eAAO,MAAM,WAAW,SAgBrB,CAAA;AAEH,eAAO,MAAM,uBAAuB,uBAUnC,CAAA;AAED,eAAO,MAAM,4BAA4B,qBAUxC,CAAA;AAED,eAAO,MAAM,kBAAkB,QAAa,QAAQ,MAAM,CAmBzD,CAAA;AAED,eAAO,MAAM,6BAA6B,QAAa,QAAQ,MAAM,GAAG,SAAS,CAYhF,CAAA;AAED,eAAO,MAAM,mBAAmB,SAAgB;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE,uBA0B9E,CAAA;AAED,eAAO,MAAM,oBAAoB,0BAkBhC,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,eAoBhC,CAAA;AAED,eAAO,MAAM,wBAAwB,0BAOpC,CAAA;AAED,eAAO,MAAM,yBAAyB,qBAyBrC,CAAA;AAED,eAAO,MAAM,2BAA2B,SAAgB;IACvD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CACjB,uBAmCA,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,qBAqErC,CAAA"}

package/dist/cli/commands/init.js

@@ -0,0 +1,277 @@
+import { Command } from "commander";
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import { loadProject } from "@inlang/sdk";
+import consola from "consola";
+import { resolve } from "node:path";
+import { detectJsonFormatting } from "@inlang/detect-json-formatting";
+import JSON5 from "json5";
+import childProcess from "node:child_process";
+import { version } from "../state.js";
+consola.options = {
+    ...consola.options,
+    // get rid of the date in the logs
+    formatOptions: { date: false },
+};
+const DEFAULT_PROJECT_PATH = "./project.inlang.json";
+export const initCommand = new Command()
+    .name("init")
+    .summary("Initializes inlang Paraglide-JS.")
+    .action(async () => {
+    consola.box("Welcome to inlang Paraglide-JS 🪂");
+    await checkIfUncommittedChanges();
+    await checkIfPackageJsonExists();
+    const projectPath = await initializeInlangProject();
+    const namespace = await promptForNamespace();
+    await addCompileStepToPackageJSON({ projectPath, namespace });
+    await adjustTsConfigIfNecessary();
+    await addParaglideJsToDependencies();
+    consola.box("inlang Paraglide-JS has been set up sucessfully.\n\n1. Run your install command (npm i, yarn install, etc)\n2. Run the build script (npm run build, or similar.)\n3. Done :) Happy paragliding 🪂\n\n For questions and feedback, visit https://github.com/inlang/monorepo/discussions.\n");
+});
+export const initializeInlangProject = async () => {
+    const existingProjectPath = await findExistingInlangProjectPath();
+    if (existingProjectPath) {
+        await existingProjectFlow({ existingProjectPath });
+        return existingProjectPath;
+    }
+    else {
+        await createNewProjectFlow();
+        return DEFAULT_PROJECT_PATH;
+    }
+};
+export const addParaglideJsToDependencies = async () => {
+    const file = await fs.readFile("./package.json", { encoding: "utf-8" });
+    const stringify = detectJsonFormatting(file);
+    const pkg = JSON.parse(file);
+    if (pkg.dependencies === undefined) {
+        pkg.dependencies = {};
+    }
+    pkg.dependencies["@inlang/paraglide-js"] = version;
+    await fs.writeFile("./package.json", stringify(pkg));
+    consola.success("Added @inlang/paraglide-js to the dependencies in package.json.");
+};
+export const promptForNamespace = async () => {
+    let assumedName = process.cwd().split("/").pop();
+    try {
+        assumedName = JSON.parse(await fs.readFile("./package.json", { encoding: "utf-8" })).name;
+    }
+    catch {
+        // nothing
+    }
+    consola.info(`You need to select a name for the project.
+
+The name is used to create an importable 'namespace' to distinguish between multiple projects in the same repository. For example, the name \`frontend\` will create the following import statement:
+	
+\`import * as m from "@inlang/paraglide-js/frontend/messages"\``);
+    const namespace = await prompt(`What should be the name of the project?`, {
+        type: "text",
+        initial: assumedName,
+    });
+    return namespace.trim();
+};
+export const findExistingInlangProjectPath = async () => {
+    for (const path of [
+        "./project.inlang.json",
+        "../project.inlang.json",
+        "../../project.inlang.json",
+    ]) {
+        if (fsSync.existsSync(path)) {
+            return path;
+        }
+        continue;
+    }
+    return undefined;
+};
+export const existingProjectFlow = async (args) => {
+    const selection = (await prompt(`Do you want to use the inlang project at "${args.existingProjectPath}" or create a new project?`, {
+        type: "select",
+        options: [
+            { label: "Use this project", value: "useExistingProject" },
+            { label: "Create a new project", value: "newProject" },
+        ],
+    })); // the prompt type is incorrect
+    if (selection === "newProject") {
+        return createNewProjectFlow();
+    }
+    const project = await loadProject({
+        settingsFilePath: resolve(process.cwd(), args.existingProjectPath),
+        nodeishFs: fs,
+    });
+    if (project.errors().length > 0) {
+        consola.error("The project contains errors: ");
+        for (const error of project.errors()) {
+            consola.error(error);
+        }
+        process.exit(1);
+    }
+};
+export const createNewProjectFlow = async () => {
+    consola.info(`Creating a new inlang project in the current working directory.`);
+    await fs.writeFile(DEFAULT_PROJECT_PATH, JSON.stringify(newProjectTemplate, undefined, 2));
+    const project = await loadProject({
+        settingsFilePath: resolve(process.cwd(), DEFAULT_PROJECT_PATH),
+        nodeishFs: fs,
+    });
+    if (project.errors().length > 0) {
+        consola.warn("Failed to create a new inlang project.\n\nThis is likely an internal bug. Please file an issue at https://github.com/inlang/monorepo.");
+        for (const error of project.errors()) {
+            consola.error(error);
+        }
+        return process.exit(1);
+    }
+    else {
+        consola.success("Successfully created a new inlang project.");
+    }
+};
+export const newProjectTemplate = {
+    $schema: "https://inlang.com/schema/project-settings",
+    // defaulting to english to not overwhelm new users
+    // with prompts. The user can change this later.
+    sourceLanguageTag: "en",
+    languageTags: ["en"],
+    modules: [
+        // for instant gratification, we're adding the most common rules
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-identical-pattern@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
+        // default to the message format plugin because it supports all features
+        "https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
+    ],
+    "plugin.inlang.messageFormat": {
+        // using .inlang/paraglide-js as directory to avoid future conflicts when an official .inlang
+        // directory is introduced, see https://github.com/inlang/monorepo/discussions/1418
+        filePath: "./.inlang/plugin.inlang.messageFormat/messages.json",
+    },
+};
+export const checkIfPackageJsonExists = async () => {
+    if (fsSync.existsSync("./package.json") === false) {
+        consola.warn("No package.json found in the current working directory. Please change the working directory to the directory with a package.json file.");
+        return process.exit(0);
+    }
+};
+export const checkIfUncommittedChanges = async () => {
+    try {
+        if (childProcess.execSync("git status --porcelain").toString().length === 0) {
+            return;
+        }
+        consola.info(`You have uncommitted changes.\n\nPlease commit your changes before initializing inlang Paraglide-JS. Committing outstanding changes ensures that you don't lose any work, and see the changes the paraglide-js init command introduces.`);
+        const response = await prompt("Do you want to initialize inlang Paraglide-JS without committing your current changes?", {
+            type: "confirm",
+            initial: false,
+        });
+        if (response === true) {
+            return;
+        }
+        else {
+            process.exit(0);
+        }
+    }
+    catch (e) {
+        // git cli is not installed
+        return;
+    }
+};
+export const addCompileStepToPackageJSON = async (args) => {
+    const file = await fs.readFile("./package.json", { encoding: "utf-8" });
+    const stringify = detectJsonFormatting(file);
+    const pkg = JSON.parse(file);
+    if (pkg?.scripts?.build === undefined) {
+        if (pkg.scripts === undefined) {
+            pkg.scripts = {};
+        }
+        pkg.scripts.build = `paraglide-js compile --project ${args.projectPath} --namespace ${args.namespace}`;
+    }
+    else if (pkg?.scripts?.build.includes("paraglide-js compile") === false) {
+        pkg.scripts.build = `paraglide-js compile --project ${args.projectPath} --namespace ${args.namespace} && ${pkg.scripts.build}`;
+    }
+    else {
+        consola.warn(`The "build" script in the \`package.json\` already contains a "paraglide-js compile" command.
+
+Please add the following command to your build script manually:
+
+\`paraglide-js compile --project ${args.projectPath} --namespace ${args.namespace}\``);
+        const response = await consola.prompt("Have you added the compile command to your build script?", {
+            type: "confirm",
+            initial: false,
+        });
+        if (response === false) {
+            consola.log("Please remove the paraglide-js compile command from your build script and try again.");
+            return process.exit(0);
+        }
+        else {
+            return;
+        }
+    }
+    await fs.writeFile("./package.json", stringify(pkg));
+    consola.success("Successfully added the compile command to the build step in package.json.");
+};
+/**
+ * Ensures that the moduleResolution compiler option is set to "bundler" or similar in the tsconfig.json.
+ *
+ * Otherwise, types defined in `package.exports` are not resolved by TypeScript. Leading to type
+ * errors with Paraglide-JS.
+ */
+export const adjustTsConfigIfNecessary = async () => {
+    if (fsSync.existsSync("./tsconfig.json") === false) {
+        return;
+    }
+    const file = await fs.readFile("./tsconfig.json", { encoding: "utf-8" });
+    // tsconfig allows comments ... FML
+    const tsconfig = JSON5.parse(file);
+    let parentTsConfig;
+    if (tsconfig.extends) {
+        try {
+            const parentTsConfigPath = resolve(process.cwd(), tsconfig.extends);
+            const parentTsConfigFile = await fs.readFile(parentTsConfigPath, { encoding: "utf-8" });
+            parentTsConfig = JSON5.parse(parentTsConfigFile);
+        }
+        catch {
+            consola.warn(`The tsconfig.json is extended from a tsconfig that couldn't be read. Maybe the file doesn't exist yet or is a NPM package. Continuing without taking the extended from tsconfig into consideration.`);
+        }
+    }
+    // options that don't support package.exports
+    const invalidOptions = ["classic", "node", "node10"];
+    const moduleResolution = tsconfig.compilerOptions?.moduleResolution ?? parentTsConfig?.compilerOptions?.moduleResolution;
+    if (moduleResolution && invalidOptions.includes(moduleResolution.toLowerCase()) === false) {
+        // the moduleResolution is already set to bundler or similar
+        return;
+    }
+    consola.info(`You need to set the \`compilerOptions.moduleResolution\` to "Bundler" in the \`tsconfig.json\` file:
+
+\`{
+  "compilerOptions": {
+    "moduleResolution": "Bundler"
+  }
+}\``);
+    let isValid = false;
+    while (isValid === false) {
+        const response = await prompt(`Did you set the \`compilerOptions.moduleResolution\` to "Bundler"?`, {
+            type: "confirm",
+            initial: false,
+        });
+        if (response === false) {
+            return consola.warn("Continuing without adjusting the tsconfig.json. This may lead to type errors.");
+        }
+        const file = await fs.readFile("./tsconfig.json", { encoding: "utf-8" });
+        const tsconfig = JSON5.parse(file);
+        if (tsconfig?.compilerOptions?.moduleResolution &&
+            tsconfig.compilerOptions.moduleResolution.toLowerCase() === "bundler") {
+            isValid = true;
+            return;
+        }
+        else {
+            consola.error("The compiler options have not been adjusted. Please set the `compilerOptions.moduleResolution` to `Bundler`.");
+        }
+    }
+};
+/**
+ * Wrapper to exit the process if the user presses CTRL+C.
+ */
+const prompt = async (message, options) => {
+    const response = await consola.prompt(message, options);
+    if (response?.toString() === "Symbol(clack:cancel)") {
+        process.exit(0);
+    }
+    return response;
+};

package/dist/cli/commands/init.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.test.d.ts.map

package/dist/cli/commands/init.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.test.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.test.ts"],"names":[],"mappings":""}