@vizejs/create-fresco 0.0.0-stage → 0.718.0

package/README.md

@@ -1,3 +1,24 @@
-# Temporary Holding Version
+# @vizejs/create-fresco
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Create a Vue SFC terminal app backed by `@vizejs/fresco`:
+
+```sh
+pnpm create @vizejs/fresco my-tui
+cd my-tui
+pnpm install
+pnpm dev
+```
+
+The generated project includes strict TypeScript, `vite-node --watch` development, a Node 22 Vite
+build, a controlled Fresco app lifecycle, and a small keyboard-driven SFC. The command never
+installs dependencies itself. It refuses a non-empty target by default; `--force` overwrites only
+the scaffold-owned paths and does not delete unrelated files.
+
+```text
+create-fresco [directory] [options]
+
+--package-manager, --pm <name>  npm, pnpm, yarn, or bun
+--force                        overwrite scaffold-owned files
+--help, -h                     show help
+--version, -v                  show version
+```

package/dist/cli.d.mts

@@ -0,0 +1,19 @@
+import { r as PackageManager } from "./types-gfBHsajB.mjs";
+
+//#region src/version.d.ts
+/** The checked-out or installed create-fresco package version. */
+declare const CREATE_FRESCO_VERSION: string;
+//#endregion
+//#region src/cli.d.ts
+interface CliOptions {
+  directory: string;
+  force: boolean;
+  packageManager?: PackageManager;
+  help: boolean;
+  version: boolean;
+}
+declare function parseCliArgs(args: readonly string[]): CliOptions;
+declare const helpText = "create-fresco [directory] [options]\n\nOptions:\n  --package-manager, --pm <name>  npm, pnpm, yarn, or bun\n  --force                        overwrite scaffold-owned files in a non-empty directory\n  --help, -h                     show this help\n  --version, -v                  show the package version";
+declare function runCli(args: readonly string[], output?: (message: string) => void): void;
+//#endregion
+export { CREATE_FRESCO_VERSION, CliOptions, helpText, parseCliArgs, runCli };

package/dist/cli.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { i as CREATE_FRESCO_VERSION, n as commandsFor, t as createFrescoProject } from "./scaffold-CuBjfy8n.mjs";
+import { pathToFileURL } from "node:url";
+//#region src/cli.ts
+const packageManagers = new Set([
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+]);
+function readPackageManager(value) {
+	if (value && packageManagers.has(value)) return value;
+	throw new Error(`CREATE_FRESCO_PACKAGE_MANAGER: expected npm, pnpm, yarn, or bun; received ${value ?? "nothing"}`);
+}
+function parseCliArgs(args) {
+	let directory;
+	let force = false;
+	let packageManager;
+	let help = false;
+	let version = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (argument === "--force") force = true;
+		else if (argument === "--help" || argument === "-h") help = true;
+		else if (argument === "--version" || argument === "-v") version = true;
+		else if (argument === "--package-manager" || argument === "--pm") {
+			packageManager = readPackageManager(args[index + 1]);
+			index += 1;
+		} else if (argument?.startsWith("--package-manager=") || argument?.startsWith("--pm=")) packageManager = readPackageManager(argument.slice(argument.indexOf("=") + 1));
+		else if (argument?.startsWith("-")) throw new Error(`CREATE_FRESCO_UNKNOWN_OPTION: ${argument}`);
+		else if (directory === void 0 && argument) directory = argument;
+		else if (argument) throw new Error(`CREATE_FRESCO_EXTRA_ARGUMENT: ${argument}`);
+	}
+	return {
+		directory: directory ?? "fresco-app",
+		force,
+		packageManager,
+		help,
+		version
+	};
+}
+const helpText = `create-fresco [directory] [options]
+
+Options:
+  --package-manager, --pm <name>  npm, pnpm, yarn, or bun
+  --force                        overwrite scaffold-owned files in a non-empty directory
+  --help, -h                     show this help
+  --version, -v                  show the package version`;
+function runCli(args, output = console.log) {
+	const options = parseCliArgs(args);
+	if (options.help) {
+		output(helpText);
+		return;
+	}
+	if (options.version) {
+		output(CREATE_FRESCO_VERSION);
+		return;
+	}
+	const result = createFrescoProject(options);
+	const commands = commandsFor(result.packageManager);
+	output(`Created ${result.packageName} in ${result.targetDirectory}`);
+	output(`\n  cd ${options.directory}\n  ${commands.install}\n  ${commands.dev}\n`);
+}
+const invokedPath = process.argv[1];
+if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) try {
+	runCli(process.argv.slice(2));
+} catch (error) {
+	console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+}
+//#endregion
+export { CREATE_FRESCO_VERSION, helpText, parseCliArgs, runCli };

package/dist/index.d.mts

@@ -0,0 +1,19 @@
+import { n as CreateFrescoProjectResult, r as PackageManager, t as CreateFrescoProjectOptions } from "./types-gfBHsajB.mjs";
+
+//#region src/scaffold.d.ts
+/** Create a project without installing dependencies or deleting unrelated files. */
+declare function createFrescoProject(options: CreateFrescoProjectOptions): CreateFrescoProjectResult;
+//#endregion
+//#region src/templates.d.ts
+interface ProjectTemplateOptions {
+  packageName: string;
+  packageManager: PackageManager;
+}
+/** Materialize every deterministic file in a new Fresco project. */
+declare function projectTemplates(options: ProjectTemplateOptions): ReadonlyMap<string, string>;
+declare function commandsFor(packageManager: PackageManager): {
+  install: string;
+  dev: string;
+};
+//#endregion
+export { type CreateFrescoProjectOptions, type CreateFrescoProjectResult, type PackageManager, type ProjectTemplateOptions, commandsFor, createFrescoProject, projectTemplates };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as commandsFor, r as projectTemplates, t as createFrescoProject } from "./scaffold-CuBjfy8n.mjs";
+export { commandsFor, createFrescoProject, projectTemplates };

package/dist/scaffold-CuBjfy8n.mjs

@@ -0,0 +1,235 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, parse, resolve } from "node:path";
+/** The checked-out or installed create-fresco package version. */
+const CREATE_FRESCO_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+//#endregion
+//#region src/templates.ts
+const packageManagerCommands = {
+	npm: {
+		install: "npm install",
+		run: (script) => `npm run ${script}`
+	},
+	pnpm: {
+		install: "pnpm install",
+		run: (script) => `pnpm ${script}`
+	},
+	yarn: {
+		install: "yarn",
+		run: (script) => `yarn ${script}`
+	},
+	bun: {
+		install: "bun install",
+		run: (script) => `bun run ${script}`
+	}
+};
+function projectPackageJson(packageName) {
+	return `${JSON.stringify({
+		name: packageName,
+		version: "0.0.0",
+		private: true,
+		type: "module",
+		scripts: {
+			dev: "vite-node --watch src/main.ts",
+			build: "vite build",
+			start: "node dist/main.mjs",
+			check: "vue-tsc --noEmit -p tsconfig.json"
+		},
+		dependencies: {
+			"@vizejs/fresco": `^${CREATE_FRESCO_VERSION}`,
+			vue: "^3.5.42"
+		},
+		devDependencies: {
+			"@vitejs/plugin-vue": "^6.0.7",
+			"@types/node": "^25.0.0",
+			typescript: "^6.0.3",
+			vite: "^8.2.4",
+			"vite-node": "^6.0.0",
+			"vue-tsc": "^3.3.11"
+		},
+		engines: { node: ">=22" }
+	}, null, 2)}\n`;
+}
+function projectReadme(options) {
+	const commands = packageManagerCommands[options.packageManager];
+	return `# ${options.packageName}
+
+A Vue-native terminal application built with [Fresco](https://github.com/ubugeeei-prod/vize).
+
+## Develop
+
+\`\`\`sh
+${commands.install}
+${commands.run("dev")}
+\`\`\`
+
+\`vite-node --watch\` reloads the SFC application when source files change. Press the arrow keys
+to update the counter and \`q\` to exit.
+
+## Check and build
+
+\`\`\`sh
+${commands.run("check")}
+${commands.run("build")}
+${commands.run("start")}
+\`\`\`
+
+The build produces one Node entry at \`dist/main.mjs\`. To use it as an executable launcher on
+macOS or Linux, prepend a Node shebang or invoke it from a small package \`bin\` entry. Fresco's
+platform-native addon remains an installed runtime dependency; this is intentionally not described
+as a static, dependency-free binary.
+`;
+}
+const appVue = `<script setup lang="ts">
+import { ref } from "vue";
+import { Box, Text, useApp, useInput } from "@vizejs/fresco";
+
+const count = ref(0);
+const { exit } = useApp();
+
+useInput({
+  onArrow(direction) {
+    if (direction === "up" || direction === "right") count.value += 1;
+    if (direction === "down" || direction === "left") count.value -= 1;
+  },
+  onChar(character) {
+    if (character === "q") exit();
+  },
+});
+<\/script>
+
+<template>
+  <Box flex-direction="column" :padding="1" border="rounded" border-color="cyan">
+    <Text :bold="true" fg="cyan">Fresco</Text>
+    <Text>Count: {{ count }}</Text>
+    <Text :dim="true">Use arrow keys; press q to exit.</Text>
+  </Box>
+</template>
+`;
+const mainTs = `import { createApp } from "@vizejs/fresco";
+import App from "./App.vue";
+
+const app = createApp(App, {
+  alternateScreen: true,
+  exitOnCtrlC: true,
+});
+
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.dispose(async () => {
+    await app.unmount();
+  });
+}
+
+try {
+  await app.mount();
+  await app.waitUntilExit();
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+}
+`;
+const viteConfig = `import vue from "@vitejs/plugin-vue";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [vue()],
+  build: {
+    ssr: "src/main.ts",
+    target: "node22",
+    outDir: "dist",
+    rollupOptions: {
+      external: ["@vizejs/fresco-native"],
+      output: {
+        entryFileNames: "main.mjs",
+      },
+    },
+  },
+});
+`;
+const tsconfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue", "vite.config.ts"]
+}
+`;
+const vueTypes = `/// <reference types="vite/client" />
+
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+  const component: DefineComponent<Record<string, never>, Record<string, never>, unknown>;
+  export default component;
+}
+`;
+/** Materialize every deterministic file in a new Fresco project. */
+function projectTemplates(options) {
+	return new Map([
+		[".gitignore", "node_modules\ndist\n*.log\n"],
+		["README.md", projectReadme(options)],
+		["package.json", projectPackageJson(options.packageName)],
+		["tsconfig.json", tsconfig],
+		["vite.config.ts", viteConfig],
+		["src/App.vue", appVue],
+		["src/env.d.ts", vueTypes],
+		["src/main.ts", mainTs]
+	]);
+}
+function commandsFor(packageManager) {
+	const commands = packageManagerCommands[packageManager];
+	return {
+		install: commands.install,
+		dev: commands.run("dev")
+	};
+}
+//#endregion
+//#region src/scaffold.ts
+function normalizedPackageName(directory) {
+	return basename(directory).toLowerCase().replaceAll(/[^a-z0-9._-]+/gu, "-").replaceAll(/^[._-]+|[._-]+$/gu, "") || "fresco-app";
+}
+function detectPackageManager(userAgent = process.env.npm_config_user_agent) {
+	const name = userAgent?.split("/")[0];
+	return name === "npm" || name === "pnpm" || name === "yarn" || name === "bun" ? name : "pnpm";
+}
+function assertSafeTarget(targetDirectory) {
+	if (targetDirectory === parse(targetDirectory).root) throw new Error("CREATE_FRESCO_UNSAFE_TARGET: refusing to scaffold into a filesystem root");
+	if (targetDirectory === homedir()) throw new Error("CREATE_FRESCO_UNSAFE_TARGET: refusing to scaffold into the home directory");
+	if (existsSync(targetDirectory) && !lstatSync(targetDirectory).isDirectory()) throw new Error(`CREATE_FRESCO_TARGET_FILE: ${targetDirectory} is not a directory`);
+}
+function assertWritableTarget(targetDirectory, force) {
+	if (!existsSync(targetDirectory)) return;
+	if (readdirSync(targetDirectory).length > 0 && !force) throw new Error(`CREATE_FRESCO_TARGET_NOT_EMPTY: ${targetDirectory} is not empty; pass --force to overwrite scaffold-owned files`);
+}
+/** Create a project without installing dependencies or deleting unrelated files. */
+function createFrescoProject(options) {
+	const targetDirectory = resolve(resolve(options.cwd ?? process.cwd()), options.directory);
+	const packageManager = options.packageManager ?? detectPackageManager();
+	const packageName = normalizedPackageName(targetDirectory);
+	const templates = projectTemplates({
+		packageName,
+		packageManager
+	});
+	assertSafeTarget(targetDirectory);
+	assertWritableTarget(targetDirectory, options.force === true);
+	mkdirSync(targetDirectory, { recursive: true });
+	for (const [relativePath, contents] of templates) {
+		const destination = resolve(targetDirectory, relativePath);
+		mkdirSync(dirname(destination), { recursive: true });
+		writeFileSync(destination, contents, "utf8");
+	}
+	return {
+		targetDirectory,
+		packageName,
+		packageManager,
+		files: [...templates.keys()]
+	};
+}
+//#endregion
+export { CREATE_FRESCO_VERSION as i, commandsFor as n, projectTemplates as r, createFrescoProject as t };

package/dist/types-gfBHsajB.d.mts

@@ -0,0 +1,16 @@
+//#region src/types.d.ts
+type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+interface CreateFrescoProjectOptions {
+  directory: string;
+  cwd?: string;
+  packageManager?: PackageManager;
+  force?: boolean;
+}
+interface CreateFrescoProjectResult {
+  targetDirectory: string;
+  packageName: string;
+  packageManager: PackageManager;
+  files: readonly string[];
+}
+//#endregion
+export { CreateFrescoProjectResult as n, PackageManager as r, CreateFrescoProjectOptions as t };

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@vizejs/create-fresco",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.718.0",
+  "description": "Create a Vue-native Fresco terminal application",
+  "keywords": [
+    "create",
+    "fresco",
+    "scaffold",
+    "terminal",
+    "tui",
+    "vue"
+  ],
+  "homepage": "https://github.com/ubugeeei-prod/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei-prod/vize/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei-prod/vize.git",
+    "directory": "npm/create-fresco"
+  },
+  "bin": {
+    "create-fresco": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "check": "vp check README.md package.json tsconfig.json src vite.config.ts && tsc --noEmit -p tsconfig.json",
+    "check:fix": "vp check --fix README.md package.json tsconfig.json src vite.config.ts",
+    "check:types": "tsc --noEmit -p tsconfig.json",
+    "fmt": "vp fmt --write README.md package.json tsconfig.json src vite.config.ts",
+    "test": "vp exec tsx --test src/**/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:typescript",
+    "tsx": "catalog:typescript",
+    "typescript": "catalog:typescript",
+    "vite-plus": "catalog:vite-stack"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "metadata": {
+    "vize": {
+      "stability": "experimental",
+      "stabilityDocs": "https://github.com/ubugeeei-prod/vize/blob/main/docs/content/stability.md#package-support-tiers"
+    }
+  }
+}