create-loutre 0.6.0 → 0.8.0

package/README.md

@@ -8,11 +8,10 @@ Loutre Applicationをstarterから作成するproject initializerです。Runtim
 npm create loutre@latest my-app
 ```
 
-BunやDenoからも実行できます。
+Bunからも実行できます。
 
 ```sh
 bun create loutre my-app
-deno x -A npm:create-loutre@latest my-app
 ```
 
 対話形式でtargetとpackage managerを選択できます。
@@ -21,7 +20,6 @@ deno x -A npm:create-loutre@latest my-app
 
 - Node.js
 - Bun
-- Deno
 - Cloudflare Workers
 - AWS Lambda
 
@@ -31,7 +29,6 @@ deno x -A npm:create-loutre@latest my-app
 - pnpm
 - Yarn
 - Bun
-- Deno
 
 ## Non-interactive usage
 

package/dist/cli.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { relative } from 'node:path';
-import { isCancel, select, text } from '@clack/prompts';
+import { select, text } from '@clack/prompts';
 import { Command, CommanderError, Option } from 'commander';
 import { bootstrapApplication } from '@loutrejs/loutre';
 import { detectPresentationTerminal, renderLoutreBrand, } from '@loutrejs/loutre/presentation';
@@ -152,11 +152,11 @@ function createProcessIO() {
 }
 async function terminalPrompt(message, initialValue) {
     const result = await text({ message, defaultValue: initialValue });
-    return isCancel(result) ? undefined : result;
+    return typeof result === 'string' ? result : undefined;
 }
 async function terminalSelect(message, options, initialValue) {
     const result = await select({ message, options: [...options], initialValue });
-    return isCancel(result) ? undefined : result;
+    return typeof result === 'string' ? result : undefined;
 }
 function installDependencies(directory, packageManager) {
     const command = executableFor(packageManager);
@@ -184,8 +184,6 @@ function detectPackageManager(userAgent, runtime) {
     const globals = runtime;
     if (globals.Bun !== undefined)
         return 'bun';
-    if (globals.Deno !== undefined)
-        return 'deno';
     const name = userAgent?.split('/')[0];
     return (packageManagers.find((packageManager) => packageManager === name) ?? 'npm');
 }
@@ -203,8 +201,8 @@ function helpText() {
         'Usage: create-loutre [directory] [options]',
         '',
         'Options:',
-        '  --target <target>                    node | bun | deno | cloudflare-workers | aws-lambda',
-        '  --package-manager <package-manager>  npm | pnpm | yarn | bun | deno',
+        '  --target <target>                    node | bun | cloudflare-workers | aws-lambda',
+        '  --package-manager <package-manager>  npm | pnpm | yarn | bun',
         '  -y, --yes                            Use defaults for unspecified options',
         '  --no-install                         Skip dependency installation',
         '  -h, --help                           Show help',

package/dist/options.d.ts

@@ -1,8 +1,8 @@
 import type { RuntimeEngine } from '@loutrejs/loutre/runtime';
-export declare const projectTargets: readonly ["node", "bun", "deno", "cloudflare-workers", "aws-lambda"];
+export declare const projectTargets: readonly ["node", "bun", "cloudflare-workers", "aws-lambda"];
 export type ProjectTarget = Exclude<RuntimeEngine, 'electron' | 'unknown'>;
 export declare function createIsTarget(target: ProjectTarget): (candidate: ProjectTarget) => boolean;
-export declare const packageManagers: readonly ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
+export declare const packageManagers: readonly ['npm', 'pnpm', 'yarn', 'bun'];
 export type PackageManager = (typeof packageManagers)[number];
 export declare const targetLabels: Readonly<Record<ProjectTarget, string>>;
 export declare const packageManagerLabels: Readonly<Record<PackageManager, string>>;

package/dist/options.js

@@ -1,18 +1,17 @@
+import { match } from 'ts-pattern';
 export const projectTargets = [
     'node',
     'bun',
-    'deno',
     'cloudflare-workers',
     'aws-lambda',
 ];
 export function createIsTarget(target) {
     return (candidate) => target === candidate;
 }
-export const packageManagers = ['npm', 'pnpm', 'yarn', 'bun', 'deno'];
+export const packageManagers = ['npm', 'pnpm', 'yarn', 'bun'];
 export const targetLabels = {
     node: 'Node.js',
     bun: 'Bun',
-    deno: 'Deno',
     'cloudflare-workers': 'Cloudflare Workers',
     'aws-lambda': 'AWS Lambda',
 };
@@ -21,22 +20,15 @@ export const packageManagerLabels = {
     pnpm: 'pnpm',
     yarn: 'Yarn',
     bun: 'Bun',
-    deno: 'Deno',
 };
 export function installCommand(packageManager) {
     return `${packageManager} install`;
 }
 export function runScriptCommand(packageManager, script) {
-    switch (packageManager) {
-        case 'npm':
-            return `npm run ${script}`;
-        case 'pnpm':
-            return `pnpm run ${script}`;
-        case 'yarn':
-            return `yarn run ${script}`;
-        case 'bun':
-            return `bun run ${script}`;
-        case 'deno':
-            return `deno task ${script}`;
-    }
+    return match(packageManager)
+        .with('npm', () => `npm run ${script}`)
+        .with('pnpm', () => `pnpm run ${script}`)
+        .with('yarn', () => `yarn run ${script}`)
+        .with('bun', () => `bun run ${script}`)
+        .exhaustive();
 }

package/dist/starter.js

@@ -1,7 +1,8 @@
 import { readFileSync } from 'node:fs';
-import { cp, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import { cp, readFile, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { match } from 'ts-pattern';
 import { createIsTarget, runScriptCommand, targetLabels, } from './options.js';
 const packageManifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const loutreVersion = requiredDependencyVersion('@loutrejs/loutre');
@@ -35,9 +36,6 @@ export async function writeStarter(targetDirectory, options) {
         verifyCommand: runScriptCommand(options.packageManager, 'verify'),
         deploymentSection: deploymentSection(options),
     });
-    if (isTarget('deno')) {
-        await rewriteLocalImportExtensionsForDeno(join(targetDirectory, 'src'));
-    }
     if (isTarget('cloudflare-workers')) {
         await renderTextTemplate(join(targetDirectory, 'wrangler.jsonc'), {
             packageName: workerNameFor(options.packageName),
@@ -46,58 +44,45 @@ export async function writeStarter(targetDirectory, options) {
     }
 }
 function targetManifest(target) {
-    switch (target) {
-        case 'node':
-            return {
-                scripts: {
-                    dev: 'tsx watch src/main.ts',
-                    build: 'tsc -p tsconfig.build.json',
-                    start: 'node dist/main.js',
-                },
-                dependencies: { '@loutrejs/node': loutreVersion },
-                devDependencies: { '@types/node': '^22.20.1', tsx: '^4.23.12' },
-                engines: { node: '>=22' },
-                types: ['node'],
-            };
-        case 'bun':
-            return {
-                scripts: {
-                    dev: 'bun --watch src/main.ts',
-                    build: 'bun build src/main.ts --outdir dist --target bun',
-                    start: 'bun dist/main.js',
-                },
-                devDependencies: { '@types/bun': '^1.4.0' },
-                types: ['bun'],
-            };
-        case 'deno':
-            return {
-                scripts: {
-                    dev: 'deno run -A --watch src/main.ts',
-                    start: 'deno run -A src/main.ts',
-                },
-                typecheck: 'tsc --noEmit --allowImportingTsExtensions',
-                types: [],
-            };
-        case 'cloudflare-workers':
-            return {
-                scripts: {
-                    dev: 'wrangler dev',
-                    build: 'wrangler deploy --dry-run --outdir dist',
-                    deploy: 'wrangler deploy',
-                },
-                devDependencies: { wrangler: '^4.127.1' },
-                types: [],
-            };
-        case 'aws-lambda':
-            return {
-                scripts: {
-                    build: 'esbuild src/main.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.mjs',
-                },
-                devDependencies: { '@types/node': '^22.20.1', esbuild: '^0.28.2' },
-                engines: { node: '>=22' },
-                types: ['node'],
-            };
-    }
+    return match(target)
+        .with('node', () => ({
+        scripts: {
+            dev: 'tsx watch src/main.ts',
+            build: 'tsc -p tsconfig.build.json',
+            start: 'node dist/main.js',
+        },
+        dependencies: { '@loutrejs/node': loutreVersion },
+        devDependencies: { '@types/node': '^22.20.1', tsx: '^4.23.12' },
+        engines: { node: '>=22' },
+        types: ['node'],
+    }))
+        .with('bun', () => ({
+        scripts: {
+            dev: 'bun --watch src/main.ts',
+            build: 'bun build src/main.ts --outdir dist --target bun',
+            start: 'bun dist/main.js',
+        },
+        devDependencies: { '@types/bun': '^1.4.0' },
+        types: ['bun'],
+    }))
+        .with('cloudflare-workers', () => ({
+        scripts: {
+            dev: 'wrangler dev',
+            build: 'wrangler deploy --dry-run --outdir dist',
+            deploy: 'wrangler deploy',
+        },
+        devDependencies: { wrangler: '^4.127.1' },
+        types: [],
+    }))
+        .with('aws-lambda', () => ({
+        scripts: {
+            build: 'esbuild src/main.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.mjs',
+        },
+        devDependencies: { '@types/node': '^22.20.1', esbuild: '^0.28.2' },
+        engines: { node: '>=22' },
+        types: ['node'],
+    }))
+        .exhaustive();
 }
 function renderPackageJson(options) {
     const target = targetManifest(options.target);
@@ -188,9 +173,7 @@ function deploymentSection(options) {
         '## Production',
         '',
         '```sh',
-        ...(isTarget('deno')
-            ? []
-            : [runScriptCommand(options.packageManager, 'build')]),
+        runScriptCommand(options.packageManager, 'build'),
         runScriptCommand(options.packageManager, 'start'),
         '```',
     ].join('\n');
@@ -206,20 +189,6 @@ async function replaceText(path, search, replacement) {
     const content = await readFile(path, 'utf8');
     await writeFile(path, content.replaceAll(search, replacement), 'utf8');
 }
-async function rewriteLocalImportExtensionsForDeno(directory) {
-    const entries = await readdir(directory, { withFileTypes: true });
-    await Promise.all(entries.map(async (entry) => {
-        const path = join(directory, entry.name);
-        if (entry.isDirectory()) {
-            await rewriteLocalImportExtensionsForDeno(path);
-            return;
-        }
-        if (!entry.isFile() || !entry.name.endsWith('.ts'))
-            return;
-        const content = await readFile(path, 'utf8');
-        await writeFile(path, content.replaceAll(/(from\s+['"]\.{1,2}\/[^'"]+)\.js(['"])/gu, '$1.ts$2'), 'utf8');
-    }));
-}
 function workerNameFor(packageName) {
     return (packageName
         .replace(/[^a-z0-9-]+/gu, '-')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loutre",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Loutre project initializer",
   "license": "MIT",
   "type": "module",
@@ -17,9 +17,10 @@
     "provenance": true
   },
   "dependencies": {
-    "@clack/prompts": "^1.7.0",
-    "@loutrejs/loutre": "^0.6.0",
-    "commander": "^15.0.0"
+    "@clack/prompts": "^1.8.1",
+    "@loutrejs/loutre": "^0.8.0",
+    "commander": "^15.0.0",
+    "ts-pattern": "^5.9.0"
   },
   "repository": {
     "type": "git",

package/templates/base/_gitignore

@@ -2,3 +2,4 @@ node_modules/
 dist/
 coverage/
 .env
+.loutre/

package/templates/targets/deno/src/main.ts

@@ -1,5 +0,0 @@
-import { denoRuntime } from '@loutrejs/loutre/runtime/deno'
-import application from './app.ts'
-
-const app = await denoRuntime.create({ application })
-await app.serve()