feat: allow creating library projects

Author: Tommypop2

packages/create/src/create-library.ts

@@ -0,0 +1,14 @@
+import { downloadRepo, GithubFetcher } from "@begit/core";
+
+export type CreateLibraryArgs = {
+	destination: string;
+};
+export const createLibrary = ({ destination }: CreateLibraryArgs) => {
+	return downloadRepo(
+		{
+			repo: { owner: "solidjs-community", name: "solid-lib-starter" },
+			dest: destination,
+		},
+		GithubFetcher,
+	);
+};

packages/create/src/create-start.ts

@@ -9,10 +9,13 @@ export type CreateStartArgs = {
 };
 
 export const createStartTS = ({ template, destination }: CreateStartArgs) => {
-	return downloadRepo({
-		repo: { owner: "solidjs", name: "solid-start", subdir: `examples/${template}` },
-		dest: destination,
-	}, GithubFetcher);
+	return downloadRepo(
+		{
+			repo: { owner: "solidjs", name: "solid-start", subdir: `examples/${template}` },
+			dest: destination,
+		},
+		GithubFetcher,
+	);
 };
 
 export const createStartJS = async ({ template, destination }: CreateStartArgs) => {

packages/create/src/create-vanilla.ts

@@ -15,7 +15,10 @@ export const createVanilla = (args: CreateVanillaArgs, transpile?: boolean) => {
 	return createVanillaTS(args);
 };
 export const createVanillaTS = async ({ template, destination }: CreateVanillaArgs) => {
-	return await downloadRepo({ repo: { owner: "solidjs", name: "templates", subdir: template }, dest: destination }, GithubFetcher);
+	return await downloadRepo(
+		{ repo: { owner: "solidjs", name: "templates", subdir: template }, dest: destination },
+		GithubFetcher,
+	);
 };
 
 export const createVanillaJS = async ({ template, destination }: CreateVanillaArgs) => {

packages/create/src/index.ts

@@ -3,12 +3,21 @@ import { createVanilla } from "./create-vanilla";
 import * as p from "@clack/prompts";
 import { cancelable, spinnerify } from "@solid-cli/utils/ui";
 import { createStart } from "./create-start";
-import { getTemplatesList, GIT_IGNORE, StartTemplate, VanillaTemplate } from "./utils/constants";
+import {
+	getTemplatesList,
+	GIT_IGNORE,
+	PROJECT_TYPES,
+	ProjectType,
+	StartTemplate,
+	VanillaTemplate,
+} from "./utils/constants";
 import { detectPackageManager } from "@solid-cli/utils/package-manager";
 import { insertAtEnd } from "@solid-cli/utils/fs";
 import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createLibrary } from "./create-library";
 export { createVanilla, createStart };
+
 export const createSolid = (version: string) =>
 	defineCommand({
 		meta: {
@@ -46,12 +55,21 @@ export const createSolid = (version: string) =>
 			// Show prompts for any unknown arguments
 			let projectName: string = projectNamePositional ?? projectNameOptional;
 			let template: string = templatePositional;
-			let isStart: boolean = solidstart;
+			let projectType: ProjectType | undefined = solidstart ? "start" : undefined;
 			projectName ??= await cancelable(
 				p.text({ message: "Project Name", placeholder: "solid-project", defaultValue: "solid-project" }),
 			);
-			isStart ??= await cancelable(p.confirm({ message: "Is this a SolidStart project?" }));
-			const template_opts = await getTemplatesList(isStart);
+			projectType ??= await cancelable(
+				p.select({
+					message: "What type of project would you like to create?",
+					initialValue: "start",
+					options: PROJECT_TYPES.map((t) => ({
+						value: t,
+						label: t === "start" ? "SolidStart" : t === "vanilla" ? "SolidJS + Vite" : "Library",
+					})),
+				}),
+			);
+			const template_opts = getTemplatesList(projectType);
 			template ??= await cancelable(
 				p.select({
 					message: "Which template would you like to use?",
@@ -61,14 +79,25 @@ export const createSolid = (version: string) =>
 			);
 
 			// Don't transpile project if it's already javascript!
-			const transpileToJS = template.startsWith("js") ? false : !(await cancelable(p.confirm({ message: "Use Typescript?" })));
+			const transpileToJS =
+				projectType === "library"
+					? false
+					: template.startsWith("js")
+						? false
+						: !(await cancelable(p.confirm({ message: "Use Typescript?" })));
 
-			if (isStart) {
+			if (projectType === "start") {
 				await spinnerify({
 					startText: "Creating project",
 					finishText: "Project created 🎉",
 					fn: () => createStart({ template: template as StartTemplate, destination: projectName }, transpileToJS),
 				});
+			} else if (projectType === "library") {
+				await spinnerify({
+					startText: "Creating project",
+					finishText: "Project created 🎉",
+					fn: () => createLibrary({ destination: projectName }),
+				});
 			} else {
 				await spinnerify({
 					startText: "Creating project",

packages/create/src/utils/constants.ts

@@ -55,7 +55,7 @@ const VANILLA_TEMPLATES = [
 	"js",
 	"js-vitest",
 	"js-tailwindcss",
-] as const;
+] as const satisfies string[];
 export type VanillaTemplate = (typeof VANILLA_TEMPLATES)[number];
 
 const START_TEMPLATES = [
@@ -77,14 +77,26 @@ const START_TEMPLATES = [
 	"with-unocss",
 	"with-vitest",
 	"experiments",
-] as const;
+] as const satisfies string[];
 export type StartTemplate = (typeof START_TEMPLATES)[number];
 
-export const getTemplatesList = async (isStart: boolean) => {
-	if (isStart) {
-		return START_TEMPLATES;
+export const LIBRARY_TEMPLATES = ["solid-lib-starter"] as const satisfies string[];
+export type LibraryTemplate = (typeof LIBRARY_TEMPLATES)[number];
+
+export const PROJECT_TYPES = ["start", "vanilla", "library"] as const satisfies string[];
+export type ProjectType = (typeof PROJECT_TYPES)[number];
+
+export function getTemplatesList(projectType: "vanilla"): StartTemplate[];
+export function getTemplatesList(projectType: "start"): VanillaTemplate[];
+export function getTemplatesList(projectType: "library"): VanillaTemplate[];
+export function getTemplatesList(projectType: ProjectType): VanillaTemplate[] | StartTemplate[] | LibraryTemplate[];
+export function getTemplatesList(projectType: ProjectType) {
+	if (projectType === "start") {
+		return START_TEMPLATES as StartTemplate[];
+	} else if (projectType === "library") {
+		return LIBRARY_TEMPLATES as LibraryTemplate[];
 	}
-	return VANILLA_TEMPLATES;
-};
+	return VANILLA_TEMPLATES as VanillaTemplate[];
+}
 
 //

packages/full-solid/src/bin.ts

@@ -13,7 +13,7 @@ intro(`\n${color.bgCyan(color.black(` Solid CLI v${packageJson.version}`))}`);
 
 const main = defineCommand({
 	meta: {
-		description: "The full Solid CLI"
+		description: "The full Solid CLI",
 	},
 	subCommands: {
 		create: createSolid(packageJson.version),
@@ -23,7 +23,7 @@ const main = defineCommand({
 			meta: { description: "Open the Solid Docs in your browser" },
 			async run() {
 				openInBrowser("https://docs.solidjs.com");
-				p.log.success("Opened successfully")
+				p.log.success("Opened successfully");
 			},
 		}),
 	},

packages/full-solid/src/start/index.ts

@@ -2,9 +2,10 @@ import { createApi, createRoute } from "@solid-cli/utils";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 import { green } from "picocolors";
-import { cancelable } from "@solid-cli/utils/ui"
+import { cancelable } from "@solid-cli/utils/ui";
 export const startCommands = defineCommand({
-	meta: { description: "Start-specific commands" }, subCommands: {
+	meta: { description: "Start-specific commands" },
+	subCommands: {
 		route: defineCommand({
 			meta: { description: "Creates a new route" },
 			args: {
@@ -17,22 +18,25 @@ export const startCommands = defineCommand({
 					type: "boolean",
 					required: false,
 					default: false,
-					alias: "a"
-				}
+					alias: "a",
+				},
 			},
 			async run({ args: { path, api } }) {
-				path ||= await cancelable(p.text({
-					message: "Route path", validate(value) {
-						if (value.length === 0) return "A route path is required"
-					},
-				}))
+				path ||= await cancelable(
+					p.text({
+						message: "Route path",
+						validate(value) {
+							if (value.length === 0) return "A route path is required";
+						},
+					}),
+				);
 				if (api) {
 					await createApi(path as string);
 				} else {
 					await createRoute(path as string);
 				}
-				p.log.success(`Route ${green(path as string)} successfully created!`)
+				p.log.success(`Route ${green(path as string)} successfully created!`);
 			},
 		}),
-	}
+	},
 });

packages/utils/src/ui/index.ts

@@ -1,3 +1,3 @@
 import { cancelable } from "./cancelable";
 import { spinnerify } from "./spinnerify";
-export { cancelable, spinnerify }
+export { cancelable, spinnerify };

packages/utils/src/ui/spinnerify.ts

@@ -16,4 +16,4 @@ export async function spinnerify<T>(spinners: SpinnerItem<any>[] | SpinnerItem<T
 		s.stop(finishText);
 	}
 	return results.length === 1 ? results[0] : results;
-}
+}