rowork 0.1.0

package/dist/commands/make-stat.js

@@ -0,0 +1,199 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { generateFile } from "../core/generate.js";
+import { addFieldToPlayerData, addToShownList } from "../core/schema-edit.js";
+import { installModule } from "../core/modules.js";
+import { playerDataModule } from "../modules/player-data.js";
+import { defineCommand } from "../plugins/api.js";
+import { defaultFor, toFieldName } from "../modules/player-data.js";
+import { listEvents } from "../core/project-index.js";
+import { answered, prompts, requireInteractive } from "../ui/prompt.js";
+import { askEventLink, createEventHandler, resolveEvent } from "./links.js";
+import { requireProject } from "./make.js";
+const ADD_METHOD = `
+	/** Adds to the player's \`{{ name }}\` (1 by default). Use a negative amount to subtract. */
+	add(player: Player, amount = 1): void {
+		this.playerData.update(player, (data) => {
+			data.{{ name }} += amount;
+			return data;
+		});
+	}
+`;
+const IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
+export const makeStatCommand = defineCommand({
+    name: "make:stat",
+    description: "Add a saved value (kills, coins...) to the player data, in every place it must be, and a service to use it.",
+    guided: true,
+    arguments: [{ name: "name", description: "the value, e.g. kills (omit it for the guided version)", required: false }],
+    options: [
+        { flags: "--type <type>", description: "number (default), string or boolean" },
+        { flags: "--default <value>", description: "starting value for a new player (default 0, empty, or false)" },
+        { flags: "--leaderboard", description: "show it in the leaderboard (default for numbers)" },
+        { flags: "--no-leaderboard", description: "do not show it in the leaderboard" },
+        { flags: "--service", description: "create the helper service (default for numbers)" },
+        { flags: "--no-service", description: "do not create the helper service" },
+        { flags: "--link <event>", description: "an existing event from the client that changes it, handled on the server" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "make:stat");
+        const installed = config.modules ?? [];
+        const missingModule = !installed.includes("player-data");
+        const given0 = context.args["name"];
+        if (missingModule && typeof given0 === "string") {
+            // Scripted: no question to ask. Say the one command that does both.
+            throw new RoworkError("There is no player data to add a value to.", {
+                hint: `Run \`rowork add:player-data --field ${given0}:number=0\`: it installs the saving and starts with that value.`,
+            });
+        }
+        const hasLeaderboard = installed.includes("leaderstats");
+        const given = context.args["name"];
+        let rawName;
+        let type = "number";
+        let rawDefault;
+        // A counter (kills, coins) is what a leaderboard and add/get/set are for: those
+        // are the defaults for numbers. Text and yes/no values get them only on request.
+        const wants = (option, fallback) => context.options[option] === undefined ? fallback : context.options[option] === true;
+        let leaderboard = false;
+        let service = false;
+        let linkTyped = typeof context.options["link"] === "string" ? context.options["link"] : undefined;
+        if (typeof given === "string") {
+            rawName = given;
+            const asked = context.options["type"];
+            if (asked !== undefined) {
+                if (asked !== "number" && asked !== "string" && asked !== "boolean") {
+                    throw new RoworkError(`Unknown type \`${String(asked)}\`.`, { hint: "Use number, string or boolean." });
+                }
+                type = asked;
+            }
+            rawDefault = typeof context.options["default"] === "string" ? context.options["default"] : undefined;
+            leaderboard = hasLeaderboard && wants("leaderboard", type === "number");
+            service = wants("service", type === "number");
+        }
+        else {
+            requireInteractive("make:stat", "rowork make:stat <name> --type number --default 0");
+            rawName = answered(await prompts.text({
+                message: "What do you want to save for each player? (anything you like, e.g. kills or best score)",
+                placeholder: "kills",
+                validate: (value) => (IDENTIFIER.test(toFieldName(value ?? "")) ? undefined : "Use letters and digits, starting with a letter."),
+            }));
+            type = answered(await prompts.select({
+                message: "What kind of value is it?",
+                options: [
+                    { value: "number", label: "Number", hint: "kills, coins, level" },
+                    { value: "string", label: "Text", hint: "a nickname, a title" },
+                    { value: "boolean", label: "Yes / no", hint: "has finished the tutorial" },
+                ],
+            }));
+            rawDefault = answered(await prompts.text({
+                message: "Starting value for a new player?",
+                placeholder: type === "number" ? "0" : type === "boolean" ? "false" : "",
+                defaultValue: "",
+            }));
+            if (hasLeaderboard) {
+                leaderboard = answered(await prompts.confirm({ message: "Show it in the leaderboard?", initialValue: type === "number" }));
+            }
+            service = answered(await prompts.confirm({ message: "Create a small service to read and change it (get, set, add)?", initialValue: type === "number" }));
+            // "Link it to...?": an existing event from the client that should change this value.
+            linkTyped = await askEventLink(root, config, "Should an existing event from the client change it? Type the event name.");
+        }
+        const name = toFieldName(rawName);
+        if (!IDENTIFIER.test(name)) {
+            throw new RoworkError(`\`${rawName}\` cannot be used as a name.`, {
+                hint: "Use letters and digits, starting with a letter: kills, bestScore.",
+            });
+        }
+        const defaultValue = defaultFor(type, rawDefault);
+        const className = `${name.charAt(0).toUpperCase()}${name.slice(1)}Service`;
+        // A link is checked before anything is written.
+        const linkEvent = linkTyped === undefined ? undefined : resolveEvent(listEvents(root, config), linkTyped);
+        const linkNow = () => {
+            if (linkEvent === undefined)
+                return;
+            const handler = createEventHandler({ root, config, event: { name: linkEvent.name }, stat: { name, type } });
+            context.logger.step(`${handler.path}: runs on the server when \`${linkEvent.name}\` arrives, linked to \`${name}\``);
+            context.logger.info("It decides the amount on the server: do not use a number the client sent.");
+        };
+        if (linkEvent !== undefined && existsAt(root, join(config.paths.services, `${linkEvent.name.charAt(0).toUpperCase()}${linkEvent.name.slice(1)}Handler.ts`))) {
+            throw new RoworkError(`A handler for \`${linkEvent.name}\` already exists.`, {
+                hint: "An event is handled in one place. Open that file to change what it does.",
+            });
+        }
+        const createService = () => {
+            const written = generateFile({
+                projectRoot: root,
+                directory: config.paths.services,
+                fileName: `${className}.ts`,
+                template: "stat-service",
+                variables: { name, type, className, extra: type === "number" ? ADD_METHOD.replaceAll("{{ name }}", name) : "" },
+                force: false,
+            });
+            if (written !== undefined)
+                context.logger.step(written);
+        };
+        // Guided and nothing saves values yet: offer to install what does, starting with this value.
+        if (missingModule) {
+            const proceed = answered(await prompts.confirm({
+                message: `Saving values needs the Player data module, which is not installed. Add it now, starting with \`${name}\`?`,
+                initialValue: true,
+            }));
+            if (!proceed) {
+                prompts.cancel("Nothing changed.");
+                return;
+            }
+            await installModule({ ...context, options: { field: [`${name}:${type}=${rawDefault ?? ""}`] } }, playerDataModule, root, false);
+            if (service)
+                createService();
+            linkNow();
+            return;
+        }
+        // ---- every edit is computed in memory first: nothing is written unless all of them work
+        const dataFile = `${config.paths.shared}/data/PlayerData.ts`;
+        const dataPath = resolveProjectPath(root, dataFile);
+        let dataSource;
+        try {
+            dataSource = readFileSync(dataPath, "utf8");
+        }
+        catch {
+            throw new RoworkError(`Cannot read ${dataFile}.`, { hint: "It is created by `rowork add:player-data`." });
+        }
+        const newData = addFieldToPlayerData(dataSource, dataFile, { name, type, defaultValue });
+        let newShown;
+        if (leaderboard) {
+            const shownFile = `${config.paths.services}/LeaderstatsService.ts`;
+            const shownPath = resolveProjectPath(root, shownFile);
+            newShown = { path: shownPath, source: addToShownList(readFileSync(shownPath, "utf8"), shownFile, name) };
+        }
+        const servicePath = join(config.paths.services, `${className}.ts`);
+        if (service && existsAt(root, servicePath)) {
+            throw new RoworkError(`${servicePath} already exists.`, { hint: "Pick another name, or use --no-service." });
+        }
+        // ---- write
+        writeFileSync(dataPath, newData, "utf8");
+        context.logger.step(`${dataFile}: added \`${name}: ${type}\` and its starting value`);
+        if (newShown !== undefined) {
+            writeFileSync(newShown.path, newShown.source, "utf8");
+            context.logger.step(`${config.paths.services}/LeaderstatsService.ts: added to the leaderboard`);
+        }
+        if (service)
+            createService();
+        linkNow();
+        context.logger.success(`Saved \`${name}\` for every player.`);
+        context.logger.blank();
+        context.logger.info("Players who already have a save get the starting value the next time they join.");
+        if (service) {
+            context.logger.info(`Use it from any service:  constructor(private readonly ${name}: ${className}) {}   then   this.${name}.${type === "number" ? "add(player)" : "set(player, value)"}`);
+        }
+    },
+});
+function existsAt(root, relativePath) {
+    try {
+        readFileSync(resolveProjectPath(root, relativePath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=make-stat.js.map

package/dist/commands/make-tool.d.ts

@@ -0,0 +1,2 @@
+export declare const makeToolCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=make-tool.d.ts.map

package/dist/commands/make-tool.js

@@ -0,0 +1,124 @@
+import { join } from "node:path";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { ensureFlameworkPath, generateFile, importPath, toClassBase, writeToolRegistry, } from "../core/generate.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, prompts } from "../ui/prompt.js";
+import { nameOrAsk, requireProject } from "./make.js";
+function parseCooldown(value) {
+    const number = Number(value.replace(",", "."));
+    return value.trim() !== "" && Number.isFinite(number) && number >= 0 && number <= 3600
+        ? number
+        : undefined;
+}
+async function askSettings() {
+    const cooldown = answered(await prompts.text({
+        message: "Seconds to wait between two uses?",
+        placeholder: "0.5",
+        defaultValue: "0.5",
+        validate: (value) => parseCooldown(value || "0.5") === undefined ? "A number between 0 and 3600." : undefined,
+    }));
+    const canBeDropped = answered(await prompts.confirm({ message: "Can the player drop it on the ground?", initialValue: false }));
+    const giveOnSpawn = answered(await prompts.confirm({
+        message: "Give it to every player when they spawn?",
+        initialValue: true,
+    }));
+    return { cooldown: parseCooldown(cooldown || "0.5") ?? 0.5, canBeDropped, giveOnSpawn };
+}
+function settingsFromOptions(context) {
+    const raw = context.options["cooldown"];
+    const cooldown = typeof raw === "string" ? parseCooldown(raw) : 0.5;
+    if (cooldown === undefined) {
+        throw new RoworkError(`\`${String(raw)}\` is not a valid cooldown.`, {
+            hint: "Use a number of seconds between 0 and 3600, e.g. --cooldown 0.5",
+        });
+    }
+    return {
+        cooldown,
+        canBeDropped: context.options["droppable"] === true,
+        giveOnSpawn: context.options["giveOnSpawn"] !== false,
+    };
+}
+export const makeToolCommand = defineCommand({
+    name: "make:tool",
+    guided: true,
+    description: "Create a tool players hold: settings, behaviour, and automatic delivery.",
+    arguments: [
+        {
+            name: "name",
+            description: "name of the tool, e.g. Pickaxe (omit it for the guided version)",
+            required: false,
+        },
+    ],
+    options: [
+        { flags: "--cooldown <seconds>", description: "seconds between two uses (default 0.5)" },
+        { flags: "--droppable", description: "the player can drop it" },
+        { flags: "--no-give-on-spawn", description: "do not give it to players automatically" },
+        { flags: "-f, --force", description: "overwrite the tool's own files if they exist" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "make:tool");
+        const { name, guided } = await nameOrAsk(context, "make:tool", "What is the tool called?", "Pickaxe");
+        const settings = guided ? await askSettings() : settingsFromOptions(context);
+        // `Pickaxe` and `PickaxeTool` both mean the same tool.
+        const base = toClassBase(name).replace(/(?<=.)Tool$/, "");
+        const constName = `${base}Tool`;
+        const force = context.options["force"] === true;
+        const sharedDirectory = `${config.paths.shared}/tools`;
+        const componentsDirectory = `${config.paths.source}/server/components`;
+        const servicesDirectory = config.paths.services;
+        const created = [];
+        const write = (directory, fileName, template, variables, own) => {
+            const written = generateFile({
+                projectRoot: root,
+                directory,
+                fileName,
+                template,
+                variables,
+                force: own && force,
+                ifExists: own ? "fail" : "skip",
+            });
+            if (written !== undefined)
+                created.push(written);
+        };
+        // Shared files first, created once and never overwritten: a failure on
+        // the tool's own files then leaves nothing harmful behind.
+        write(sharedDirectory, "ToolDefinition.ts", "tool-definition", {}, false);
+        write(servicesDirectory, "ToolService.ts", "tool-service", {
+            definitionImport: importPath(root, servicesDirectory, `${sharedDirectory}/ToolDefinition`),
+            registryImport: importPath(root, servicesDirectory, `${sharedDirectory}/index`),
+        }, false);
+        write(sharedDirectory, `${constName}.ts`, "tool-config", {
+            constName,
+            base,
+            tag: constName,
+            cooldown: String(settings.cooldown),
+            canBeDropped: String(settings.canBeDropped),
+            giveOnSpawn: String(settings.giveOnSpawn),
+        }, true);
+        write(componentsDirectory, `${constName}Component.ts`, "tool-component", {
+            constName,
+            base,
+            tag: constName,
+            className: `${constName}Component`,
+            configImport: importPath(root, componentsDirectory, `${sharedDirectory}/${constName}`),
+        }, true);
+        writeToolRegistry(root, sharedDirectory);
+        const runtime = resolveProjectPath(root, join(config.paths.source, "server", "runtime.server.ts"));
+        for (const directory of [servicesDirectory, componentsDirectory]) {
+            if (ensureFlameworkPath(runtime, directory, context.logger)) {
+                context.logger.step(`registered ${directory} in runtime.server.ts`);
+            }
+        }
+        for (const file of created)
+            context.logger.step(file);
+        context.logger.success(`Created tool ${base}`);
+        context.logger.blank();
+        context.logger.info(settings.giveOnSpawn
+            ? `Every player gets the ${base} when they spawn.`
+            : `The ${base} is not given automatically: settings are in ${sharedDirectory}/${constName}.ts.`);
+        context.logger.info(`Write what it does in ${componentsDirectory}/${constName}Component.ts (activate).`);
+        context.logger.info(`Change its settings later in ${sharedDirectory}/${constName}.ts.`);
+    },
+});
+//# sourceMappingURL=make-tool.js.map

package/dist/commands/make-ui.d.ts

@@ -0,0 +1,3 @@
+export declare const makeScreenCommand: import("../plugins/api.js").CommandDefinition;
+export declare const makeUiCommand: import("../plugins/api.js").CommandDefinition;
+//# sourceMappingURL=make-ui.d.ts.map

package/dist/commands/make-ui.js

@@ -0,0 +1,199 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { RoworkError } from "../cli/errors.js";
+import { resolveProjectPath } from "../core/config.js";
+import { formatGenerated } from "../core/format-generated.js";
+import { generateFile, toClassBase } from "../core/generate.js";
+import { installModule } from "../core/modules.js";
+import { ELEMENTS_MARKER, addElementToScreen, addScreenToApp, listScreens, screensDirectory, screensSupported, uiDirectory, } from "../core/ui-edit.js";
+import { uiModule } from "../modules/ui.js";
+import { defineCommand } from "../plugins/api.js";
+import { answered, prompts } from "../ui/prompt.js";
+import { nameOrAsk, requireProject } from "./make.js";
+const NAME_ARGUMENT = { name: "name", description: "the name, e.g. Shop (omit it for the guided version)", required: false };
+function read(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Makes sure the project has an interface that screens can be added to. Guided, a missing
+ * `ui` module is offered and installed on the spot; scripted, the one command that fixes it
+ * is printed. A project whose interface predates screens is told exactly what to change.
+ */
+async function ensureInterface(context, root, config, guided, command) {
+    if (!(config.modules ?? []).includes("ui")) {
+        if (!guided) {
+            throw new RoworkError("There is no interface to add this to.", { hint: "Run `rowork add:ui` first, then try again." });
+        }
+        const proceed = answered(await prompts.confirm({ message: "Your project has no interface yet. Add the UI module (React) now?", initialValue: true }));
+        if (!proceed) {
+            prompts.cancel("Nothing changed.");
+            process.exit(0);
+        }
+        await installModule({ ...context, options: {} }, uiModule, root, false);
+        return;
+    }
+    const state = screensSupported(root, config, read);
+    if (!state.ok) {
+        throw new RoworkError(`This project's interface predates screens: ${state.reason}.`, {
+            hint: [
+                `\`rowork ${command}\` adds to two files, and needs them to look like a new project's:`,
+                "  - UiController.tsx draws with:  createRoot(new Instance(\"Folder\")).render(createPortal(<App />, playerGui));   (import createPortal from \"@rbxts/react-roblox\")",
+                "  - App.tsx returns a fragment listing the screens, with a `{/* rowork:screens */}` line after them.",
+                "See docs/modules.md, section \"User interface\", for the full example.",
+            ].join("\n      "),
+        });
+    }
+}
+export const makeScreenCommand = defineCommand({
+    name: "make:screen",
+    description: "Create a screen (a ScreenGui) and show it from App, ready to fill with elements.",
+    guided: true,
+    arguments: [NAME_ARGUMENT],
+    async run(context) {
+        const { root, config } = requireProject(context, "make:screen");
+        const { name: typed, guided } = await nameOrAsk(context, "make:screen", "What is the screen called? (e.g. Shop, Inventory, Settings)", "Shop");
+        const base = toClassBase(typed);
+        const screenName = base.endsWith("Screen") && base.length > "Screen".length ? base.slice(0, -"Screen".length) : base;
+        const className = `${screenName}Screen`;
+        await ensureInterface(context, root, config, guided, "make:screen");
+        const screenFile = `${screensDirectory(config)}/${className}.tsx`;
+        if (existsSync(resolveProjectPath(root, screenFile))) {
+            throw new RoworkError(`${screenFile} already exists.`, {
+                hint: "Pick another name. To start this screen again, delete the file and its line in App.tsx.",
+            });
+        }
+        // Computed before anything is written: a refusal leaves the project as it was.
+        const appFile = `${uiDirectory(config)}/App.tsx`;
+        const appPath = resolveProjectPath(root, appFile);
+        const appSource = read(appPath);
+        if (appSource === undefined)
+            throw new RoworkError(`Cannot read ${appFile}.`, { hint: "It is created by `rowork add:ui`." });
+        const newApp = addScreenToApp(appSource, appFile, className, `./screens/${className}`);
+        const written = generateFile({
+            projectRoot: root,
+            directory: screensDirectory(config),
+            fileName: `${className}.tsx`,
+            template: "screen.tsx",
+            variables: { name: screenName, className, elementsMarker: ELEMENTS_MARKER },
+            force: false,
+        });
+        writeFileSync(appPath, newApp, "utf8");
+        await formatGenerated(root, [appPath, resolveProjectPath(root, screenFile)], context.logger);
+        context.logger.success(`Created the ${screenName} screen (${written ?? screenFile})`);
+        context.logger.step(`${appFile}: shows <${className} />`);
+        context.logger.blank();
+        context.logger.info("Press Play in Studio: a placeholder title shows at the top of the screen, delete it when you add your own.");
+        context.logger.info(`Add things to it:  rowork make:ui <name> --in ${screenName}`);
+    },
+});
+const KINDS = {
+    button: { label: "Button", hint: "text and a click", controls: '{ text: "Click me" }', binding: "text={props.controls.text}" },
+    label: { label: "Text", hint: "a piece of text", controls: '{ text: "Hello" }', binding: "text={props.controls.text}" },
+    panel: { label: "Panel", hint: "a rounded box with a title, that holds other elements", controls: '{ title: "Panel" }', binding: "title={props.controls.title}" },
+    image: { label: "Image", hint: "a picture (upload files with `rowork assets`)", controls: '{ image: "" }', binding: "image={props.controls.image}" },
+};
+export const makeUiCommand = defineCommand({
+    name: "make:ui",
+    description: "Create a reusable interface element (button, text, panel, image) with its Studio preview, and place it in a screen.",
+    guided: true,
+    arguments: [NAME_ARGUMENT],
+    options: [
+        { flags: "--kind <kind>", description: "button (default), label, panel or image" },
+        { flags: "--in <screen>", description: "place it in this screen, e.g. Home (see the screens in the ui folder)" },
+    ],
+    async run(context) {
+        const { root, config } = requireProject(context, "make:ui");
+        const { name: typed, guided } = await nameOrAsk(context, "make:ui", "What is the element called? (e.g. HealthBar, ShopButton)", "ShopButton");
+        const name = toClassBase(typed);
+        let kind = "button";
+        const askedKind = context.options["kind"];
+        if (typeof askedKind === "string") {
+            if (!(askedKind in KINDS)) {
+                throw new RoworkError(`Unknown kind \`${askedKind}\`.`, { hint: "Use button, label, panel or image." });
+            }
+            kind = askedKind;
+        }
+        else if (guided) {
+            kind = answered(await prompts.select({
+                message: "What kind of element is it?",
+                options: Object.keys(KINDS).map((value) => ({ value, label: KINDS[value].label, hint: KINDS[value].hint })),
+            }));
+        }
+        await ensureInterface(context, root, config, guided, "make:ui");
+        // "Place it in...?": a screen to put it in, so it shows up without editing anything.
+        const screens = listScreens(root, config);
+        let placeIn;
+        if (typeof context.options["in"] === "string") {
+            const wanted = context.options["in"];
+            placeIn = screens.find((screen) => screen.toLowerCase() === wanted.replace(/Screen$/i, "").toLowerCase());
+            if (placeIn === undefined) {
+                throw new RoworkError(`There is no screen called \`${wanted}\`.`, {
+                    hint: screens.length === 0 ? "Create one with `rowork make:screen <name>`." : `Screens: ${screens.join(", ")}.`,
+                });
+            }
+        }
+        else if (guided && screens.length > 0) {
+            const chosen = answered(await prompts.select({
+                message: "Put it in a screen now?",
+                options: [
+                    ...screens.map((screen) => ({ value: screen, label: screen })),
+                    { value: "", label: "Not yet", hint: "just create it, I will place it myself" },
+                ],
+            }));
+            placeIn = chosen === "" ? undefined : chosen;
+        }
+        const uiDir = uiDirectory(config);
+        const componentFile = `${uiDir}/${name}.tsx`;
+        const storyFile = `${uiDir}/${name}.story.tsx`;
+        for (const file of [componentFile, storyFile]) {
+            if (existsSync(resolveProjectPath(root, file))) {
+                throw new RoworkError(`${file} already exists.`, { hint: "Pick another name." });
+            }
+        }
+        // The screen edit is computed first, so a refusal leaves the project as it was.
+        let screenEdit;
+        if (placeIn !== undefined) {
+            const file = `${screensDirectory(config)}/${placeIn}Screen.tsx`;
+            const path = resolveProjectPath(root, file);
+            const source = read(path);
+            if (source === undefined)
+                throw new RoworkError(`Cannot read ${file}.`);
+            screenEdit = { path, file, source: addElementToScreen(source, file, name, `../${name}`) };
+        }
+        const written = generateFile({
+            projectRoot: root,
+            directory: uiDir,
+            fileName: `${name}.tsx`,
+            template: `ui-${kind}.tsx`,
+            variables: { name },
+            force: false,
+        });
+        const story = generateFile({
+            projectRoot: root,
+            directory: uiDir,
+            fileName: `${name}.story.tsx`,
+            template: "ui-story.tsx",
+            variables: { name, controls: KINDS[kind].controls, binding: KINDS[kind].binding },
+            force: false,
+        });
+        if (screenEdit !== undefined)
+            writeFileSync(screenEdit.path, screenEdit.source, "utf8");
+        await formatGenerated(root, [resolveProjectPath(root, componentFile), resolveProjectPath(root, storyFile), ...(screenEdit === undefined ? [] : [screenEdit.path])], context.logger);
+        context.logger.success(`Created ${KINDS[kind].label.toLowerCase()} ${name} (${written ?? componentFile})`);
+        context.logger.step(`${story ?? storyFile}: its preview for the UI Labs plugin in Studio`);
+        if (screenEdit !== undefined) {
+            context.logger.step(`${screenEdit.file}: places <${name} />`);
+            context.logger.blank();
+            context.logger.info("Press Play in Studio to see it.");
+        }
+        else {
+            context.logger.blank();
+            context.logger.info(`It is not shown anywhere yet. Place it in a screen with  rowork make:ui ${name} --in <screen>  (or write <${name} /> in a screen yourself).`);
+        }
+    },
+});
+//# sourceMappingURL=make-ui.js.map

package/dist/commands/make.d.ts

@@ -0,0 +1,21 @@
+import { type CommandContext, type CommandDefinition, type RoworkConfig } from "../plugins/api.js";
+export type Side = "server" | "client";
+export declare function requireProject(context: CommandContext, command: string): {
+    root: string;
+    config: RoworkConfig;
+};
+/** Validates a name typed in a prompt, using the same rules as the command line. */
+export declare function validateName(value: string | undefined): string | undefined;
+/**
+ * The name from the command line, or, in a terminal with none given, from a
+ * question. `undefined` guided means the caller should also ask its other
+ * questions.
+ */
+export declare function nameOrAsk(context: CommandContext, command: string, message: string, placeholder: string): Promise<{
+    name: string;
+    guided: boolean;
+}>;
+export declare const makeServiceCommand: CommandDefinition;
+export declare const makeControllerCommand: CommandDefinition;
+export declare const makeComponentCommand: CommandDefinition;
+//# sourceMappingURL=make.d.ts.map