@effindomv2/create-fui-as-app 0.1.1

package/LICENSE.md

@@ -0,0 +1,6 @@
+`@effindomv2/create-fui-as-app` is licensed under the MIT License.
+
+See:
+
+- `../../LICENSE.md`
+- `../../LICENSES/MIT.md`

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runCli } from "./scaffold.js";
+const code = runCli(process.argv.slice(2), process.cwd(), console);
+if (code !== 0) {
+    process.exit(code);
+}

package/dist/src/scaffold.d.ts

@@ -0,0 +1,10 @@
+export interface ScaffoldOptions {
+    readonly targetDirectory: string;
+    readonly projectName: string;
+}
+export interface LoggerLike {
+    log(message: string): void;
+    error(message: string): void;
+}
+export declare function createProject(options: ScaffoldOptions): void;
+export declare function runCli(argv: readonly string[], cwd: string, logger: LoggerLike): number;

package/dist/src/scaffold.js

@@ -0,0 +1,55 @@
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { createTemplateFiles } from "./templates.js";
+function normalizePackageName(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "") || "fui-as-app";
+}
+function assertDirectoryIsEmpty(targetDirectory) {
+    mkdirSync(targetDirectory, { recursive: true });
+    const entries = readdirSync(targetDirectory);
+    if (entries.length > 0) {
+        throw new Error(`Target directory is not empty: ${targetDirectory}`);
+    }
+}
+export function createProject(options) {
+    assertDirectoryIsEmpty(options.targetDirectory);
+    const templateFiles = createTemplateFiles({
+        projectName: options.projectName,
+        packageName: normalizePackageName(options.projectName),
+    });
+    for (const [relativePath, contents] of templateFiles) {
+        const absolutePath = resolve(options.targetDirectory, relativePath);
+        mkdirSync(dirname(absolutePath), { recursive: true });
+        writeFileSync(absolutePath, contents, "utf8");
+    }
+}
+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>");
+        return 1;
+    }
+    const targetDirectory = resolve(cwd, requestedPath);
+    const projectName = requestedPath === "." ? "fui-as-app" : requestedPath;
+    try {
+        createProject({
+            targetDirectory,
+            projectName,
+        });
+    }
+    catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    logger.log(`Created ${projectName} at ${targetDirectory}`);
+    logger.log("Next steps:");
+    logger.log(`  cd ${requestedPath}`);
+    logger.log("  npm install");
+    logger.log("  npm run dev");
+    return 0;
+}

package/dist/src/templates.d.ts

@@ -0,0 +1,5 @@
+export interface TemplateContext {
+    readonly projectName: string;
+    readonly packageName: string;
+}
+export declare function createTemplateFiles(context: TemplateContext): Map<string, string>;

package/dist/src/templates.js

@@ -0,0 +1,230 @@
+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.1",
+        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 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 src="./effindom-runtime-config.js"></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"
+    }
+  },
+  "options": {
+    "runtime": "stub"
+  }
+}
+`;
+const tsconfigJson = `{
+  "extends": "assemblyscript/std/assembly.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"]
+}
+`;
+const prepareRuntimeMjs = `import { copyFileSync, cpSync, 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 });
+copyFileSync("index.html", \`\${outputDir}/index.html\`);
+
+const runtimeConfig = \`window.__effindomRuntime = Object.assign({}, window.__effindomRuntime, {\\\\n  manifestUrl: "./runtime/dist/effindom.v2.manifest.json",\\\\n});\\\\n\`;
+writeFileSync(\`\${outputDir}/effindom-runtime-config.js\`, runtimeConfig, "utf8");
+`;
+const smokeMjs = `import { accessSync } from "node:fs";
+
+const expectedFiles = [
+  "public/index.html",
+  "public/harness.js",
+  "public/app.wasm",
+  "public/effindom-runtime-config.js",
+  "public/runtime/dist/bridge.js",
+  "public/runtime/dist/effindom.v2.manifest.json",
+];
+
+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],
+    ]);
+}

package/dist/src/versions.d.ts

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

package/dist/src/versions.js

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

package/dist/tests/scaffold.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/scaffold.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import { createProject } from "../src/scaffold.js";
+test("createProject writes hello-world scaffold including AssemblyScript tsconfig", () => {
+    const root = mkdtempSync(join(tmpdir(), "create-fui-as-app-"));
+    const target = join(root, "my-app");
+    try {
+        createProject({
+            targetDirectory: target,
+            projectName: "my-app",
+        });
+        const tsconfig = JSON.parse(readFileSync(join(target, "tsconfig.json"), "utf8"));
+        assert.equal(tsconfig.extends, "assemblyscript/std/assembly.json");
+        assert.deepEqual(tsconfig.include, ["src/**/*.ts"]);
+        const packageJson = JSON.parse(readFileSync(join(target, "package.json"), "utf8"));
+        assert.equal(typeof packageJson.scripts.dev, "string");
+        assert.equal(typeof packageJson.scripts.build, "string");
+        assert.equal(typeof packageJson.scripts.test, "string");
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test("createProject fails on non-empty target directory", () => {
+    const root = mkdtempSync(join(tmpdir(), "create-fui-as-app-"));
+    const target = join(root, "existing-app");
+    try {
+        createProject({
+            targetDirectory: target,
+            projectName: "existing-app",
+        });
+        writeFileSync(join(target, "README.txt"), "occupied", "utf8");
+        assert.throws(() => createProject({
+            targetDirectory: target,
+            projectName: "existing-app",
+        }));
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@effindomv2/create-fui-as-app",
+  "version": "0.1.1",
+  "private": false,
+  "license": "MIT",
+  "description": "Scaffold a minimal EffinDom v2 FUI-AS app",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "create-fui-as-app": "./dist/src/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/scaffold.d.ts",
+      "default": "./dist/src/scaffold.js"
+    }
+  },
+  "main": "./dist/src/scaffold.js",
+  "types": "./dist/src/scaffold.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test dist/tests/**/*.test.js",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  }
+}