@vlandoss/starter 0.0.13 → 0.0.15-git-9445806.0

package/dist/bin.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import { createPkgService, createShellService, cwd, getVersion, palette, run } from "@vlandoss/clibuddy";
+import { Argument, Command, Option, createCommand } from "commander";
+import fs from "node:fs";
+import { join } from "node:path";
+import { createLoggy } from "@vlandoss/loggy";
+import nodePlop from "node-plop";
+//#region src/services/config.ts
+var ConfigService = class {
+	#baseDir;
+	constructor(baseDir = "") {
+		this.#baseDir = baseDir;
+	}
+	getPluginChoices() {
+		const folderPath = this.#getPlopFolderDir("plugins");
+		return fs.readdirSync(folderPath).sort();
+	}
+	getTemplateChoices() {
+		const folderPath = this.#getPlopFolderDir("templates");
+		return fs.readdirSync(folderPath).filter((folder) => !folder.startsWith("#")).sort();
+	}
+	#getPlopFolderDir(folder) {
+		return join(this.#baseDir, join("plopfiles", folder));
+	}
+};
+//#endregion
+//#region src/services/logger.ts
+const logger = createLoggy({ namespace: "vland" });
+//#endregion
+//#region src/services/ctx.ts
+async function createContext(binDir) {
+	const debug = logger.subdebug("create-context-value");
+	const binPath = fs.realpathSync(binDir);
+	debug("bin path %s", binPath);
+	const binPkg = await createPkgService(binPath);
+	if (!binPkg) throw new Error("Could not find bin package.json");
+	debug("bin pkg info %O", binPkg.info());
+	return {
+		binPkg,
+		config: new ConfigService(binDir),
+		shell: createShellService({ localBaseBinPath: [binDir] })
+	};
+}
+//#endregion
+//#region src/actions/add.ts
+const GENERATOR_ID$1 = "add";
+var AddAction = class {
+	#templateService;
+	constructor({ templateService }) {
+		this.#templateService = templateService;
+	}
+	async execute(options) {
+		logger.subdebug("add-action")("execute options: %O", options);
+		const bypassArr = this.#getBypassArr(options);
+		await this.#templateService.generate({
+			bypassArr,
+			generatorId: GENERATOR_ID$1
+		});
+		logger.success("Added successfully 🎉");
+	}
+	#getBypassArr(options) {
+		const { slugs } = options;
+		const bypassArr = [];
+		if (slugs.length) bypassArr[0] = slugs.join(",");
+		return bypassArr;
+	}
+};
+//#endregion
+//#region src/services/template.ts
+var PlopTemplateService = class {
+	#plop;
+	constructor(plop) {
+		this.#plop = plop;
+	}
+	async generate(options) {
+		const { generatorId, bypassArr } = options;
+		const debug = logger.subdebug("plop-template-service:generate");
+		debug("generate options: %O", options);
+		const generator = this.#plop.getGenerator(generatorId);
+		const answers = await generator.runPrompts(bypassArr);
+		debug("generator answers: %O", answers);
+		const results = await generator.runActions(answers);
+		debug("generator results: %O", results);
+		if (results.failures.length > 0) throw new Error("Can't generate files");
+		return { answers };
+	}
+};
+const PLOP_CONFIG_PATH = join("plopfiles", "plopfile.ts");
+async function createPlopTemplateService(options) {
+	const { force, destBasePath } = options;
+	const debug = logger.subdebug("create-plop-template-service");
+	debug("options: %O", options);
+	const configPath = join(options.basePath, PLOP_CONFIG_PATH);
+	debug("plop config path:", configPath);
+	return new PlopTemplateService(await nodePlop(configPath, {
+		force,
+		destBasePath
+	}));
+}
+//#endregion
+//#region src/program/commands/add.ts
+function createAddCommand(ctx) {
+	return createCommand("add").description("add config files to a project 📁").addArgument(new Argument("[slug...]", "the config slugs to pick").choices(ctx.config.getPluginChoices())).addOption(new Option("-d, --dest <string>", "destination path to create folder (default: cwd)")).addOption(new Option("-f, --force", "override existing files").default(false)).action(async function addAction(slugs, options) {
+		try {
+			const { dest: destBasePath = cwd, force } = options;
+			await new AddAction({ templateService: await createPlopTemplateService({
+				force,
+				destBasePath,
+				basePath: ctx.binPkg.dirPath
+			}) }).execute({ slugs });
+		} catch (error) {
+			logger.error(error);
+			process.exit(1);
+		}
+	}).addHelpText("afterAll", "\nUnder the hood, this command uses Plop.js to generate the project.");
+}
+//#endregion
+//#region src/actions/init.ts
+const GENERATOR_ID = "init";
+var InitAction = class {
+	#templateService;
+	#shellService;
+	constructor({ templateService, shellService }) {
+		this.#templateService = templateService;
+		this.#shellService = shellService;
+	}
+	async execute(options) {
+		const { destBasePath, git } = options;
+		logger.subdebug("init-action")("execute options: %O", options);
+		const bypassArr = this.#getBypassArr(options);
+		await this.#templateService.generate({
+			bypassArr,
+			generatorId: GENERATOR_ID
+		});
+		logger.success("Project generated 🎉");
+		const shell = this.#shellService.at(destBasePath).quiet();
+		if (git) {
+			logger.start("Creating git repository");
+			await shell.$`git init`;
+			await shell.$`git add . && git commit -m "initial commit"`;
+			logger.success("Git repository created");
+		}
+	}
+	#getBypassArr(options) {
+		const { template } = options;
+		const bypassArr = [];
+		if (template) bypassArr[0] = template;
+		return bypassArr;
+	}
+};
+//#endregion
+//#region src/program/commands/init.ts
+function createInitCommand(ctx) {
+	return createCommand("init").description("init a new project 🚀").addArgument(new Argument("[template]", "the template to use").choices(ctx.config.getTemplateChoices())).addOption(new Option("-d, --dest [string]", "destination path to create folder (default: cwd)")).addOption(new Option("--no-git", "skip to create a git repository").default(true)).addOption(new Option("-f, --force", "override existing files").default(false)).action(async function initAction(template, options) {
+		try {
+			const { dest: destBasePath = cwd, force } = options;
+			await new InitAction({
+				templateService: await createPlopTemplateService({
+					force,
+					destBasePath,
+					basePath: ctx.binPkg.dirPath
+				}),
+				shellService: ctx.shell
+			}).execute({
+				template,
+				destBasePath,
+				...options
+			});
+		} catch (error) {
+			logger.error(error);
+			process.exit(1);
+		}
+	}).addHelpText("afterAll", "\nUnder the hood, this command uses Plop.js to generate the project.");
+}
+const BANNER_TEXT = `${`⚡ ${palette.bold("V")} ${palette.bold("L")} ${palette.bold("A")} ${palette.bold("N")} ${palette.bold("D")}`}: The CLI to init a new project in ${`${palette.vland("Variable Land")} 👊`}\n`;
+//#endregion
+//#region src/program/index.ts
+async function createProgram(options) {
+	const ctx = await createContext(options.binDir);
+	return new Command("vland").version(getVersion(ctx.binPkg), "-v, --version").addHelpText("before", BANNER_TEXT).addCommand(createInitCommand(ctx)).addCommand(createAddCommand(ctx));
+}
+//#endregion
+//#region src/main.ts
+async function main(options) {
+	await run(async () => {
+		await (await createProgram(options)).parseAsync();
+	}, logger);
+}
+//#endregion
+//#region bin.ts
+main({ binDir: __dirname });
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/starter",
-  "version": "0.0.13",
+  "version": "0.0.15-git-9445806.0",
   "description": "The CLI to init a new project in Variable Land",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/starter#readme",
   "bugs": {
@@ -8,34 +8,46 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/variableland/dx.git"
+    "url": "git+https://github.com/variableland/dx.git",
+    "directory": "packages/starter"
   },
   "license": "MIT",
   "author": "rcrd <rcrd@variable.land>",
   "type": "module",
+  "imports": {
+    "#src/*": "./src/*"
+  },
   "module": "src/main.ts",
   "bin": {
-    "vland": "./bin.ts"
+    "vland": "./dist/bin.mjs"
   },
   "files": [
-    "bin",
+    "bin.ts",
+    "dist",
     "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*",
     "plopfiles",
     "tsconfig.json"
   ],
   "dependencies": {
     "commander": "14.0.3",
     "node-plop": "0.32.3",
-    "@vlandoss/clibuddy": "0.0.9",
-    "@vlandoss/loggy": "0.0.6"
+    "@vlandoss/clibuddy": "0.0.11-git-9445806.0",
+    "@vlandoss/loggy": "0.0.8-git-9445806.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
+    "node": ">=20.0.0",
     "bun": ">=1.0.0"
   },
+  "devDependencies": {
+    "@vlandoss/tsdown-config": "^0.0.2-git-9445806.0"
+  },
   "scripts": {
+    "build": "tsdown",
     "test:types": "rr tsc"
   }
 }

package/plopfiles/plopfile.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import type { NodePlopAPI } from "node-plop";
-import { ConfigService } from "#/services/config";
+import { ConfigService } from "#src/services/config.ts";
 import { tsconfigPrompts } from "./prompts/tsconfig";
 
 const validators = {

package/src/actions/add.ts

@@ -1,5 +1,5 @@
-import { logger } from "#/services/logger";
-import type { TemplateService } from "#/services/types";
+import { logger } from "#src/services/logger.ts";
+import type { TemplateService } from "#src/services/types.ts";
 import type { AnyAction } from "./types";
 
 type CreateOptions = {

package/src/actions/init.ts

@@ -1,6 +1,6 @@
 import type { ShellService } from "@vlandoss/clibuddy";
-import { logger } from "#/services/logger";
-import type { TemplateService } from "#/services/types";
+import { logger } from "#src/services/logger.ts";
+import type { TemplateService } from "#src/services/types.ts";
 import type { AnyAction } from "./types";
 
 type ExecuteOptions = {

package/src/main.ts

@@ -1,6 +1,6 @@
 import { run } from "@vlandoss/clibuddy";
-import { createProgram, type Options } from "./program";
-import { logger } from "./services/logger";
+import { createProgram, type Options } from "./program/index.ts";
+import { logger } from "./services/logger.ts";
 
 export async function main(options: Options) {
   await run(async () => {

package/src/program/commands/add.ts

@@ -1,9 +1,9 @@
 import { cwd } from "@vlandoss/clibuddy";
 import { Argument, createCommand, Option } from "commander";
-import { AddAction } from "#/actions/add";
-import type { ContextValue } from "#/services/ctx";
-import { logger } from "#/services/logger";
-import { createPlopTemplateService } from "#/services/template";
+import { AddAction } from "#src/actions/add.ts";
+import type { ContextValue } from "#src/services/ctx.ts";
+import { logger } from "#src/services/logger.ts";
+import { createPlopTemplateService } from "#src/services/template.ts";
 
 type AddOptions = {
   dest: string;

package/src/program/commands/init.ts

@@ -1,9 +1,9 @@
 import { cwd } from "@vlandoss/clibuddy";
 import { Argument, createCommand, Option } from "commander";
-import { InitAction } from "#/actions/init";
-import type { ContextValue } from "#/services/ctx";
-import { logger } from "#/services/logger";
-import { createPlopTemplateService } from "#/services/template";
+import { InitAction } from "#src/actions/init.ts";
+import type { ContextValue } from "#src/services/ctx.ts";
+import { logger } from "#src/services/logger.ts";
+import { createPlopTemplateService } from "#src/services/template.ts";
 
 type InitOptions = {
   dest: string;

package/src/program/index.ts

@@ -1,8 +1,8 @@
 import { getVersion } from "@vlandoss/clibuddy";
 import { Command } from "commander";
-import { createContext } from "#/services/ctx";
-import { createAddCommand } from "./commands/add";
-import { createInitCommand } from "./commands/init";
+import { createContext } from "#src/services/ctx.ts";
+import { createAddCommand } from "./commands/add.ts";
+import { createInitCommand } from "./commands/init.ts";
 import { BANNER_TEXT } from "./ui";
 
 export type Options = {

package/src/services/ctx.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import { createPkgService, createShellService, type PkgService, type ShellService } from "@vlandoss/clibuddy";
-import { ConfigService } from "./config";
-import { logger } from "./logger";
+import { ConfigService } from "./config.ts";
+import { logger } from "./logger.ts";
 
 export type ContextValue = {
   binPkg: PkgService;

package/src/services/template.ts

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import type { NodePlopAPI } from "node-plop";
 import nodePlop from "node-plop";
-import { logger } from "./logger";
-import type { GenerateOptions, TemplateService } from "./types";
+import { logger } from "./logger.ts";
+import type { GenerateOptions, TemplateService } from "./types.ts";
 
 type CreateOptions = {
   basePath: string;

package/tsconfig.json

@@ -1,10 +1,3 @@
 {
-  "extends": ["@total-typescript/tsconfig/bundler/no-dom/app"],
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "#/*": ["./src/*"],
-      "@vlandoss/*": ["../../packages/*/src"]
-    }
-  }
+  "extends": ["@vlandoss/config/ts/no-dom/app"]
 }