@tschk/moonshine-cli 0.4.1 → 0.4.49
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +108 -18
- package/bin/moonshine.ts +31 -17
- package/package.json +28 -14
- package/src/adopt/gaps.ts +33 -6
- package/src/adopt/plan.ts +77 -11
- package/src/adopt/project.ts +12 -2
- package/src/adopt/report.ts +2 -2
- package/src/adopt/scan.ts +18 -3
- package/src/adopt/templates.ts +157 -79
- package/src/adopt/types.ts +6 -3
- package/src/adopt.ts +15 -17
- package/src/build.ts +50 -3
- package/src/compile-graph.ts +6 -0
- package/src/compile-output.ts +1 -0
- package/src/compile.ts +72 -64
- package/src/config.ts +2 -1
- package/src/dev.ts +12 -1
- package/src/new.ts +193 -67
- package/src/preview-native.ts +150 -0
- package/src/preview-worker.ts +38 -0
- package/src/preview.ts +64 -14
package/src/new.ts
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
import { existsSync } from "node:fs";
|
|
2
|
-
import { mkdir, writeFile } from "node:fs/promises";
|
|
2
|
+
import { mkdir, readdir, writeFile } from "node:fs/promises";
|
|
3
3
|
import { join, resolve } from "node:path";
|
|
4
4
|
|
|
5
|
-
type Renderer = "
|
|
5
|
+
type Renderer = "native" | "react" | "crepus";
|
|
6
6
|
type Adapter = "bun" | "node" | "cloudflare" | "vercel";
|
|
7
7
|
|
|
8
8
|
export function detectMoonshineRoot(): string | null {
|
|
@@ -33,12 +33,14 @@ export function packagePath(
|
|
|
33
33
|
): string | undefined {
|
|
34
34
|
const map: Record<string, string> = {
|
|
35
35
|
"@tschk/moonshine": "packages/core",
|
|
36
|
+
"@tschk/moonshine-dom": "packages/dom",
|
|
36
37
|
"@tschk/moonshine-next": "packages/adapter-next",
|
|
37
38
|
"@tschk/moonshine-react-router": "packages/adapter-react-router",
|
|
38
39
|
"@tschk/moonshine-tanstack": "packages/adapter-tanstack",
|
|
39
40
|
"@tschk/moonshine-waku": "packages/adapter-waku",
|
|
40
41
|
"@tschk/moonshine-framework": "packages/framework",
|
|
41
42
|
"@tschk/moonshine-compiler": "packages/compiler",
|
|
43
|
+
"@tschk/moonshine-cli": "packages/cli",
|
|
42
44
|
"@tschk/moonshine-server": "packages/server",
|
|
43
45
|
"@tschk/moonshine-react": "packages/react",
|
|
44
46
|
"@tschk/moonshine-solid": "packages/adapter-solid",
|
|
@@ -52,14 +54,33 @@ export function packagePath(
|
|
|
52
54
|
return rel ? dep(root, rel, version) : undefined;
|
|
53
55
|
}
|
|
54
56
|
|
|
55
|
-
|
|
57
|
+
/** Keep transitive local package references off the registry while developing Moonshine. */
|
|
58
|
+
export async function localOverrides(
|
|
59
|
+
root: string | null,
|
|
60
|
+
): Promise<Record<string, string> | undefined> {
|
|
61
|
+
if (!root) return undefined;
|
|
62
|
+
const overrides: Record<string, string> = {};
|
|
63
|
+
for (const entry of await readdir(join(root, "packages"), {
|
|
64
|
+
withFileTypes: true,
|
|
65
|
+
})) {
|
|
66
|
+
if (!entry.isDirectory()) continue;
|
|
67
|
+
const directory = join(root, "packages", entry.name);
|
|
68
|
+
const manifestFile = Bun.file(join(directory, "package.json"));
|
|
69
|
+
if (!(await manifestFile.exists())) continue;
|
|
70
|
+
const manifest = (await manifestFile.json()) as { name?: string };
|
|
71
|
+
if (manifest.name) overrides[manifest.name] = `file:${directory}`;
|
|
72
|
+
}
|
|
73
|
+
return overrides;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
function runtimeForAdapter(adapter: Adapter, renderer?: Renderer): string {
|
|
56
77
|
switch (adapter) {
|
|
57
78
|
case "node":
|
|
58
79
|
return "node";
|
|
59
80
|
case "cloudflare":
|
|
60
81
|
return "cloudflare";
|
|
61
82
|
case "vercel":
|
|
62
|
-
return "vercel-edge";
|
|
83
|
+
return renderer === "native" ? "node" : "vercel-edge";
|
|
63
84
|
case "bun":
|
|
64
85
|
default:
|
|
65
86
|
return "bun";
|
|
@@ -78,8 +99,9 @@ function parseArgs(args: string[]): {
|
|
|
78
99
|
let vite = false;
|
|
79
100
|
for (let i = 0; i < args.length; i++) {
|
|
80
101
|
const a = args[i]!;
|
|
81
|
-
if (a === "--
|
|
82
|
-
else if (a === "--
|
|
102
|
+
if (a === "--native") renderer = "native";
|
|
103
|
+
else if (a === "--react") renderer = "react";
|
|
104
|
+
else if (a === "--solid") renderer = "native";
|
|
83
105
|
else if (a === "--crepus") renderer = "crepus";
|
|
84
106
|
else if (a === "--adapter") {
|
|
85
107
|
const next = args[++i];
|
|
@@ -102,11 +124,11 @@ function parseArgs(args: string[]): {
|
|
|
102
124
|
}
|
|
103
125
|
if (!name) {
|
|
104
126
|
console.error(
|
|
105
|
-
"Usage: moonshine new <name> [--react|--solid|--crepus] [--adapter bun|node|cloudflare|vercel] [--vite]",
|
|
127
|
+
"Usage: moonshine new <name> [--native|--react|--solid|--crepus] [--adapter bun|node|cloudflare|vercel] [--vite]",
|
|
106
128
|
);
|
|
107
129
|
process.exit(1);
|
|
108
130
|
}
|
|
109
|
-
return { name, renderer, adapter, vite };
|
|
131
|
+
return { name, renderer: renderer ?? "native", adapter, vite };
|
|
110
132
|
}
|
|
111
133
|
|
|
112
134
|
async function writePackageJson(
|
|
@@ -116,21 +138,44 @@ async function writePackageJson(
|
|
|
116
138
|
renderer: Renderer | undefined,
|
|
117
139
|
adapter: Adapter,
|
|
118
140
|
): Promise<void> {
|
|
119
|
-
const dependencies: Record<string, string> =
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
141
|
+
const dependencies: Record<string, string> =
|
|
142
|
+
renderer === "native"
|
|
143
|
+
? {
|
|
144
|
+
"@tschk/moonshine-dom": packagePath(
|
|
145
|
+
"@tschk/moonshine-dom",
|
|
146
|
+
root,
|
|
147
|
+
"^0.4.2",
|
|
148
|
+
)!,
|
|
149
|
+
"@tschk/moonshine-framework": packagePath(
|
|
150
|
+
"@tschk/moonshine-framework",
|
|
151
|
+
root,
|
|
152
|
+
"^0.4.2",
|
|
153
|
+
)!,
|
|
154
|
+
"@tschk/moonshine-server": packagePath(
|
|
155
|
+
"@tschk/moonshine-server",
|
|
156
|
+
root,
|
|
157
|
+
"^0.4.2",
|
|
158
|
+
)!,
|
|
159
|
+
}
|
|
160
|
+
: {
|
|
161
|
+
"@tschk/moonshine": packagePath("@tschk/moonshine", root)!,
|
|
162
|
+
"@tschk/moonshine-framework": packagePath(
|
|
163
|
+
"@tschk/moonshine-framework",
|
|
164
|
+
root,
|
|
165
|
+
)!,
|
|
166
|
+
"@tschk/moonshine-compiler": packagePath(
|
|
167
|
+
"@tschk/moonshine-compiler",
|
|
168
|
+
root,
|
|
169
|
+
)!,
|
|
170
|
+
"@tschk/moonshine-server": packagePath(
|
|
171
|
+
"@tschk/moonshine-server",
|
|
172
|
+
root,
|
|
173
|
+
)!,
|
|
174
|
+
};
|
|
131
175
|
dependencies[`@tschk/moonshine-deploy-${adapter}`] = packagePath(
|
|
132
176
|
`@tschk/moonshine-deploy-${adapter}`,
|
|
133
177
|
root,
|
|
178
|
+
renderer === "native" ? "^0.4.2" : "^0.2.0",
|
|
134
179
|
)!;
|
|
135
180
|
|
|
136
181
|
const devDependencies: Record<string, string> = {
|
|
@@ -138,7 +183,11 @@ async function writePackageJson(
|
|
|
138
183
|
typescript: "~7.0.0",
|
|
139
184
|
};
|
|
140
185
|
|
|
141
|
-
if (renderer === "
|
|
186
|
+
if (renderer === "native") {
|
|
187
|
+
devDependencies["@tschk/moonshine-cli"] = root
|
|
188
|
+
? dep(root, "packages/cli")
|
|
189
|
+
: "^0.4.2";
|
|
190
|
+
} else if (renderer === "react") {
|
|
142
191
|
dependencies["@tschk/moonshine-react"] = packagePath(
|
|
143
192
|
"@tschk/moonshine-react",
|
|
144
193
|
root,
|
|
@@ -147,12 +196,6 @@ async function writePackageJson(
|
|
|
147
196
|
dependencies["react-dom"] = "^19.1.0";
|
|
148
197
|
devDependencies["@types/react"] = "^19.1.0";
|
|
149
198
|
devDependencies["@types/react-dom"] = "^19.1.0";
|
|
150
|
-
} else if (renderer === "solid") {
|
|
151
|
-
dependencies["@tschk/moonshine-solid"] = packagePath(
|
|
152
|
-
"@tschk/moonshine-solid",
|
|
153
|
-
root,
|
|
154
|
-
)!;
|
|
155
|
-
dependencies["solid-js"] = "^1.9.14";
|
|
156
199
|
} else if (renderer === "crepus") {
|
|
157
200
|
dependencies["@tschk/crepus-moonshine"] = packagePath(
|
|
158
201
|
"@tschk/crepus-moonshine",
|
|
@@ -180,9 +223,15 @@ async function writePackageJson(
|
|
|
180
223
|
build: "moonshine build",
|
|
181
224
|
dev: "moonshine dev",
|
|
182
225
|
preview: "moonshine preview",
|
|
226
|
+
...(renderer === "native" && adapter === "node"
|
|
227
|
+
? { start: "node .moonshine/server.js" }
|
|
228
|
+
: {}),
|
|
183
229
|
},
|
|
184
230
|
dependencies,
|
|
185
231
|
devDependencies,
|
|
232
|
+
...(renderer === "native" && root
|
|
233
|
+
? { overrides: await localOverrides(root) }
|
|
234
|
+
: {}),
|
|
186
235
|
},
|
|
187
236
|
null,
|
|
188
237
|
2,
|
|
@@ -198,16 +247,14 @@ async function writeTsconfig(
|
|
|
198
247
|
target: "ES2024",
|
|
199
248
|
module: "ESNext",
|
|
200
249
|
moduleResolution: "Bundler",
|
|
201
|
-
jsx:
|
|
250
|
+
jsx: "react-jsx",
|
|
202
251
|
strict: true,
|
|
203
252
|
skipLibCheck: true,
|
|
204
253
|
noEmit: true,
|
|
205
254
|
types: ["bun"],
|
|
206
255
|
lib: ["ES2024", "DOM"],
|
|
207
256
|
};
|
|
208
|
-
if (renderer === "
|
|
209
|
-
compilerOptions.jsxImportSource = "solid-js";
|
|
210
|
-
}
|
|
257
|
+
if (renderer === "native") delete compilerOptions.jsx;
|
|
211
258
|
await writeFile(
|
|
212
259
|
join(dir, "tsconfig.json"),
|
|
213
260
|
JSON.stringify(
|
|
@@ -226,9 +273,20 @@ async function writeConfig(
|
|
|
226
273
|
renderer: Renderer | undefined,
|
|
227
274
|
adapter: Adapter,
|
|
228
275
|
): Promise<void> {
|
|
229
|
-
const runtime = runtimeForAdapter(adapter);
|
|
276
|
+
const runtime = runtimeForAdapter(adapter, renderer);
|
|
230
277
|
const entries: Record<string, unknown> = { runtime, adapter };
|
|
231
278
|
if (renderer) entries.renderer = renderer;
|
|
279
|
+
if (renderer === "native")
|
|
280
|
+
entries.routes = [
|
|
281
|
+
{ id: "home", path: "/", file: "src/routes/home.ts", mode: "ssr" },
|
|
282
|
+
{
|
|
283
|
+
id: "counter",
|
|
284
|
+
path: "/counter",
|
|
285
|
+
file: "src/routes/counter.ts",
|
|
286
|
+
clientFile: "src/client/counter.ts",
|
|
287
|
+
mode: "spa",
|
|
288
|
+
},
|
|
289
|
+
];
|
|
232
290
|
await writeFile(
|
|
233
291
|
join(dir, "moonshine.config.ts"),
|
|
234
292
|
`import { defineConfig } from "@tschk/moonshine-framework";
|
|
@@ -243,7 +301,9 @@ async function writeRoute(
|
|
|
243
301
|
renderer: Renderer | undefined,
|
|
244
302
|
): Promise<void> {
|
|
245
303
|
await mkdir(join(dir, "src", "routes"), { recursive: true });
|
|
246
|
-
if (renderer === "
|
|
304
|
+
if (renderer === "native") {
|
|
305
|
+
await writeNativeRoutes(dir);
|
|
306
|
+
} else if (renderer === "react") {
|
|
247
307
|
await writeFile(
|
|
248
308
|
join(dir, "src", "routes", "index.tsx"),
|
|
249
309
|
`export default function Home({ data }: { data?: unknown }) {
|
|
@@ -254,21 +314,6 @@ async function writeRoute(
|
|
|
254
314
|
</main>
|
|
255
315
|
);
|
|
256
316
|
}
|
|
257
|
-
`,
|
|
258
|
-
);
|
|
259
|
-
} else if (renderer === "solid") {
|
|
260
|
-
await writeFile(
|
|
261
|
-
join(dir, "src", "routes", "index.ts"),
|
|
262
|
-
`import h from "@tschk/moonshine-solid/h";
|
|
263
|
-
|
|
264
|
-
export default function Home({ data }: { data?: unknown }) {
|
|
265
|
-
const d = (data ?? {}) as Record<string, string>;
|
|
266
|
-
return h(
|
|
267
|
-
"main",
|
|
268
|
-
{ "data-moonshine-mode": d.mode ?? "default" },
|
|
269
|
-
h("h1", null, "Moonshine"),
|
|
270
|
-
);
|
|
271
|
-
}
|
|
272
317
|
`,
|
|
273
318
|
);
|
|
274
319
|
} else if (renderer === "crepus") {
|
|
@@ -284,16 +329,63 @@ export default function Home({ data }: { data?: unknown }) {
|
|
|
284
329
|
}
|
|
285
330
|
}
|
|
286
331
|
|
|
332
|
+
async function writeNativeRoutes(dir: string): Promise<void> {
|
|
333
|
+
await mkdir(join(dir, "src/client"), { recursive: true });
|
|
334
|
+
await Promise.all([
|
|
335
|
+
writeFile(
|
|
336
|
+
join(dir, "src/routes/home.ts"),
|
|
337
|
+
`import { h } from "@tschk/moonshine-dom/ssr";
|
|
338
|
+
|
|
339
|
+
export function loader({ request }: { request: Request }) {
|
|
340
|
+
return { name: new URL(request.url).searchParams.get("name") ?? "world" };
|
|
341
|
+
}
|
|
342
|
+
|
|
343
|
+
export default function Home({ data }: { data: { home: ReturnType<typeof loader> } }) {
|
|
344
|
+
return h("main", null,
|
|
345
|
+
h("h1", null, "hello, ", data.home.name),
|
|
346
|
+
h("a", { href: "/counter" }, "open counter"),
|
|
347
|
+
);
|
|
348
|
+
}
|
|
349
|
+
`,
|
|
350
|
+
),
|
|
351
|
+
writeFile(
|
|
352
|
+
join(dir, "src/routes/counter.ts"),
|
|
353
|
+
`export function loader() {
|
|
354
|
+
return { start: 0 };
|
|
355
|
+
}
|
|
356
|
+
`,
|
|
357
|
+
),
|
|
358
|
+
writeFile(
|
|
359
|
+
join(dir, "src/client/counter.ts"),
|
|
360
|
+
`import { h } from "@tschk/moonshine-dom/dom";
|
|
361
|
+
import { createSignal } from "@tschk/moonshine-dom/reactive";
|
|
362
|
+
|
|
363
|
+
export default function Counter({ data }: { data: { counter: { start: number } } }) {
|
|
364
|
+
const [count, setCount] = createSignal(data.counter.start);
|
|
365
|
+
return h("main", null,
|
|
366
|
+
h("a", { href: "/" }, "home"),
|
|
367
|
+
h("h1", null, "Moonshine"),
|
|
368
|
+
h("button", { type: "button", onClick: () => setCount(count() + 1) }, () => "count " + count()),
|
|
369
|
+
);
|
|
370
|
+
}
|
|
371
|
+
`,
|
|
372
|
+
),
|
|
373
|
+
]);
|
|
374
|
+
}
|
|
375
|
+
|
|
287
376
|
async function writeReadme(
|
|
288
377
|
dir: string,
|
|
289
378
|
name: string,
|
|
290
379
|
renderer: Renderer | undefined,
|
|
291
380
|
adapter: Adapter,
|
|
292
381
|
): Promise<void> {
|
|
293
|
-
const runtime = runtimeForAdapter(adapter);
|
|
382
|
+
const runtime = runtimeForAdapter(adapter, renderer);
|
|
294
383
|
let body = `# ${name}\n\nMoonshine on **${adapter}** (${runtime}).\n\n\`\`\`bash\nbun install\nbun run dev\n\`\`\`\n`;
|
|
384
|
+
if (renderer === "native")
|
|
385
|
+
body +=
|
|
386
|
+
"\nThe home page renders on the server. `/counter` mounts the independent DOM runtime.\nServer and browser entries are authored separately; hydration and islands are not supported.\n";
|
|
295
387
|
if (!renderer)
|
|
296
|
-
body += `\nAdd \`--react
|
|
388
|
+
body += `\nAdd \`--react\` or \`--crepus\` for a legacy UI renderer.\n`;
|
|
297
389
|
await writeFile(join(dir, "README.md"), body);
|
|
298
390
|
}
|
|
299
391
|
|
|
@@ -301,6 +393,7 @@ async function writeViteApp(
|
|
|
301
393
|
dir: string,
|
|
302
394
|
name: string,
|
|
303
395
|
root: string | null,
|
|
396
|
+
renderer: Renderer,
|
|
304
397
|
): Promise<void> {
|
|
305
398
|
await mkdir(join(dir, "src"), { recursive: true });
|
|
306
399
|
|
|
@@ -318,15 +411,31 @@ async function writeViteApp(
|
|
|
318
411
|
build: "vite build",
|
|
319
412
|
preview: "vite preview",
|
|
320
413
|
},
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
414
|
+
...(renderer === "native" && root
|
|
415
|
+
? { overrides: await localOverrides(root) }
|
|
416
|
+
: {}),
|
|
417
|
+
dependencies:
|
|
418
|
+
renderer === "native"
|
|
419
|
+
? {
|
|
420
|
+
"@tschk/moonshine-dom": packagePath(
|
|
421
|
+
"@tschk/moonshine-dom",
|
|
422
|
+
root,
|
|
423
|
+
"^0.4.2",
|
|
424
|
+
)!,
|
|
425
|
+
}
|
|
426
|
+
: {
|
|
427
|
+
"@tschk/moonshine": dep(root, "packages/core"),
|
|
428
|
+
react: "^19.1.0",
|
|
429
|
+
"react-dom": "^19.1.0",
|
|
430
|
+
},
|
|
326
431
|
devDependencies: {
|
|
327
|
-
"
|
|
328
|
-
|
|
329
|
-
|
|
432
|
+
...(renderer === "react"
|
|
433
|
+
? {
|
|
434
|
+
"@types/react": "^19.1.0",
|
|
435
|
+
"@types/react-dom": "^19.1.0",
|
|
436
|
+
"@vitejs/plugin-react": "^4.5.0",
|
|
437
|
+
}
|
|
438
|
+
: {}),
|
|
330
439
|
typescript: "~7.0.0",
|
|
331
440
|
vite: "^6.3.5",
|
|
332
441
|
},
|
|
@@ -343,7 +452,7 @@ async function writeViteApp(
|
|
|
343
452
|
target: "ES2024",
|
|
344
453
|
module: "ESNext",
|
|
345
454
|
moduleResolution: "Bundler",
|
|
346
|
-
jsx: "react-jsx",
|
|
455
|
+
...(renderer === "react" ? { jsx: "react-jsx" } : {}),
|
|
347
456
|
strict: true,
|
|
348
457
|
skipLibCheck: true,
|
|
349
458
|
noEmit: true,
|
|
@@ -357,7 +466,11 @@ async function writeViteApp(
|
|
|
357
466
|
),
|
|
358
467
|
writeFile(
|
|
359
468
|
join(dir, "vite.config.ts"),
|
|
360
|
-
|
|
469
|
+
renderer === "native"
|
|
470
|
+
? `import { defineConfig } from "vite";
|
|
471
|
+
export default defineConfig({});
|
|
472
|
+
`
|
|
473
|
+
: `import { defineConfig } from "vite";
|
|
361
474
|
import react from "@vitejs/plugin-react";
|
|
362
475
|
|
|
363
476
|
export default defineConfig({
|
|
@@ -376,14 +489,26 @@ export default defineConfig({
|
|
|
376
489
|
</head>
|
|
377
490
|
<body>
|
|
378
491
|
<div id="app"></div>
|
|
379
|
-
<script type="module" src="/src/main
|
|
492
|
+
<script type="module" src="/src/main.${renderer === "native" ? "ts" : "tsx"}"></script>
|
|
380
493
|
</body>
|
|
381
494
|
</html>
|
|
382
495
|
`,
|
|
383
496
|
),
|
|
384
497
|
writeFile(
|
|
385
|
-
join(dir, "src/main.tsx"),
|
|
386
|
-
|
|
498
|
+
join(dir, renderer === "native" ? "src/main.ts" : "src/main.tsx"),
|
|
499
|
+
renderer === "native"
|
|
500
|
+
? `import { h, render } from "@tschk/moonshine-dom/dom";
|
|
501
|
+
import { createSignal } from "@tschk/moonshine-dom/reactive";
|
|
502
|
+
|
|
503
|
+
render(() => {
|
|
504
|
+
const [count, setCount] = createSignal(0);
|
|
505
|
+
return h("main", null,
|
|
506
|
+
h("h1", null, "Moonshine"),
|
|
507
|
+
h("button", { type: "button", onClick: () => setCount(count() + 1) }, () => "count " + count()),
|
|
508
|
+
);
|
|
509
|
+
}, document.querySelector("#app")!);
|
|
510
|
+
`
|
|
511
|
+
: `import { createSignal, useSignal, createApp } from "@tschk/moonshine/react";
|
|
387
512
|
|
|
388
513
|
const count = createSignal(0);
|
|
389
514
|
|
|
@@ -405,7 +530,7 @@ createApp({ root: App }).mount("#app");
|
|
|
405
530
|
),
|
|
406
531
|
writeFile(
|
|
407
532
|
join(dir, "README.md"),
|
|
408
|
-
`# ${name}\n\nVite +
|
|
533
|
+
`# ${name}\n\nVite + Moonshine ${renderer === "native" ? "independent DOM runtime" : "signals"} (client SPA).\n\n\`\`\`bash\nbun install\nbun run dev\n\`\`\`\n\nFull-stack Bun (SSR and separate browser entries; no hydration): \`moonshine new app\`.\n`,
|
|
409
534
|
),
|
|
410
535
|
]);
|
|
411
536
|
}
|
|
@@ -430,10 +555,11 @@ async function writeBunApp(
|
|
|
430
555
|
|
|
431
556
|
export async function newCommand(args: string[]): Promise<void> {
|
|
432
557
|
const { name, renderer, adapter, vite } = parseArgs(args);
|
|
433
|
-
if (vite &&
|
|
434
|
-
console.error("--vite
|
|
558
|
+
if (vite && renderer !== "react" && renderer !== "native") {
|
|
559
|
+
console.error("--vite supports --native or --react scaffolds");
|
|
435
560
|
process.exit(1);
|
|
436
561
|
}
|
|
562
|
+
|
|
437
563
|
const root = detectMoonshineRoot();
|
|
438
564
|
const dir = resolve(process.cwd(), name);
|
|
439
565
|
if (existsSync(dir)) {
|
|
@@ -442,7 +568,7 @@ export async function newCommand(args: string[]): Promise<void> {
|
|
|
442
568
|
}
|
|
443
569
|
|
|
444
570
|
await mkdir(dir, { recursive: true });
|
|
445
|
-
if (vite) await writeViteApp(dir, name, root);
|
|
571
|
+
if (vite) await writeViteApp(dir, name, root, renderer!);
|
|
446
572
|
else await writeBunApp(dir, name, root, renderer, adapter);
|
|
447
573
|
|
|
448
574
|
console.log(`Created ${name}/ (${vite ? "vite" : adapter})`);
|
|
@@ -0,0 +1,150 @@
|
|
|
1
|
+
import { resolve } from "node:path";
|
|
2
|
+
import { pathToFileURL } from "node:url";
|
|
3
|
+
import { createBunServer } from "@tschk/moonshine-deploy-bun";
|
|
4
|
+
import {
|
|
5
|
+
PUBLIC_DIR,
|
|
6
|
+
type MoonshineManifest,
|
|
7
|
+
type Renderer,
|
|
8
|
+
} from "@tschk/moonshine-framework";
|
|
9
|
+
import {
|
|
10
|
+
createRequestHandler,
|
|
11
|
+
type RouteModule,
|
|
12
|
+
} from "@tschk/moonshine-server";
|
|
13
|
+
import type { PreviewHandle } from "./preview";
|
|
14
|
+
|
|
15
|
+
export type NativePreviewOptions = {
|
|
16
|
+
projectDir: string;
|
|
17
|
+
manifestPath: string;
|
|
18
|
+
port?: number;
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
export async function startNativeServer(
|
|
22
|
+
options: NativePreviewOptions,
|
|
23
|
+
): Promise<PreviewHandle> {
|
|
24
|
+
const manifest = (await Bun.file(
|
|
25
|
+
options.manifestPath,
|
|
26
|
+
).json()) as MoonshineManifest;
|
|
27
|
+
const path = resolve(
|
|
28
|
+
options.projectDir,
|
|
29
|
+
".moonshine",
|
|
30
|
+
manifest.entries.server ?? "dist/server.js",
|
|
31
|
+
);
|
|
32
|
+
const bundle = (await import(pathToFileURL(path).href)) as {
|
|
33
|
+
modules?: Record<string, RouteModule>;
|
|
34
|
+
renderer?: Renderer;
|
|
35
|
+
requestScope?: Parameters<typeof createRequestHandler>[0]["requestScope"];
|
|
36
|
+
};
|
|
37
|
+
if (!bundle.renderer)
|
|
38
|
+
throw new Error(
|
|
39
|
+
"Native renderer missing from server bundle; rebuild the project",
|
|
40
|
+
);
|
|
41
|
+
if (manifest.requestContext && typeof bundle.requestScope !== "function")
|
|
42
|
+
throw new Error(
|
|
43
|
+
"Request context runner missing from server bundle; rebuild the project",
|
|
44
|
+
);
|
|
45
|
+
const staticDir = resolve(options.projectDir, ".moonshine", PUBLIC_DIR);
|
|
46
|
+
const makeHandler = manifest.dataRequests
|
|
47
|
+
? (await import("@tschk/moonshine-server/data-http")).createRequestHandler
|
|
48
|
+
: createRequestHandler;
|
|
49
|
+
const server = createBunServer({
|
|
50
|
+
fetch: makeHandler({
|
|
51
|
+
manifest,
|
|
52
|
+
modules: bundle.modules ?? {},
|
|
53
|
+
renderer: bundle.renderer,
|
|
54
|
+
...(manifest.requestContext ? { requestScope: bundle.requestScope } : {}),
|
|
55
|
+
staticDir,
|
|
56
|
+
}),
|
|
57
|
+
port: options.port ?? 0,
|
|
58
|
+
});
|
|
59
|
+
return {
|
|
60
|
+
url: server.url,
|
|
61
|
+
port: server.port,
|
|
62
|
+
stop: async () => {
|
|
63
|
+
await server.stop(true);
|
|
64
|
+
},
|
|
65
|
+
};
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
/** A fresh Bun process avoids both ESM and filesystem caches across rebuilds. */
|
|
69
|
+
export function startNativePreview(
|
|
70
|
+
options: NativePreviewOptions,
|
|
71
|
+
): Promise<PreviewHandle> {
|
|
72
|
+
return new Promise((resolveReady, reject) => {
|
|
73
|
+
let settled = false;
|
|
74
|
+
let stopping: Promise<void> | undefined;
|
|
75
|
+
let child: ReturnType<typeof Bun.spawn>;
|
|
76
|
+
const fail = (error: Error) => {
|
|
77
|
+
if (settled) return;
|
|
78
|
+
settled = true;
|
|
79
|
+
clearTimeout(timer);
|
|
80
|
+
child.kill("SIGKILL");
|
|
81
|
+
void child.exited.then(() => reject(error));
|
|
82
|
+
};
|
|
83
|
+
const timer = setTimeout(
|
|
84
|
+
() => fail(new Error("Native preview startup timed out")),
|
|
85
|
+
10_000,
|
|
86
|
+
);
|
|
87
|
+
try {
|
|
88
|
+
child = Bun.spawn(
|
|
89
|
+
[
|
|
90
|
+
process.execPath,
|
|
91
|
+
resolve(import.meta.dir, "preview-worker.ts"),
|
|
92
|
+
JSON.stringify(options),
|
|
93
|
+
],
|
|
94
|
+
{
|
|
95
|
+
stdout: "inherit",
|
|
96
|
+
stderr: "inherit",
|
|
97
|
+
ipc(message: unknown) {
|
|
98
|
+
if (settled || !message || typeof message !== "object") return;
|
|
99
|
+
if (
|
|
100
|
+
"type" in message &&
|
|
101
|
+
message.type === "moonshine:error" &&
|
|
102
|
+
"error" in message &&
|
|
103
|
+
typeof message.error === "string"
|
|
104
|
+
) {
|
|
105
|
+
fail(new Error(message.error));
|
|
106
|
+
} else if (
|
|
107
|
+
"type" in message &&
|
|
108
|
+
message.type === "moonshine:ready" &&
|
|
109
|
+
"url" in message &&
|
|
110
|
+
typeof message.url === "string"
|
|
111
|
+
) {
|
|
112
|
+
settled = true;
|
|
113
|
+
clearTimeout(timer);
|
|
114
|
+
const url = new URL(message.url);
|
|
115
|
+
resolveReady({
|
|
116
|
+
url,
|
|
117
|
+
port: Number(url.port),
|
|
118
|
+
stop: () =>
|
|
119
|
+
(stopping ??= (async () => {
|
|
120
|
+
if (child.exitCode !== null) return;
|
|
121
|
+
try {
|
|
122
|
+
child.send({ type: "moonshine:stop" });
|
|
123
|
+
} catch {
|
|
124
|
+
child.kill("SIGKILL");
|
|
125
|
+
}
|
|
126
|
+
const shutdownTimer = setTimeout(
|
|
127
|
+
() => child.kill("SIGKILL"),
|
|
128
|
+
1_000,
|
|
129
|
+
);
|
|
130
|
+
try {
|
|
131
|
+
await child.exited;
|
|
132
|
+
} finally {
|
|
133
|
+
clearTimeout(shutdownTimer);
|
|
134
|
+
}
|
|
135
|
+
})()),
|
|
136
|
+
});
|
|
137
|
+
}
|
|
138
|
+
},
|
|
139
|
+
},
|
|
140
|
+
);
|
|
141
|
+
void child.exited.then((code) =>
|
|
142
|
+
fail(new Error(`Native preview exited before readiness (${code})`)),
|
|
143
|
+
);
|
|
144
|
+
} catch (error) {
|
|
145
|
+
settled = true;
|
|
146
|
+
clearTimeout(timer);
|
|
147
|
+
reject(error);
|
|
148
|
+
}
|
|
149
|
+
});
|
|
150
|
+
}
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import { startNativeServer, type NativePreviewOptions } from "./preview-native";
|
|
2
|
+
import type { PreviewHandle } from "./preview";
|
|
3
|
+
|
|
4
|
+
let server: PreviewHandle | undefined;
|
|
5
|
+
let stopping: Promise<void> | undefined;
|
|
6
|
+
function stop(): Promise<void> {
|
|
7
|
+
return (stopping ??= (async () => {
|
|
8
|
+
await server?.stop();
|
|
9
|
+
process.exit(0);
|
|
10
|
+
})());
|
|
11
|
+
}
|
|
12
|
+
process.on("disconnect", () => {
|
|
13
|
+
void stop();
|
|
14
|
+
});
|
|
15
|
+
process.on("SIGTERM", () => {
|
|
16
|
+
void stop();
|
|
17
|
+
});
|
|
18
|
+
process.on("message", (message) => {
|
|
19
|
+
if (
|
|
20
|
+
message &&
|
|
21
|
+
typeof message === "object" &&
|
|
22
|
+
"type" in message &&
|
|
23
|
+
message.type === "moonshine:stop"
|
|
24
|
+
)
|
|
25
|
+
void stop();
|
|
26
|
+
});
|
|
27
|
+
try {
|
|
28
|
+
const options = JSON.parse(process.argv[2]!) as NativePreviewOptions;
|
|
29
|
+
server = await startNativeServer(options);
|
|
30
|
+
process.send?.({ type: "moonshine:ready", url: server.url.href });
|
|
31
|
+
} catch (error) {
|
|
32
|
+
process.send?.({
|
|
33
|
+
type: "moonshine:error",
|
|
34
|
+
error: error instanceof Error ? error.message : String(error),
|
|
35
|
+
});
|
|
36
|
+
await server?.stop();
|
|
37
|
+
process.exit(1);
|
|
38
|
+
}
|