@effindomv2/create-fui-as-app 0.1.3 → 0.1.5

package/dist/scripts/sync-templates.js

@@ -0,0 +1,297 @@
+import { cpSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const REPO_ROOT = resolve(PACKAGE_ROOT, "..", "..");
+const FUI_AS_ROOT = join(REPO_ROOT, "v2", "fui-as");
+const FUI_AS_TEMPLATES_ROOT = join(FUI_AS_ROOT, "templates");
+const TEMPLATES_ROOT = join(PACKAGE_ROOT, "build", "templates");
+const LEGACY_TEMPLATES_ROOT = join(PACKAGE_ROOT, "templates");
+function writeTextFile(filePath, contents) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, contents, "utf8");
+}
+function posixRelativeImport(fromFilePath, toFilePath) {
+    const fromDirectory = dirname(fromFilePath);
+    let specifier = relative(fromDirectory, toFilePath).replaceAll("\\", "/");
+    if (specifier.endsWith(".ts")) {
+        specifier = specifier.slice(0, -3);
+    }
+    if (!specifier.startsWith(".")) {
+        specifier = `./${specifier}`;
+    }
+    return specifier;
+}
+function rewriteSdkImportsInFile(filePath, templateSrcRoot) {
+    const original = readFileSync(filePath, "utf8");
+    const rewritten = original
+        .replace(/(['"])(?:\.\.\/)+src\/(Fui|FuiExports|FuiPrimitives|FuiBrowser)\1/g, (_full, quote, symbolName) => {
+        const targetPath = join(templateSrcRoot, "fui", `${symbolName}.ts`);
+        const relativeSpecifier = posixRelativeImport(filePath, targetPath);
+        return `${quote}${relativeSpecifier}${quote}`;
+    })
+        .replace(/(['"])(?:\.\.\/)+browser\/src\/(?:host-events|host-services)\1/g, '"@effindomv2/fui-as/browser"');
+    if (rewritten !== original) {
+        writeFileSync(filePath, rewritten, "utf8");
+    }
+}
+function walkFiles(root, callback) {
+    for (const entry of readdirSync(root)) {
+        const absolutePath = join(root, entry);
+        const stats = statSync(absolutePath);
+        if (stats.isDirectory()) {
+            walkFiles(absolutePath, callback);
+            continue;
+        }
+        callback(absolutePath);
+    }
+}
+function writeSharedSdkShims(templateRoot) {
+    const fuiRoot = join(templateRoot, "src", "fui");
+    writeTextFile(join(fuiRoot, "Fui.ts"), 'export * from "../../node_modules/@effindomv2/fui-as/src/Fui";\n');
+    writeTextFile(join(fuiRoot, "FuiExports.ts"), 'export * from "../../node_modules/@effindomv2/fui-as/src/FuiExports";\n');
+    writeTextFile(join(fuiRoot, "FuiPrimitives.ts"), 'export * from "../../node_modules/@effindomv2/fui-as/src/FuiPrimitives";\n');
+    writeTextFile(join(fuiRoot, "FuiBrowser.ts"), 'export * from "../../node_modules/@effindomv2/fui-as/browser/src/index";\n');
+}
+function writeAsconfig(templateRoot) {
+    writeTextFile(join(templateRoot, "asconfig.json"), JSON.stringify({
+        targets: {
+            debug: {
+                debug: true,
+                exportRuntime: true,
+                bindings: "esm",
+                outFile: "public/app.wasm",
+                sourceMap: true,
+                textFile: "public/app.wat",
+            },
+            release: {
+                exportRuntime: true,
+                bindings: "esm",
+                optimizeLevel: 3,
+                outFile: "public/app.wasm",
+                shrinkLevel: 1,
+                sourceMap: false,
+                textFile: "public/app.wat",
+            },
+        },
+        options: {
+            runtime: "stub",
+        },
+    }, null, 2) + "\n");
+}
+function writeTsconfig(templateRoot) {
+    writeTextFile(join(templateRoot, "tsconfig.json"), JSON.stringify({
+        extends: "assemblyscript/std/assembly.json",
+        compilerOptions: {
+            noEmit: true,
+        },
+        include: ["src/**/*.ts"],
+    }, null, 2) + "\n");
+}
+function writePackageJsonTemplate(templateRoot, scripts, description) {
+    writeTextFile(join(templateRoot, "package.json"), JSON.stringify({
+        name: "__PACKAGE_NAME__",
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        description,
+        scripts,
+        dependencies: {
+            "@effindomv2/fui-as": "__FUI_AS_VERSION__",
+            "@effindomv2/runtime": "__RUNTIME_VERSION__",
+        },
+        devDependencies: {
+            assemblyscript: "0.28.17",
+            "chokidar-cli": "^3.0.0",
+            concurrently: "^9.2.1",
+            esbuild: "^0.27.7",
+            "http-server": "^14.1.1",
+            tsx: "^4.20.6",
+        },
+    }, null, 2) + "\n");
+}
+function writeHelloSupportFiles(templateRoot) {
+    writeTextFile(join(templateRoot, "scripts", "prepare-runtime.ts"), `import { copyFileSync, cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+const outputDir = "public";
+rmSync(outputDir, { recursive: true, force: true });
+mkdirSync(\`\${outputDir}/runtime\`, { recursive: true });
+
+cpSync("node_modules/@effindomv2/runtime/dist", \`\${outputDir}/runtime/dist\`, { recursive: true });
+cpSync("node_modules/@effindomv2/runtime/dist/fonts", \`\${outputDir}/runtime/fonts\`, { recursive: true });
+copyFileSync("node_modules/@effindomv2/runtime/dist/bridge.js", \`\${outputDir}/bridge.js\`);
+if (existsSync("node_modules/@effindomv2/runtime/dist/bridge.js.map")) {
+  copyFileSync("node_modules/@effindomv2/runtime/dist/bridge.js.map", \`\${outputDir}/bridge.js.map\`);
+}
+writeFileSync(
+  \`\${outputDir}/effindom-runtime-config.js\`,
+  'window.__effindomRuntime = Object.assign({}, window.__effindomRuntime, { manifestUrl: "./runtime/dist/effindom.v2.manifest.json" });\\n',
+  "utf8",
+);
+copyFileSync("index.html", \`\${outputDir}/index.html\`);
+`);
+    writeTextFile(join(templateRoot, "scripts", "smoke.ts"), `import { accessSync } from "node:fs";
+
+const expectedFiles = [
+  "public/index.html",
+  "public/harness.js",
+  "public/app.wasm",
+  "public/bridge.js",
+  "public/effindom-runtime-config.js",
+  "public/runtime/dist/effindom.v2.manifest.json",
+  "public/runtime/fonts/NotoSans-Regular.ttf",
+];
+
+for (const filePath of expectedFiles) {
+  accessSync(filePath);
+}
+`);
+    writePackageJsonTemplate(templateRoot, {
+        build: "npm run generate:host && npm run build:assets && npm run build:wasm && npm run build:harness",
+        "build:assets": "tsx scripts/prepare-runtime.ts",
+        "build:wasm": "asc src/App.ts --config asconfig.json --target release",
+        "build:harness": "esbuild harness.ts --bundle --format=esm --platform=browser --outfile=public/harness.js",
+        "generate:host-services": "tsx ./node_modules/@effindomv2/fui-as/scripts/generate-host-services.ts src/host/host-services.ts appHostServices src/host/generated/HostServices.ts ../../fui/FuiPrimitives",
+        "generate:host-events": "tsx ./node_modules/@effindomv2/fui-as/scripts/generate-host-events.ts src/host/host-events.ts appHostEvents src/host/generated/HostEvents.ts ../../fui/FuiPrimitives",
+        "generate:host": "npm run generate:host-services && npm run generate:host-events",
+        watch: 'chokidar "src/**/*.ts" "harness.ts" "index.html" "asconfig.json" --ignore "src/host/generated/**" -c "npm run build"',
+        serve: "http-server public -p 8080 -c-1",
+        dev: 'npm run build && concurrently -k -n watch,serve "npm run watch" "npm run serve"',
+        test: "npm run build && tsx scripts/smoke.ts",
+    }, "Scaffolded FUI-AS hello-world app");
+}
+function writeMvcSupportFiles(templateRoot) {
+    writeTextFile(join(templateRoot, "index.html"), `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="refresh" content="0; url=/mvc-home/" />
+    <title>FUI-AS MVC App</title>
+  </head>
+  <body>
+    <p>Redirecting to <a href="/mvc-home/">/mvc-home/</a>…</p>
+  </body>
+</html>
+`);
+    writeTextFile(join(templateRoot, "scripts", "prepare-runtime.ts"), `import { copyFileSync, cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+
+const outputDir = "public";
+rmSync(outputDir, { recursive: true, force: true });
+mkdirSync(\`\${outputDir}/runtime\`, { recursive: true });
+mkdirSync(\`\${outputDir}/mvc-home\`, { recursive: true });
+mkdirSync(\`\${outputDir}/mvc-settings\`, { recursive: true });
+
+cpSync("node_modules/@effindomv2/runtime/dist", \`\${outputDir}/runtime/dist\`, { recursive: true });
+cpSync("node_modules/@effindomv2/runtime/dist/fonts", \`\${outputDir}/runtime/fonts\`, { recursive: true });
+copyFileSync("node_modules/@effindomv2/runtime/dist/bridge.js", \`\${outputDir}/bridge.js\`);
+if (existsSync("node_modules/@effindomv2/runtime/dist/bridge.js.map")) {
+  copyFileSync("node_modules/@effindomv2/runtime/dist/bridge.js.map", \`\${outputDir}/bridge.js.map\`);
+}
+writeFileSync(
+  \`\${outputDir}/effindom-runtime-config.js\`,
+  'window.__effindomRuntime = Object.assign({}, window.__effindomRuntime, { manifestUrl: "./runtime/dist/effindom.v2.manifest.json" });\\n',
+  "utf8",
+);
+copyFileSync("index.html", \`\${outputDir}/index.html\`);
+copyFileSync("route-shell.html", \`\${outputDir}/mvc-home/index.html\`);
+copyFileSync("route-shell.html", \`\${outputDir}/mvc-settings/index.html\`);
+`);
+    writeTextFile(join(templateRoot, "scripts", "smoke.ts"), `import { accessSync } from "node:fs";
+
+const expectedFiles = [
+  "public/index.html",
+  "public/harness.js",
+  "public/mvc-home/index.html",
+  "public/mvc-settings/index.html",
+  "public/mvc-home.wasm",
+  "public/mvc-settings.wasm",
+  "public/bridge.js",
+  "public/effindom-runtime-config.js",
+  "public/runtime/dist/effindom.v2.manifest.json",
+  "public/runtime/fonts/NotoSans-Regular.ttf",
+];
+
+for (const filePath of expectedFiles) {
+  accessSync(filePath);
+}
+`);
+    writePackageJsonTemplate(templateRoot, {
+        build: "npm run generate:host && npm run build:assets && npm run build:wasm && npm run build:harness",
+        "build:assets": "tsx scripts/prepare-runtime.ts",
+        "build:wasm": "npm run build:wasm:home && npm run build:wasm:settings",
+        "build:wasm:home": "asc src/routes/mvc_home.ts --config asconfig.json --target release --outFile public/mvc-home.wasm",
+        "build:wasm:settings": "asc src/routes/mvc_settings.ts --config asconfig.json --target release --outFile public/mvc-settings.wasm",
+        "build:harness": "esbuild harness.ts --bundle --format=esm --platform=browser --outfile=public/harness.js",
+        "generate:host-services": "tsx ./node_modules/@effindomv2/fui-as/scripts/generate-host-services.ts src/host/host-services.ts appHostServices src/host/generated/HostServices.ts ../../fui/FuiPrimitives",
+        "generate:host-events": "tsx ./node_modules/@effindomv2/fui-as/scripts/generate-host-events.ts src/host/host-events.ts appHostEvents src/host/generated/HostEvents.ts ../../fui/FuiPrimitives",
+        "generate:host": "npm run generate:host-services && npm run generate:host-events",
+        watch: 'chokidar "src/**/*.ts" "harness.ts" "route-shell.html" "index.html" "asconfig.json" --ignore "src/host/generated/**" -c "npm run build"',
+        serve: "http-server public -p 8080 -c-1",
+        dev: 'npm run build && concurrently -k -n watch,serve "npm run watch" "npm run serve"',
+        test: "npm run build && tsx scripts/smoke.ts",
+    }, "Scaffolded FUI-AS MVC app");
+}
+function rewriteHarnessImports(filePath) {
+    const original = readFileSync(filePath, "utf8");
+    const rewritten = original
+        .replace(/(['"])(?:\.\.\/)+browser\/src\/common-harness\1/g, '"@effindomv2/fui-as/browser"')
+        .replace(/(['"])(?:\.\.\/)+browser\/src\/routed-harness\1/g, '"@effindomv2/fui-as/browser"')
+        .replaceAll("?v=midnight-6", "");
+    if (rewritten !== original) {
+        writeFileSync(filePath, rewritten, "utf8");
+    }
+}
+function normalizeGeneratedHeader(filePath, label) {
+    const original = readFileSync(filePath, "utf8");
+    const rewritten = original.replace(/^\/\/ Generated by .*$/m, `// Generated from ${label}.`);
+    if (rewritten !== original) {
+        writeFileSync(filePath, rewritten, "utf8");
+    }
+}
+function syncHelloTemplate() {
+    const templateRoot = join(TEMPLATES_ROOT, "hello");
+    const templateSrcRoot = join(templateRoot, "src");
+    rmSync(templateRoot, { recursive: true, force: true });
+    const sourceRoot = join(FUI_AS_TEMPLATES_ROOT, "demo-hello-world");
+    cpSync(join(sourceRoot, "src"), templateSrcRoot, { recursive: true });
+    cpSync(join(sourceRoot, "harness.ts"), join(templateRoot, "harness.ts"));
+    cpSync(join(sourceRoot, "index.html"), join(templateRoot, "index.html"));
+    writeSharedSdkShims(templateRoot);
+    writeAsconfig(templateRoot);
+    writeTsconfig(templateRoot);
+    writeHelloSupportFiles(templateRoot);
+    walkFiles(templateSrcRoot, (filePath) => {
+        if (filePath.endsWith(".ts")) {
+            rewriteSdkImportsInFile(filePath, templateSrcRoot);
+        }
+    });
+    rewriteHarnessImports(join(templateRoot, "harness.ts"));
+    normalizeGeneratedHeader(join(templateSrcRoot, "host", "generated", "HostEvents.ts"), "the scaffold host-events definition");
+    normalizeGeneratedHeader(join(templateSrcRoot, "host", "generated", "HostServices.ts"), "the scaffold host-services definition");
+}
+function syncMvcTemplate() {
+    const templateRoot = join(TEMPLATES_ROOT, "mvc");
+    const templateSrcRoot = join(templateRoot, "src");
+    rmSync(templateRoot, { recursive: true, force: true });
+    const sourceRoot = join(FUI_AS_TEMPLATES_ROOT, "demo-mvc");
+    cpSync(join(sourceRoot, "src"), templateSrcRoot, { recursive: true });
+    cpSync(join(sourceRoot, "harness.ts"), join(templateRoot, "harness.ts"));
+    cpSync(join(sourceRoot, "route-shell.html"), join(templateRoot, "route-shell.html"));
+    writeSharedSdkShims(templateRoot);
+    writeAsconfig(templateRoot);
+    writeTsconfig(templateRoot);
+    writeMvcSupportFiles(templateRoot);
+    walkFiles(templateSrcRoot, (filePath) => {
+        if (filePath.endsWith(".ts")) {
+            rewriteSdkImportsInFile(filePath, templateSrcRoot);
+        }
+    });
+    rewriteHarnessImports(join(templateRoot, "harness.ts"));
+    normalizeGeneratedHeader(join(templateSrcRoot, "host", "generated", "HostEvents.ts"), "the scaffold host-events definition");
+    normalizeGeneratedHeader(join(templateSrcRoot, "host", "generated", "HostServices.ts"), "the scaffold host-services definition");
+}
+rmSync(TEMPLATES_ROOT, { recursive: true, force: true });
+rmSync(LEGACY_TEMPLATES_ROOT, { recursive: true, force: true });
+mkdirSync(TEMPLATES_ROOT, { recursive: true });
+syncHelloTemplate();
+syncMvcTemplate();

package/dist/src/scaffold.d.ts

@@ -1,6 +1,8 @@
+import { type TemplateName } from "./templates.js";
 export interface ScaffoldOptions {
     readonly targetDirectory: string;
     readonly projectName: string;
+    readonly template?: TemplateName;
 }
 export interface LoggerLike {
     log(message: string): void;

package/dist/src/scaffold.js

@@ -18,7 +18,7 @@ function assertDirectoryIsEmpty(targetDirectory) {
 }
 export function createProject(options) {
     assertDirectoryIsEmpty(options.targetDirectory);
-    const templateFiles = createTemplateFiles({
+    const templateFiles = createTemplateFiles(options.template ?? "hello", {
         projectName: options.projectName,
         packageName: normalizePackageName(options.projectName),
     });
@@ -28,10 +28,54 @@ export function createProject(options) {
         writeFileSync(absolutePath, contents, "utf8");
     }
 }
+function parseCliOptions(argv) {
+    let requestedPath = null;
+    let template = "hello";
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === "--template") {
+            const value = argv.at(index + 1);
+            if (value === undefined) {
+                return { requestedPath, template, error: "--template requires a value (hello or mvc)." };
+            }
+            if (value !== "hello" && value !== "mvc") {
+                return { requestedPath, template, error: `Unsupported template: ${value}` };
+            }
+            template = value;
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("--template=")) {
+            const value = argument.slice("--template=".length);
+            if (value !== "hello" && value !== "mvc") {
+                return { requestedPath, template, error: `Unsupported template: ${value}` };
+            }
+            template = value;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            return { requestedPath, template, error: `Unknown option: ${argument}` };
+        }
+        if (requestedPath !== null) {
+            return { requestedPath, template, error: `Unexpected argument: ${argument}` };
+        }
+        requestedPath = argument;
+    }
+    return { requestedPath, template, error: null };
+}
+function printUsage(logger) {
+    logger.error("Usage: create-fui-as-app <project-directory> [--template hello|mvc]");
+}
 export function runCli(argv, cwd, logger) {
-    const requestedPath = argv[0];
-    if (requestedPath === undefined || requestedPath.length === 0) {
-        logger.error("Usage: create-fui-as-app <project-directory>");
+    const parsed = parseCliOptions(argv);
+    if (parsed.error !== null) {
+        logger.error(parsed.error);
+        printUsage(logger);
+        return 1;
+    }
+    const requestedPath = parsed.requestedPath;
+    if (requestedPath === null || requestedPath.length === 0) {
+        printUsage(logger);
         return 1;
     }
     const targetDirectory = resolve(cwd, requestedPath);
@@ -40,13 +84,14 @@ export function runCli(argv, cwd, logger) {
         createProject({
             targetDirectory,
             projectName,
+            template: parsed.template,
         });
     }
     catch (error) {
         logger.error(error instanceof Error ? error.message : String(error));
         return 1;
     }
-    logger.log(`Created ${projectName} at ${targetDirectory}`);
+    logger.log(`Created ${projectName} (${parsed.template} template) at ${targetDirectory}`);
     logger.log("Next steps:");
     logger.log(`  cd ${requestedPath}`);
     logger.log("  npm install");

package/dist/src/templates.d.ts

@@ -1,5 +1,6 @@
+export type TemplateName = "hello" | "mvc";
 export interface TemplateContext {
     readonly projectName: string;
     readonly packageName: string;
 }
-export declare function createTemplateFiles(context: TemplateContext): Map<string, string>;
+export declare function createTemplateFiles(template: TemplateName, context: TemplateContext): Map<string, string>;

package/dist/src/templates.js

@@ -1,232 +1,43 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { FUI_AS_VERSION, RUNTIME_VERSION } from "./versions.js";
-function formatJson(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function renderPackageJson(context) {
-    return formatJson({
-        name: context.packageName,
-        version: "0.1.3",
-        private: true,
-        type: "module",
-        scripts: {
-            build: "npm run build:assets && npm run build:wasm && npm run build:harness",
-            "build:assets": "node scripts/prepare-runtime.mjs",
-            "build:wasm": "asc src/App.ts --config asconfig.json --target release",
-            "build:harness": "esbuild harness.ts --bundle --format=esm --platform=browser --outfile=public/harness.js",
-            watch: "chokidar \"src/**/*.ts\" \"harness.ts\" \"index.html\" \"asconfig.json\" -c \"npm run build\"",
-            serve: "http-server public -p 8080 -c-1",
-            dev: "npm run build && concurrently -k -n watch,serve \"npm run watch\" \"npm run serve\"",
-            test: "npm run build && node scripts/smoke.mjs"
-        },
-        dependencies: {
-            "@effindomv2/fui-as": FUI_AS_VERSION,
-            "@effindomv2/runtime": RUNTIME_VERSION
-        },
-        devDependencies: {
-            assemblyscript: "0.28.17",
-            "chokidar-cli": "^3.0.0",
-            concurrently: "^9.2.1",
-            esbuild: "^0.27.7",
-            "http-server": "^14.1.1"
+const TEMPLATE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "build", "templates");
+function collectTemplateFiles(root, relativePath = "") {
+    const absolutePath = resolve(root, relativePath);
+    const stats = statSync(absolutePath);
+    if (stats.isFile()) {
+        return new Map([[relativePath, readFileSync(absolutePath, "utf8")]]);
+    }
+    const output = new Map();
+    for (const entry of readdirSync(absolutePath)) {
+        const nestedRelativePath = relativePath.length === 0 ? entry : `${relativePath}/${entry}`;
+        const nestedAbsolutePath = resolve(root, nestedRelativePath);
+        const nestedStats = statSync(nestedAbsolutePath);
+        if (nestedStats.isDirectory()) {
+            const nestedFiles = collectTemplateFiles(root, nestedRelativePath);
+            for (const [filePath, contents] of nestedFiles) {
+                output.set(filePath, contents);
+            }
+            continue;
         }
-    });
-}
-const appTs = `import { Application } from "../node_modules/@effindomv2/fui-as/src/Fui";
-export * from "../node_modules/@effindomv2/fui-as/src/FuiExports";
-
-import { createHelloWorldPage } from "./HelloWorld";
-
-Application.register((app) => app.page(createHelloWorldPage));
-`;
-const helloWorldTs = `import {
-  AlignItems,
-  Button,
-  Column,
-  JustifyContent,
-  rgb,
-  SelectionArea,
-  Text,
-  TextAlign,
-  Unit,
-} from "../node_modules/@effindomv2/fui-as/src/Fui";
-
-class HelloWorld {
-  private clickCount: i32 = 0;
-  private readonly counterLabel: Text = new Text("Clicked 0 times");
-
-  constructor() {
-    this.counterLabel.fontSize(20.0);
-  }
-
-  buildPage(): SelectionArea {
-    const title = new Text("Hello world from FUI-AS")
-      .fontSize(36.0)
-      .textAlign(TextAlign.Center)
-      .width(100.0, Unit.Percent);
-
-    const subtitle = new Text("A tiny app in two files: App.ts + HelloWorld.ts")
-      .fontSize(16.0)
-      .textAlign(TextAlign.Center)
-      .width(100.0, Unit.Percent);
-
-    const button = new Button("Click me")
-      .margin(0.0, 18.0, 0.0, 12.0)
-      .onClickWith<HelloWorld>(this, (owner) => {
-        owner.clickCount += 1;
-        owner.counterLabel.text(
-          "Clicked " + owner.clickCount.toString() + " time" + (owner.clickCount == 1 ? "" : "s"),
-        );
-      });
-
-    const note = new Text(
-      "For production apps, move to an explicit MVC structure once screens, state, or host integration grows.",
-    )
-      .fontSize(14.0)
-      .textAlign(TextAlign.Center)
-      .width(680.0, Unit.Pixel);
-
-    return new SelectionArea()
-      .fillWidth()
-      .fillHeight()
-      .child(
-        Column(
-          title,
-          subtitle,
-          button,
-          this.counterLabel,
-          note,
-        )
-          .fillWidth()
-          .fillHeight()
-          .padding(24.0, 24.0, 24.0, 24.0)
-          .justifyContent(JustifyContent.Center)
-          .alignItems(AlignItems.Center),
-      )
-      .bgColor(rgb(0, 0, 0)) as SelectionArea;
-  }
-}
-
-export function createHelloWorldPage(): SelectionArea {
-  return new HelloWorld().buildPage();
-}
-`;
-const harnessTs = `import { startHarness } from "@effindomv2/fui-as/browser";
-
-startHarness({
-  wasmPath: "./app.wasm",
-});
-`;
-const indexHtml = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>FUI-AS Hello World</title>
-    <style>
-      html,
-      body {
-        width: 100%;
-        height: 100%;
-        margin: 0;
-        padding: 0;
-        overflow: hidden;
-        background: #0f172a;
-      }
-
-      [data-effindom-canvas-size-source] {
-        position: fixed;
-        inset: 0;
-      }
-
-      #fui-canvas {
-        display: block;
-        width: 100%;
-        height: 100%;
-      }
-    </style>
-  </head>
-  <body>
-    <main data-effindom-canvas-size-source>
-      <canvas id="fui-canvas"></canvas>
-    </main>
-    <script>
-      window.__effindomRuntime = Object.assign({}, window.__effindomRuntime, {
-        manifestUrl: "./runtime/dist/effindom.v2.manifest.json",
-      });
-    </script>
-    <script src="./runtime/dist/bridge.js"></script>
-    <script type="module" src="./harness.js"></script>
-  </body>
-</html>
-`;
-const asconfigJson = `{
-  "targets": {
-    "debug": {
-      "debug": true,
-      "exportRuntime": true,
-      "bindings": "esm",
-      "outFile": "public/app.wasm",
-      "sourceMap": true,
-      "textFile": "public/app.wat"
-    },
-    "release": {
-      "exportRuntime": true,
-      "bindings": "esm",
-      "optimizeLevel": 3,
-      "outFile": "public/app.wasm",
-      "shrinkLevel": 1,
-      "sourceMap": false,
-      "textFile": "public/app.wat"
+        output.set(nestedRelativePath, readFileSync(nestedAbsolutePath, "utf8"));
     }
-  },
-  "options": {
-    "runtime": "stub"
-  }
-}
-`;
-const tsconfigJson = `{
-  "extends": "assemblyscript/std/assembly.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": ["src/**/*.ts"]
-}
-`;
-const prepareRuntimeMjs = `import { copyFileSync, cpSync, mkdirSync, rmSync } from "node:fs";
-
-const outputDir = "public";
-rmSync(outputDir, { recursive: true, force: true });
-mkdirSync(\`\${outputDir}/runtime\`, { recursive: true });
-
-cpSync("node_modules/@effindomv2/runtime/dist", \`\${outputDir}/runtime/dist\`, { recursive: true });
-cpSync("node_modules/@effindomv2/runtime/dist/fonts", \`\${outputDir}/runtime/fonts\`, { recursive: true });
-copyFileSync("index.html", \`\${outputDir}/index.html\`);
-`;
-const smokeMjs = `import { accessSync } from "node:fs";
-
-const expectedFiles = [
-  "public/index.html",
-  "public/harness.js",
-  "public/app.wasm",
-  "public/runtime/dist/bridge.js",
-  "public/runtime/dist/effindom.v2.manifest.json",
-  "public/runtime/fonts/NotoSans-Regular.ttf",
-];
-
-for (const filePath of expectedFiles) {
-  accessSync(filePath);
-}
-`;
-export function createTemplateFiles(context) {
-    return new Map([
-        ["package.json", renderPackageJson(context)],
-        ["index.html", indexHtml],
-        ["asconfig.json", asconfigJson],
-        ["tsconfig.json", tsconfigJson],
-        ["harness.ts", harnessTs],
-        ["src/App.ts", appTs],
-        ["src/HelloWorld.ts", helloWorldTs],
-        ["scripts/prepare-runtime.mjs", prepareRuntimeMjs],
-        ["scripts/smoke.mjs", smokeMjs],
-    ]);
+    return output;
+}
+function replaceTemplateTokens(value, context) {
+    return value
+        .replaceAll("__PACKAGE_NAME__", context.packageName)
+        .replaceAll("__PROJECT_NAME__", context.projectName)
+        .replaceAll("__FUI_AS_VERSION__", FUI_AS_VERSION)
+        .replaceAll("__RUNTIME_VERSION__", RUNTIME_VERSION);
+}
+export function createTemplateFiles(template, context) {
+    const templateDirectory = resolve(TEMPLATE_ROOT, template);
+    const files = collectTemplateFiles(templateDirectory);
+    const output = new Map();
+    for (const [filePath, contents] of files) {
+        output.set(filePath, replaceTemplateTokens(contents, context));
+    }
+    return output;
 }

package/dist/src/versions.d.ts

@@ -1,2 +1,2 @@
-export declare const FUI_AS_VERSION = "0.1.1";
+export declare const FUI_AS_VERSION = "0.1.2";
 export declare const RUNTIME_VERSION = "0.1.0";