create-gtkx 1.6.0 → 2.0.0-beta.2

package/src/scaffolder.ts

@@ -2,8 +2,8 @@ import * as p from "@clack/prompts";
 import { APPLICATION_ID_MAX_LENGTH, isValidApplicationId } from "@gtkx/config/internal";
 import { errorMessage, tryResolveExecutable, upperFirst } from "@gtkx/utils";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, readdirSync, rmSync, type Stats, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { lstatSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { addDependency, detectPackageManager as nypmDetectPackageManager } from "nypm";
 import { x } from "tinyexec";
 import packageManifest from "../package.json" with { type: "json" };
@@ -23,6 +23,7 @@ import { listTemplates, renderFile, type TemplateContext } from "./templates.js"
 type CreateOptions = {
     name?: string | undefined;
     applicationId?: string | undefined;
+    displayName?: string | undefined;
     packageManager?: string | undefined;
     isTypescript?: boolean | undefined;
     shouldIncludeTesting?: boolean | undefined;
@@ -35,13 +36,16 @@ type ResolvedOptions = {
     root: string;
     isCurrentDirectory: boolean;
     name: string;
+    displayName: string;
     applicationId: string;
     packageManager: PackageManager;
     isTypescript: boolean;
     shouldIncludeTesting: boolean;
-    shouldEmptyTarget: boolean;
+    shouldInitializeGit: boolean;
 };
 
+type ScaffoldFile = { destination: string; contents: string };
+
 type InstallDependenciesOptions = {
     cwd: string;
     packageManager: PackageManager;
@@ -106,12 +110,8 @@ const APPLICATION_ID_SUFFIX = ".app";
 const APPLICATION_ID_SEGMENT_LIMIT = APPLICATION_ID_MAX_LENGTH - APPLICATION_ID_PREFIX.length -
     APPLICATION_ID_SUFFIX.length;
 
-const pinGtkxDependency = (name: string, version: string): string =>
-    name.startsWith("@gtkx/") ? `${name}@^${version}` : name;
-
-const getDevCommand = (packageManager: PackageManager): string => DEV_COMMAND[packageManager];
-const getAddCommand = (packageManager: PackageManager): string => ADD_COMMAND[packageManager];
-const titleFromName = (name: string): string => name.split("-").map((part) => upperFirst(part)).join(" ");
+const displayNameFromProjectName = (name: string): string =>
+    name.split("-").map((part) => upperFirst(part)).join(" ");
 
 const gitConfigValue = (key: string): string | null => {
     const git = tryResolveExecutable("git");
@@ -147,7 +147,9 @@ const stripTrailingSlashes = (value: string): string => {
     return value.slice(0, end);
 };
 
-const formatTargetDir = (target: string): string => stripTrailingSlashes(target.trim().replaceAll(/[<>:"\\|?*]/g, ""));
+const formatTargetDir = (target: string): string =>
+    stripTrailingSlashes(target.trim().replaceAll(/[<>:"\\|?*]/g, ""));
+
 const deriveProjectName = (target: string): string => basename(resolve(process.cwd(), target));
 
 const isDirEmpty = (dir: string): boolean => {
@@ -156,6 +158,12 @@ const isDirEmpty = (dir: string): boolean => {
     return entries.length === 0 || (entries.length === 1 && entries[0] === ".git");
 };
 
+const shouldInitializeGit = (root: string): boolean => {
+    const entry = lstatSync(root, { throwIfNoEntry: false });
+
+    return entry === undefined || (entry.isDirectory() && readdirSync(root).length === 0);
+};
+
 const getDevDependencies = ({
     isTypescript,
     shouldIncludeTesting,
@@ -203,6 +211,17 @@ const validateApplicationIdInput = (value: string | undefined): string | undefin
 const validateApplicationIdAnswer = (value: string | undefined): string | undefined =>
     value ? validateApplicationIdFormat(value) : undefined;
 
+const validateDisplayName = (value: string | undefined): string | undefined => {
+    if (value === undefined || value.trim().length === 0) {
+        return "Display name is required";
+    }
+
+    return value.includes("\n") || value.includes("\r") ? "Display name must be a single line" : undefined;
+};
+
+const validateDisplayNameAnswer = (value: string | undefined): string | undefined =>
+    value ? validateDisplayName(value) : undefined;
+
 const fail = (message: string): never => {
     p.log.error(message);
     throw new ScaffoldAbortedError(message);
@@ -220,14 +239,6 @@ const requestedPackageManager = (value: string | undefined): PackageManager | un
     return value;
 };
 
-const targetStats = (root: string): Stats | undefined => {
-    try {
-        return statSync(root, { throwIfNoEntry: false });
-    } catch {
-        return undefined;
-    }
-};
-
 const validateTargetDir = (target: string): string | undefined => {
     if (!target) {
         return "Project directory is required";
@@ -263,40 +274,36 @@ const promptApplicationId = async (name: string): Promise<string> => {
     );
 };
 
-const detectPackageManager = async (cwd: string): Promise<PackageManager | undefined> => {
-    const detected = await nypmDetectPackageManager(cwd, { includeParentDirs: true });
+const promptDisplayName = async (name: string): Promise<string> => {
+    const defaultDisplayName = displayNameFromProjectName(name);
 
-    if (!detected) {
-        return undefined;
-    }
-
-    return isKnownPackageManager(detected.name) ? detected.name : undefined;
+    return guardCancellation(
+        await p.text({
+            message: "Display name",
+            placeholder: defaultDisplayName,
+            defaultValue: defaultDisplayName,
+            validate: validateDisplayNameAnswer,
+        }),
+    );
 };
 
-const packageManagerHint = (
-    manager: (typeof PACKAGE_MANAGERS)[number],
-    detected: PackageManager | undefined,
-): string | undefined => {
-    if (detected === manager.value) {
-        return "detected";
-    }
+const packageManagerOption = (manager: (typeof PACKAGE_MANAGERS)[number], detected: PackageManager | undefined) => {
+    let hint: string | undefined;
 
-    if (manager.isRecommended) {
-        return "recommended";
+    if (detected === manager.value) {
+        hint = "detected";
+    } else if (manager.isRecommended) {
+        hint = "recommended";
     }
 
-    return undefined;
-};
-
-const packageManagerOption = (manager: (typeof PACKAGE_MANAGERS)[number], detected: PackageManager | undefined) => {
-    const hint = packageManagerHint(manager, detected);
-
     return { value: manager.value, label: manager.label, ...(hint !== undefined && { hint }) };
 };
 
 const detectedPackageManager = async (): Promise<PackageManager | undefined> => {
     try {
-        return await detectPackageManager(process.cwd());
+        const detected = await nypmDetectPackageManager(process.cwd(), { includeParentDirs: true });
+
+        return detected && isKnownPackageManager(detected.name) ? detected.name : undefined;
     } catch {
         return undefined;
     }
@@ -315,39 +322,15 @@ const promptPackageManager = async (): Promise<PackageManager> => {
     );
 };
 
-const shouldUseTypeScript = async (): Promise<boolean> =>
-    guardCancellation(
-        await p.confirm({
-            message: "Use TypeScript?",
-            initialValue: true,
-        }),
-    );
-
-const shouldSetUpTesting = async (): Promise<boolean> =>
-    guardCancellation(
-        await p.confirm({
-            message: "Include testing setup (Vitest)?",
-            initialValue: true,
-        }),
-    );
-
-const emptyDir = (root: string): void => {
-    for (const entry of readdirSync(root)) {
-        if (entry === ".git") {
-            continue;
-        }
-
-        rmSync(join(root, entry), { recursive: true, force: true });
-    }
-};
-
-const prepareTargetDirectory = (root: string, shouldEmptyTarget: boolean): void => {
-    mkdirSync(root, { recursive: true });
-
-    if (shouldEmptyTarget) {
-        emptyDir(root);
-    }
-};
+const isOptionEnabled = async (
+    value: boolean | undefined,
+    isInteractive: boolean | undefined,
+    message: string,
+): Promise<boolean> =>
+    value ??
+    (isInteractive
+        ? guardCancellation(await p.confirm({ message, initialValue: true }))
+        : true);
 
 const shouldOverwriteDirectory = async (target: string, options: CreateOptions): Promise<boolean> => {
     if (!options.isInteractive) {
@@ -356,17 +339,17 @@ const shouldOverwriteDirectory = async (target: string, options: CreateOptions):
 
     return guardCancellation(
         await p.confirm({
-            message: `Directory "${target}" is not empty. Overwrite its contents?`,
+            message: `Directory "${target}" is not empty. Replace scaffold files?`,
             initialValue: false,
         }),
     );
 };
 
-const shouldEmptyTargetDirectory = async (root: string, target: string, options: CreateOptions): Promise<boolean> => {
-    const stats = targetStats(root);
+const validateTargetAvailability = async (root: string, target: string, options: CreateOptions): Promise<void> => {
+    const stats = statSync(root, { throwIfNoEntry: false });
 
     if (stats === undefined) {
-        return false;
+        return;
     }
 
     if (!stats.isDirectory()) {
@@ -374,14 +357,14 @@ const shouldEmptyTargetDirectory = async (root: string, target: string, options:
     }
 
     if (isDirEmpty(root)) {
-        return false;
+        return;
     }
 
     if (await shouldOverwriteDirectory(target, options)) {
-        return true;
+        return;
     }
 
-    return fail(`Directory "${target}" is not empty`);
+    fail(`Directory "${target}" is not empty`);
 };
 
 const resolveTarget = async (options: CreateOptions): Promise<string> => {
@@ -404,6 +387,14 @@ const resolveApplicationId = async (options: CreateOptions, name: string): Promi
     return error === undefined ? applicationId : fail(error);
 };
 
+const resolveDisplayName = async (options: CreateOptions, name: string): Promise<string> => {
+    const value = options.displayName ??
+        (options.isInteractive ? await promptDisplayName(name) : displayNameFromProjectName(name));
+    const error = validateDisplayName(value);
+
+    return error === undefined ? value.trim() : fail(error);
+};
+
 const resolvePackageManager = async (
     requested: PackageManager | undefined,
     options: CreateOptions,
@@ -419,44 +410,36 @@ const resolvePackageManager = async (
     return (await detectedPackageManager()) ?? "pnpm";
 };
 
-const isTypescriptSelected = async (options: CreateOptions): Promise<boolean> => {
-    if (options.isTypescript !== undefined) {
-        return options.isTypescript;
-    }
-
-    return options.isInteractive ? shouldUseTypeScript() : true;
-};
-
-const isTestingIncluded = async (options: CreateOptions): Promise<boolean> => {
-    if (options.shouldIncludeTesting !== undefined) {
-        return options.shouldIncludeTesting;
-    }
-
-    return options.isInteractive ? shouldSetUpTesting() : true;
-};
-
 const resolveOptions = async (options: CreateOptions): Promise<ResolvedOptions> => {
     const requested = requestedPackageManager(options.packageManager);
     const target = await resolveTarget(options);
     const name = deriveProjectName(target);
+    const displayName = await resolveDisplayName(options, name);
     const applicationId = await resolveApplicationId(options, name);
     const root = resolve(process.cwd(), target);
     const isCurrentDirectory = root === process.cwd();
-    const shouldEmptyTarget = await shouldEmptyTargetDirectory(root, target, options);
+    const shouldInitialize = shouldInitializeGit(root);
+    await validateTargetAvailability(root, target, options);
     const packageManager = await resolvePackageManager(requested, options);
-    const isTypescript = await isTypescriptSelected(options);
-    const shouldIncludeTesting = await isTestingIncluded(options);
+    const isTypescript = await isOptionEnabled(options.isTypescript, options.isInteractive, "Use TypeScript?");
+
+    const shouldIncludeTesting = await isOptionEnabled(
+        options.shouldIncludeTesting,
+        options.isInteractive,
+        "Include testing setup (Vitest)?",
+    );
 
     return {
         target,
         root,
         isCurrentDirectory,
         name,
+        displayName,
         applicationId,
         packageManager,
         isTypescript,
         shouldIncludeTesting,
-        shouldEmptyTarget,
+        shouldInitializeGit: shouldInitialize,
     };
 };
 
@@ -472,48 +455,140 @@ const isTemplateIncluded = (templateRelativePath: string, resolved: ResolvedOpti
     return true;
 };
 
-const toScriptExtension = (templateRelativePath: string, isTypescript: boolean): string =>
-    isTypescript ? templateRelativePath : templateRelativePath.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
-
-const toIconPath = (path: string, applicationId: string): string =>
-    path.endsWith(ICON_TEMPLATE_NAME) ? `${path.slice(0, -ICON_TEMPLATE_NAME.length)}${applicationId}.svg` : path;
+const destinationPath = (template: string, resolved: ResolvedOptions): string => {
+    const scriptPath = resolved.isTypescript ? template : template.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
 
-const toDestinationPath = (templateRelativePath: string, isTypescript: boolean, applicationId: string): string =>
-    toIconPath(toScriptExtension(templateRelativePath, isTypescript), applicationId);
-
-const addTestScript = (root: string): void => {
-    updateManifest(root, (manifest) => {
-        (manifest.scripts as Record<string, string>).test = "vitest run";
-    });
+    return scriptPath.endsWith(ICON_TEMPLATE_NAME)
+        ? `${scriptPath.slice(0, -ICON_TEMPLATE_NAME.length)}${resolved.applicationId}.svg`
+        : scriptPath;
 };
 
 const templateContext = (resolved: ResolvedOptions): TemplateContext => ({
     name: resolved.name,
     applicationId: resolved.applicationId,
-    title: titleFromName(resolved.name),
+    displayName: resolved.displayName,
     shouldIncludeTesting: resolved.shouldIncludeTesting,
     isTypescript: resolved.isTypescript,
     importExtension: resolved.isTypescript ? ".js" : ".jsx",
-    developerName: gitConfigValue("user.name") ?? titleFromName(resolved.name),
+    developerName: gitConfigValue("user.name") ?? resolved.displayName,
     developerEmail: gitConfigValue("user.email"),
 });
 
-const scaffoldProject = async (root: string, resolved: ResolvedOptions): Promise<void> => {
-    const { applicationId, isTypescript, shouldIncludeTesting } = resolved;
+const replaceTemplateDestination = (destination: string): void => {
+    const entry = lstatSync(destination, { throwIfNoEntry: false });
+
+    if (entry === undefined) {
+        return;
+    }
+
+    if (!entry.isFile() && !entry.isSymbolicLink()) {
+        fail(`Cannot replace scaffold file because its destination is not a file: ${destination}`);
+    }
+
+    rmSync(destination, { force: true });
+};
+
+const projectRelativeDestination = (root: string, destination: string): string => {
+    const relativePath = relative(root, destination);
+    const isOutsideProject = relativePath.length === 0 || relativePath.startsWith(`..${sep}`) ||
+        isAbsolute(relativePath);
+
+    if (isOutsideProject) {
+        fail(`Scaffold destination is outside the project: ${destination}`);
+    }
+
+    return relativePath;
+};
+
+const assertRootIsNotSymbolicLink = (root: string): void => {
+    const rootEntry = lstatSync(root, { throwIfNoEntry: false });
+
+    if (rootEntry?.isSymbolicLink()) {
+        fail(`Cannot scaffold through a symbolic link: ${root}`);
+    }
+};
+
+const assertSafeAncestor = (ancestor: string): void => {
+    const entry = lstatSync(ancestor, { throwIfNoEntry: false });
+
+    if (entry?.isSymbolicLink()) {
+        fail(`Cannot scaffold through a symbolic link: ${ancestor}`);
+    }
+
+    if (entry !== undefined && !entry.isDirectory()) {
+        fail(`Cannot scaffold through a non-directory path: ${ancestor}`);
+    }
+};
+
+const assertSafeAncestors = (root: string, relativePath: string): void => {
+    let ancestor = root;
+    const segments = relativePath.split(sep);
+    const ancestorSegments = segments.slice(0, -1);
+
+    for (const segment of ancestorSegments) {
+        ancestor = join(ancestor, segment);
+        assertSafeAncestor(ancestor);
+    }
+};
+
+const assertReplaceableDestination = (destination: string): void => {
+    const entry = lstatSync(destination, { throwIfNoEntry: false });
+    const isReplaceable = entry === undefined || entry.isFile() || entry.isSymbolicLink();
+
+    if (!isReplaceable) {
+        fail(`Cannot replace scaffold file because its destination is not a file: ${destination}`);
+    }
+};
+
+const assertSafeDestination = (root: string, destination: string): void => {
+    const relativePath = projectRelativeDestination(root, destination);
+    assertRootIsNotSymbolicLink(root);
+    assertSafeAncestors(root, relativePath);
+    assertReplaceableDestination(destination);
+};
+
+const plannedScaffoldFiles = async (root: string, resolved: ResolvedOptions): Promise<ScaffoldFile[]> => {
     const context = templateContext(resolved);
+    const files: ScaffoldFile[] = [];
 
     for (const template of listTemplates()) {
-        if (!isTemplateIncluded(template, resolved)) {
-            continue;
+        if (isTemplateIncluded(template, resolved)) {
+            files.push({
+                destination: join(root, destinationPath(template, resolved)),
+                contents: await renderFile(template, context),
+            });
         }
+    }
+
+    return files;
+};
 
-        const destination = join(root, toDestinationPath(template, isTypescript, applicationId));
-        mkdirSync(dirname(destination), { recursive: true });
-        writeFileSync(destination, await renderFile(template, context));
+const auxiliaryDestinations = (root: string, resolved: ResolvedOptions): string[] => [
+    ...(resolved.packageManager === "pnpm" ? [join(root, "pnpm-workspace.yaml")] : []),
+    ...(resolved.isTypescript ? [join(root, "node_modules", ".gtkx", "env.d.ts")] : []),
+];
+
+const scaffoldProject = async (root: string, resolved: ResolvedOptions): Promise<void> => {
+    const files = await plannedScaffoldFiles(root, resolved);
+    const destinations = [...files.map((file) => file.destination), ...auxiliaryDestinations(root, resolved)];
+
+    for (const destination of destinations) {
+        assertSafeDestination(root, destination);
     }
 
-    if (shouldIncludeTesting) {
-        addTestScript(root);
+    for (const destination of destinations) {
+        replaceTemplateDestination(destination);
+    }
+
+    for (const file of files) {
+        mkdirSync(dirname(file.destination), { recursive: true });
+        writeFileSync(file.destination, file.contents);
+    }
+
+    if (resolved.shouldIncludeTesting) {
+        updateManifest(root, (manifest) => {
+            (manifest.scripts as Record<string, string>).test = "vitest run";
+        });
     }
 };
 
@@ -543,10 +618,11 @@ const installDependencies = async (options: InstallDependenciesOptions): Promise
     });
 };
 
-const pin = (names: string[]): string[] => names.map((dependency) => pinGtkxDependency(dependency, selfVersion));
+const pin = (names: string[]): string[] =>
+    names.map((dependency) => dependency.startsWith("@gtkx/") ? `${dependency}@^${selfVersion}` : dependency);
 
 const formatRecovery = ({ resolved, devDependencies }: InstallFailureOptions): string => {
-    const add = getAddCommand(resolved.packageManager);
+    const add = ADD_COMMAND[resolved.packageManager];
 
     const steps = [
         ...(resolved.isCurrentDirectory ? [] : [`cd ${resolved.target}`]),
@@ -608,7 +684,27 @@ const writeInitialEnvModule = (root: string): void => {
     writeFileSync(join(storeDir, "env.d.ts"), `${GTKX_ENV_MODULE_HEADER}\n`);
 };
 
-const initializeGitRepo = async (root: string): Promise<void> => {
+const isInsideGitRepository = (root: string): boolean => {
+    const git = tryResolveExecutable("git");
+
+    if (git === undefined) {
+        return false;
+    }
+
+    try {
+        execFileSync(git, ["-C", root, "rev-parse", "--show-toplevel"], { stdio: "ignore" });
+
+        return true;
+    } catch {
+        return false;
+    }
+};
+
+const initializeGitRepo = async (root: string, shouldInitialize: boolean): Promise<void> => {
+    if (!shouldInitialize || isInsideGitRepository(root)) {
+        return;
+    }
+
     const spinner = p.spinner();
     spinner.start("Initializing git repository...");
 
@@ -624,7 +720,7 @@ const initializeGitRepo = async (root: string): Promise<void> => {
 };
 
 const printNextSteps = (resolved: ResolvedOptions): void => {
-    const devCmd = getDevCommand(resolved.packageManager);
+    const devCmd = DEV_COMMAND[resolved.packageManager];
     const cdStep = resolved.isCurrentDirectory ? "" : `cd ${resolved.target}\n`;
     const testingNote = resolved.shouldIncludeTesting ? HEADLESS_COMPOSITOR_NOTE : "";
     p.note(`${cdStep}${devCmd}${testingNote}`, "Next steps");
@@ -636,9 +732,13 @@ const createProjectStructure = async (root: string, resolved: ResolvedOptions):
         done: "Project structure created",
         failed: "Failed to create the project structure",
         run: async () => {
-            prepareTargetDirectory(root, resolved.shouldEmptyTarget);
+            mkdirSync(root, { recursive: true });
             await scaffoldProject(root, resolved);
             writeBuildAllowance(root, resolved.packageManager);
+
+            if (resolved.isTypescript) {
+                writeInitialEnvModule(root);
+            }
         },
     });
 };
@@ -651,11 +751,7 @@ const scaffold = async (options: CreateOptions = {}): Promise<void> => {
     await createProjectStructure(root, resolved);
     await installAllDependencies({ resolved, devDependencies: devDeps });
 
-    if (resolved.isTypescript) {
-        writeInitialEnvModule(root);
-    }
-
-    await initializeGitRepo(root);
+    await initializeGitRepo(root, resolved.shouldInitializeGit);
     printNextSteps(resolved);
 };
 

package/src/templates/gtkx.config.ts.ejs

@@ -3,21 +3,11 @@ import { defineConfig } from "@gtkx/config";
 export default defineConfig({
     applicationId: "<%= applicationId %>",
     applicationIcon: "data/icons",
-    future: {
-        v2ByteArrays: true,
-        v2ValueReturns: true,
-        v2FinishResults: true,
-        v2InoutReturns: true,
-        v2ResourceImports: true,
-        v2DefaultLibraries: true,
-        v2TreeShaking: true,
-    },
     deploy: {
-        name: "<%= title %>",
+        name: <%- sourceStringLiteral(displayName) %>,
         summary: "A GTK4 application built with GTKX",
         description: [
-            "<%= title %> is a GTK4 and Adwaita application built with GTKX, which renders native GObject "
-            + "widgets from React. Replace this paragraph with a description of what your application does.",
+            <%- sourceStringLiteral(`${displayName} is a GTK4 and Adwaita application built with GTKX, which renders native GObject widgets from React. Replace this paragraph with a description of what your application does.`) %>,
         ],
         categories: ["Utility"],
     },

package/src/templates/mise.toml.ejs

@@ -0,0 +1,2 @@
+[tools]
+node = "26"

package/src/templates/package.json.ejs

@@ -10,6 +10,9 @@
     "author": <%- sourceStringLiteral(developerName) %>,
 <% } -%>
     "type": "module",
+    "engines": {
+        "node": ">=26.7.0"
+    },
     "scripts": {
         "dev": "gtkx dev",
         "build": "gtkx build",

package/src/templates/src/app.tsx.ejs

@@ -8,7 +8,7 @@ const MainWindow = () => {
 
     return (
         <GtkApplicationWindow
-            title="<%= title %>"
+            title={<%- sourceStringLiteral(displayName) %>}
             defaultWidth={400}
             defaultHeight={300}
             onCloseRequest={quit}

package/src/templates.ts

@@ -1,4 +1,4 @@
-import { sortStrings, sourceStringLiteral } from "@gtkx/utils";
+import { sortStrings, sourceStringLiteral, toPosixPath } from "@gtkx/utils";
 import ejs from "ejs";
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
@@ -6,7 +6,7 @@ import { join } from "node:path";
 type TemplateContext = {
     name: string;
     applicationId: string;
-    title: string;
+    displayName: string;
     shouldIncludeTesting: boolean;
     isTypescript: boolean;
     importExtension: string;
@@ -14,20 +14,18 @@ type TemplateContext = {
     developerEmail: string | null;
 };
 
-const getTemplatesDir = (): string => {
-    return join(import.meta.dirname, "templates");
-};
+const TEMPLATES_DIR = join(import.meta.dirname, "templates");
 
 const listTemplates = (): string[] =>
     sortStrings(
-        readdirSync(getTemplatesDir(), { recursive: true, withFileTypes: true })
+        readdirSync(TEMPLATES_DIR, { recursive: true, withFileTypes: true })
             .filter((entry) => entry.isFile())
             .map((entry) => join(entry.parentPath, entry.name))
-            .map((absolute) => absolute.slice(getTemplatesDir().length + 1).replaceAll(/[/\\]/g, "/"))
+            .map((absolute) => toPosixPath(absolute.slice(TEMPLATES_DIR.length + 1)))
             .map((relative) => relative.replace(/\.ejs$/, "")),
     );
 
 const renderFile = async (templateName: string, context: TemplateContext): Promise<string> =>
-    ejs.renderFile(join(getTemplatesDir(), `${templateName}.ejs`), { ...context, sourceStringLiteral });
+    ejs.renderFile(join(TEMPLATES_DIR, `${templateName}.ejs`), { ...context, sourceStringLiteral });
 
 export { listTemplates, renderFile, type TemplateContext };