create-routify 1.4.2 → 1.5.0

package/README.md

@@ -17,7 +17,17 @@ We have designed the cli to be able to be run in headless mode, as such the foll
 ```
 npm init routify [directory-name]
 
--h, --help          get the help menu
--v, --version       use this to set the version of routify, e.g. 3
--f, --force         this option bypasses directory checks, be careful as might overwrite files!
+  -v, --version <version>                  use this to set the version of routify, e.g. 3
+  -t, --starter-template <starterTemplate>    use this to set the starter template, e.g. starter-basic
+  -f, --force                              this option bypasses directory checks, be careful as might overwrite files!
+  -r, --force-refresh                      this option forces a refresh of the repos
+  -f, --features <features>                optionally add features to your project, eg. "test", "prettier"
+  -s, --skip                               this option skips all prompts
+  -p, --package-manager <package-manager>  this option sets the package manager to use, e.g. "npm", "pnpm" or "yarn"
+  -i, --install                            install dependencies after creating project
+  -d, --debug                              run in debug mode
+  -h, --help                               display help for command
 ```
+
+### Contributors
+See [CONTRIBUTORS.md](CONTRIBUTORS.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-routify",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "A powerful cli for super-powering your routify development experience",
   "main": "index.js",
   "type": "module",
@@ -32,16 +32,14 @@
     "url": "https://github.com/roxiness/create-routify/issues"
   },
   "dependencies": {
-    "@roxi/routify": "^3.0.0-next.172",
-    "kleur": "^4.1.5",
+    "@clack/prompts": "^0.6.3",
+    "commander": "^11.0.0",
+    "download-git-repo": "^3.0.2",
     "log-symbols": "^5.1.0",
-    "minimist": "^1.2.7",
-    "prompts": "^2.4.2",
-    "simple-git": "^3.15.1",
+    "picocolors": "^1.0.0",
     "update-notifier": "^6.0.2"
   },
   "devDependencies": {
-    "@types/prompts": "^2.4.2",
     "@types/update-notifier": "^6.0.1"
   }
 }

package/src/bin.js

@@ -2,13 +2,47 @@
 import updateNotifier from 'update-notifier';
 import { readFile } from 'fs/promises';
 import { run } from '../src/index.js';
-import minimist from 'minimist';
+import { program } from 'commander';
 
-const args = minimist(process.argv.slice(2));
-
-run({ args });
+parseArgs();
 
 try {
     const pkg = await readFile('../package.json', 'utf-8');
     updateNotifier({ pkg: JSON.parse(pkg) }).notify();
 } catch {}
+
+function parseArgs(config) {
+    program
+        .argument('[dir]', 'name of the directory to create')
+        .option(
+            '-v, --version <version>',
+            'use this to set the version of routify, e.g. 3',
+        )
+        .option(
+            '-t, --starter-template <starterTemplate>',
+            'use this to set the starter template, e.g. starter-basic',
+        )
+        .option(
+            '-f, --force',
+            'this option bypasses directory checks, be careful as might overwrite files!',
+        )
+        .option(
+            '-r, --force-refresh',
+            'this option forces a refresh of the repos',
+        )
+        .option(
+            '--features <features...>',
+            'optionally add features to your project, eg. "test", "prettier"',
+        )
+        .option('-H, --headless', 'run in headless mode')
+        .option(
+            '-p, --package-manager <package-manager>',
+            'this option sets the package manager to use, e.g. "npm", "pnpm" or "yarn"',
+        )
+        .option('-i, --install', 'install dependencies after creating project')
+        .option('-d, --debug', 'run in debug mode')
+        .action((dir, options) => {
+            run({ dir, ...options });
+        })
+        .parse();
+}

package/src/index.js

@@ -1,108 +1,330 @@
-import { onCancel } from './utils/prompts.js';
+/**
+ * @typedef {Object} Options
+ * @property {string} dir
+ * @property {string} projectDir
+ * @property {string} version
+ * @property {string} starterTemplate
+ * @property {Template} template
+ * @property {boolean} force
+ * @property {boolean} headless
+ * @property {boolean} debug
+ * @property {''|'npm'|'yarn'|'pnpm'} packageManager
+ * @property {string[]} features
+ *
+ *
+ */
+
+import { mkdir, cp, rm } from 'fs/promises';
 import { existsSync, readdirSync } from 'fs';
-import { mkdir } from 'fs/promises';
+import { join, relative, resolve } from 'path';
 import symbols from 'log-symbols';
-import { relative } from 'path';
-import { resolve } from 'path';
-import prompts from 'prompts';
-import k from 'kleur';
-
-const versions = {
-    2: () => import('./versions/two.js'),
-    3: () => import('./versions/three/index.js'),
-};
-
-const helpText = `  npm init routify [directory-name]
-
-  -h, --help          get the help menu
-  -v, --version       use this to set the version of routify, e.g. 3
-  -f, --force         this option bypasses directory checks, be careful as might overwrite files!`;
-
-async function getVersion(args) {
-    const argsVersion = args.v || args.version;
-    if (argsVersion) return argsVersion;
+import color from 'picocolors';
+import * as p from '@clack/prompts';
+import { emitter, writePrettierConfig } from './utils/index.js';
+import { addTests, removeTests } from './utils/patcher/test/index.js';
+import { getTemplatesFromRepos } from './utils/repos.js';
 
-    const { version } = await prompts(
-        {
-            type: 'select',
-            name: 'version',
+const prompts = {
+    version: () =>
+        p.select({
             message: 'Routify Version:',
-            choices: [
-                { title: 'Routify 2', value: 2 },
+            options: [
+                { label: 'Routify 2', value: 2 },
                 {
-                    title: `Routify 3 ${k.bold().magenta('[BETA]')}`,
+                    label: `Routify 3`,
                     value: 3,
+                    hint: 'This is a beta version',
                 },
             ],
-        },
-        { onCancel },
-    );
+            initialValue: 3,
+        }),
+    dir: () =>
+        p.text({
+            message: 'Directory name:',
+            initialValue: '',
+            // hint: 'Leave empty to use current directory',
+            defaultValue: '.',
+            placeholder: 'Leave empty to use current directory',
+        }),
+    overwrite: () =>
+        p.confirm({
+            message: 'Directory is not empty, continue?',
+            initialValue: false,
+        }),
+    selectFeatures: (availableFeatures) =>
+        p.multiselect({
+            message: 'Select features:',
+            options: availableFeatures,
+            initialValues: availableFeatures
+                .filter((f) => f.initial)
+                .map((f) => f.value),
+        }),
+    selectTemplate: (templates) =>
+        p.select({
+            message: 'Select template:',
+            options: templates.map((template) => ({
+                label: template.manifest?.name || template.name,
+                value: template.name,
+                hint: template.manifest?.description || template.description,
+            })),
+            initialValue: 'starter-basic',
+        }),
+    selectPackageManager: () =>
+        p.select({
+            message: 'Install dependencies with:',
+            options: [
+                { label: "Don't install", value: '' },
+                { label: 'npm', value: 'npm' },
+                { label: 'pnpm', value: 'pnpm' },
+                { label: 'yarn', value: 'yarn' },
+            ],
+            initialValue: '',
+        }),
+    nextSteps: (dir, packageManager) => {
+        const steps = [
+            dir === '.' ? '' : `cd ${dir}`,
+            packageManager ? '' : 'npm install',
+            `${packageManager || 'npm'} run dev`,
+        ]
+            .filter(Boolean)
+            .map((step, i) => `${i + 1}. ${step}`)
+            .join('\n');
 
-    return version;
-}
+        return `Next steps: \n${steps}`;
+    },
+};
 
-export const run = async ({ args }) => {
-    console.log(`  ${k.dim(`v${'1.0.0'}`)}`);
-    console.log(`  ${k.bold().magenta('Routify')} ${k.magenta().dim('CLI')}`);
-    console.log();
+const check = {
+    existingDir: async (options) => {
+        const proceed =
+            !existsSync(options.projectDir) ||
+            !readdirSync(options.projectDir).length ||
+            options.force ||
+            (await prompts.overwrite());
 
-    if (args.h || args.help) {
-        return console.log(helpText);
-    }
+        if (!proceed) {
+            p.cancel('Directory not empty');
+            process.exit();
+        }
+    },
+    version: (version) => {
+        if ([2, 3].includes(version.toString())) {
+            p.cancel(`Version ${version} not found`);
+            process.exit();
+        }
+    },
+};
+
+const getAvailableFeatures = (template) => {
+    const features = template.manifest.features || [];
+    if (template.manifest.test)
+        features.push({
+            label: 'test',
+            value: 'test',
+            hint: 'Add test files',
+            initial: true,
+        });
+    features.push({
+        label: 'prettier',
+        value: 'prettier',
+        hint: 'Add prettier config',
+        initial: true,
+    });
+    return features;
+};
+
+/**
+ *
+ * @param {} options
+ * @param {TemplateConfig} configs
+ */
+async function runPrompts(options, configs) {
+    console.clear();
+    p.intro(`${color.bgMagenta(color.black(' Routify CLI '))}`);
 
-    const version = await getVersion(args);
-    const force = args.f || args.force;
-
-    if (!Object.keys(versions).includes(version.toString()))
-        return console.log(`  ${k.red(`Version ${version} not found`)}`);
-
-    const projectName = args._[0] || '.';
-    const projectDir = resolve(projectName.toString());
-
-    if (
-        existsSync(projectDir) &&
-        readdirSync(projectDir).length > 0 &&
-        !force
-    ) {
-        const { proceed } = await prompts(
-            {
-                type: 'confirm',
-                message: `Directory is not empty, continue?`,
-                name: 'proceed',
-            },
-            { onCancel },
-        );
-
-        if (!proceed) return onCancel();
+    options.version = options.version || (await prompts.version());
+    check.version(options.version);
+    const config = configs.versions[options.version];
+    await setTemplates(configs, options);
+    options.dir = options.dir || (await prompts.dir());
+
+    options.projectDir = resolve(options.dir);
+    await check.existingDir(options);
+
+    while (!options.starterTemplate) {
+        const refreshOption = {
+            name: '[Refresh templates]',
+            hint: 'Update templates from remote',
+        };
+        const customTemplates = {
+            name: '[Include custom templates]',
+            hint: 'Include templates from 3rd party repos',
+        };
+        const templates = [...options.templates];
+        if (!options.forceRefresh) templates.push(refreshOption);
+        if (
+            !options.customTemplates &&
+            config.templatesRepos.find((repo) => !repo.includeByDefault)
+        )
+            templates.push(customTemplates);
+        options.starterTemplate =
+            options.starterTemplate ||
+            (await prompts.selectTemplate(templates));
+
+        if (options.starterTemplate === '[Refresh templates]') {
+            options.forceRefresh = true;
+            await setTemplates(configs, options);
+            options.starterTemplate = null;
+        }
+        if (options.starterTemplate === '[Include custom templates]') {
+            options.customTemplates = true;
+            await setTemplates(configs, options);
+            options.starterTemplate = null;
+        }
     }
 
-    await mkdir(projectDir, { recursive: true });
+    options.template = options.templates.find(
+        (t) => t.name === options.starterTemplate,
+    );
+
+    if (!options.template)
+        p.cancel(`Template ${options.starterTemplate} not found`);
+
+    options.features =
+        options.features ||
+        (await prompts.selectFeatures(getAvailableFeatures(options.template)));
 
-    await runVersion(version, { args, projectDir });
+    options.packageManager =
+        options.packageManager || (await prompts.selectPackageManager());
+}
 
-    console.log();
-    console.log(`  ${k.green('All Done!')}`);
-    console.log();
-    console.log(`  Now you can:`);
+const copy = async (options) => {
+    const s = p.spinner();
+    s.start('Copying template to project directory');
+    await mkdir(options.projectDir, { recursive: true });
+
+    await cp(options.template.dir, options.projectDir, {
+        recursive: true,
+    });
+    if (existsSync(join(options.projectDir, 'manifest.js')))
+        await rm(join(options.projectDir, 'manifest.js'));
+    s.stop('Copied template to project directory');
+};
 
-    let i = 1;
+const install = async (options) => {
+    if (options.packageManager) {
+        const s = p.spinner();
+
+        const { exec } = await import('child_process');
+        const { packageManager } = options;
+        const cwd = relative(process.cwd(), options.projectDir);
+        const cmd = `${packageManager} install`;
+        s.start(`Installing via ${packageManager}`);
+        await new Promise((resolve, reject) => {
+            exec(cmd, { cwd }, (err, stdout, stderr) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(stdout);
+                }
+            });
+        });
+
+        s.stop('Installed via pnpm');
+    }
+};
 
-    if (relative(process.cwd(), projectDir) != '')
-        console.log(`    ${i++}) cd ${relative(process.cwd(), projectDir)}`);
+/**
+ *
+ * @param {Options} options
+ */
+export const manageTests = async (options) => {
+    const { test } = options.template.manifest;
+    const dir = options.projectDir;
+    const shouldAddTest = options.features.includes('test');
+    if (shouldAddTest) {
+        await addTests(dir, test);
+    } else await removeTests(dir);
+};
 
-    console.log(`    ${i++}) npm install`);
-    console.log(`    ${i++}) npm run dev`);
+/**
+ * @param {Options} options
+ */
+const handleFeatures = async (options) => {
+    const s = p.spinner();
+    s.start('Set up features');
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await manageTests(options);
+    if (options.features.includes('prettier')) {
+        writePrettierConfig(options.projectDir);
+    }
+    s.stop('Set up features');
+};
 
-    console.log();
+/**
+ *
+ * @param {*} options
+ * @param {TemplateConfig} configs
+ */
+const normalizeOptions = async (options, configs) => {
+    options.version = options.version || 3;
+    const config = configs.versions[options.version];
+    await setTemplates(configs, options);
+    options.projectDir = resolve(options.dir);
+    options.starterTemplate = options.starterTemplate || config.defaultTemplate;
+    options.template = options.templates.find(
+        (t) => t.name === options.starterTemplate,
+    );
+    options.features = options.features || [];
+    check.version(options.version);
+    if (!options.template)
+        p.cancel(`Template ${options.starterTemplate} not found`);
+};
 
-    console.log(
-        `${symbols.success} If you need help, ${k.blue(
-            'join the Discord',
-        )}: https://discord.com/invite/ntKJD5B`,
+/**
+ *
+ * @param {TemplateConfig} configs
+ * @param {*} options
+ */
+const setTemplates = async (configs, options) => {
+    const config = configs.versions[options.version];
+    options.templates = await getTemplatesFromRepos(
+        config.templatesRepos,
+        options.forceRefresh,
+        options.debug,
     );
 };
 
-const runVersion = async (version, args) => {
-    const { run } = await versions[version]();
-    return run(args);
+export const run = async (options) => {
+    const s = p.spinner();
+    emitter.on('download', (url) => s.start(`Downloading ${url}`));
+    emitter.on('downloaded', (url) => s.stop(`Downloaded ${url}`));
+    const configs = (await import('../config.js')).default;
+
+    const tools = { prompts: p };
+    // console.log(options);
+    // process.exit();
+    if (!options.headless) await runPrompts(options, configs);
+    else await normalizeOptions(options, configs);
+
+    await copy(options);
+    await handleFeatures(options);
+    const { preInstall, postInstall } = options.template.manifest;
+    if (preInstall) await preInstall(options, tools);
+    await install(options);
+    if (postInstall) await postInstall(options, tools);
+
+    p.note(
+        prompts.nextSteps(options.dir, options.packageManager) +
+            `\n\n${
+                symbols.success
+            } Need help? Join us on discord: ${color.underline(
+                color.bgMagenta('https://discord.com/invite/ntKJD5B'),
+            )}\n${
+                symbols.success
+            } Follow our twitter to get updates: ${color.underline(
+                color.bgMagenta('https://twitter.com/routifyjs'),
+            )}`,
+    );
+    p.outro('Happy coding!');
 };

package/src/utils/index.js

@@ -0,0 +1,23 @@
+import { writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import EventEmitter from 'events';
+export const createDirname = (meta) => dirname(fileURLToPath(meta.url));
+
+export const writePrettierConfig = async (dir) => {
+    const prettierConfigPath = join(dir, '.prettierrc');
+    if (!existsSync(prettierConfigPath)) {
+        await writeFile(
+            prettierConfigPath,
+            `{
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "all",
+    "printWidth": 120
+}`,
+        );
+    }
+};
+
+export const emitter = new EventEmitter();

package/src/utils/patcher/test/index.js

@@ -0,0 +1,112 @@
+import { rm } from 'fs/promises';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const resolveTestTemplate = (template) => {
+    if (typeof template === 'string') return template;
+    if (typeof template === 'object') {
+        const { page, contains } = template;
+        return `test('can see ${page}', async () => {
+    await router.url.push('${page}')
+
+    expect(document.body.innerHTML).toContain('${contains}')
+})`;
+    }
+};
+
+/**
+ * @param {string} dir
+ * @param {TestTemplate[]} tests
+ */
+export const createTestFiles = async (dir, tests) => {
+    const testDir = join(dir, 'tests');
+    await mkdirSync(testDir, { recursive: true });
+    await writeFileSync(
+        join(testDir, 'test.spec.js'),
+        `/** @type { Router } */
+let router
+
+beforeAll(async () => {
+    await import('../.routify/routify-init.js')
+    router = globalThis.__routify.routers[0]
+    await router.ready()
+    // wait for components to render
+    await new Promise((resolve) => setTimeout(resolve))
+})
+
+${tests.map(resolveTestTemplate).join('\n\n')}
+`,
+    );
+};
+
+const installVitest = async (dir) => {
+    // patch package.json
+    const packageJsonPath = join(dir, 'package.json');
+    const file = readFileSync(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(file);
+    // if vitest isn't already installed, install it
+    if (!packageJson.devDependencies.vitest) {
+        packageJson.devDependencies.vitest = 'latest';
+        // add script
+        if (!packageJson.scripts.test) packageJson.scripts.test = 'vitest';
+        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    // add test entry to vite.config.js
+    const viteConfigPath = join(dir, 'vite.config.js');
+    const viteConfig = readFileSync(viteConfigPath, 'utf-8');
+    if (!viteConfig.includes('test:')) {
+        writeFileSync(
+            viteConfigPath,
+            viteConfig.replace(
+                'plugins: [',
+                `
+    test: {
+        environment: 'jsdom',
+        globals: true,
+    },
+    plugins: [`,
+            ),
+        );
+    }
+    // add global types to tsconfig.json
+    if (existsSync(join(dir, 'tsconfig.json'))) {
+        const tsConfigPath = join(dir, 'tsconfig.json');
+        const tsConfigFile = readFileSync(tsConfigPath, 'utf-8');
+        const tsConfig = JSON.parse(tsConfigFile);
+        tsConfig.compilerOptions.types = [
+            ...(tsConfig.compilerOptions.types || []),
+            'vitest/globals',
+        ];
+        tsConfig.include = [...(tsConfig.include || []), 'tests/**/*'];
+        writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2));
+    }
+};
+
+export const removeTests = async (dir) => {
+    // remove tests folder (windows and unix)
+    const testDir = join(dir, 'tests');
+    await rm(testDir, { recursive: true, force: true });
+    // remove any line from scripts and devDependencies that contains test
+    const packageJsonPath = join(dir, 'package.json');
+    const file = readFileSync(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(file);
+    packageJson.scripts = Object.fromEntries(
+        Object.entries(packageJson.scripts).filter(
+            ([key]) => !key.includes('test'),
+        ),
+    );
+    packageJson.devDependencies = Object.fromEntries(
+        Object.entries(packageJson.devDependencies).filter(
+            ([key]) => !key.includes('test'),
+        ),
+    );
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+};
+
+/**
+ *
+ * @param {string} dir
+ * @param {TemplateManifest['test']} test
+ */
+export const addTests = async (dir, test) =>
+    Promise.all([createTestFiles(dir, test.tests), installVitest(dir)]);

package/src/utils/repos.js

@@ -0,0 +1,131 @@
+import { readdir } from 'fs/promises';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { existsSync } from 'fs';
+import { createRequire } from 'module';
+import download from 'download-git-repo';
+import { emitter } from './index.js';
+export const createDirname = (meta) => dirname(fileURLToPath(meta.url));
+const __dirname = createDirname(import.meta);
+
+const require = createRequire(import.meta.url);
+
+const getReposPath = () => join(__dirname, '..', '..', '.repos');
+
+const ensureRepo = async (url, force, onDownload) => {
+    // convert url to file safe name
+    const name = url.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+    const repoPath = `${getReposPath()}/${name}`;
+
+    const localPath = url.match(/^local:(.*)/);
+    if (localPath) return join(__dirname, '..', '..', localPath[1]);
+
+    // if repo doesn't exist, download it
+    if (!existsSync(repoPath) || force) {
+        emitter.emit('download', url);
+        if (onDownload) onDownload();
+        await new Promise((resolve, reject) =>
+            download(url, repoPath, { clone: false }, (err) => {
+                if (err) reject(err);
+                else resolve(null);
+            }),
+        );
+        emitter.emit('downloaded', url);
+    }
+
+    // return path to repo
+    return repoPath;
+};
+
+export const getTemplatesDir = async (url, dir) => {
+    const repoPath = await ensureRepo(url);
+
+    return [repoPath, dir].filter(Boolean).join('/');
+};
+
+export class Manifest {
+    /**
+     * @param {Partial<TemplateManifest>} manifest
+     */
+    constructor(manifest) {
+        this.name = manifest.name || '';
+        this.description = manifest.description || '';
+        this.test = manifest.test || null;
+        this.features = manifest.features || [];
+        this.postInstall = manifest.postInstall || (() => {});
+        this.preInstall = manifest.preInstall || (() => {});
+        this.error = manifest.error || null;
+    }
+}
+
+export const getManifestFromDir = async (dir) => {
+    try {
+        return await import(
+            pathToFileURL(join(dir, 'manifest.js')).pathname
+        ).then((m) => new Manifest(m.default));
+    } catch (error) {
+        return new Manifest({ error });
+    }
+};
+
+/**
+ *
+ * @param {TemplateRepoConfig[]} repos
+ * @param {boolean} forceRefresh
+ * @param {boolean} debug
+ */
+export const getTemplatesFromRepos = async (repos, forceRefresh, debug) => {
+    /** @type {Template[]} */
+    const templates = [];
+    for (const repo of repos) {
+        const repoPath = await ensureRepo(repo.url, forceRefresh);
+        if (repo.templateType === 'single') {
+            templates.push({
+                dir: repoPath,
+                name: repo.name,
+                description: repo.description,
+                manifest: await getManifestFromDir(repoPath),
+            });
+        } else if (repo.templateType === 'directory') {
+            const templatePath = [repoPath, repo.path]
+                .filter(Boolean)
+                .join('/');
+            const collectionTemplates = await getTemplatesFromDir(
+                templatePath,
+                debug,
+            );
+            templates.push(...collectionTemplates);
+        }
+    }
+    return templates;
+};
+
+/**
+ * Returns the directory of @roxi/routify/examples
+ */
+export const getRoutifyExamplesDir = () => {
+    const routifyPkgJsonPath = require.resolve('@roxi/routify/package.json');
+    return resolve(routifyPkgJsonPath, '..', 'examples');
+};
+
+/**
+ * Returns every template with a manifest.js file
+ * @param {string} routifyExamplesDir
+ * @param {boolean=} debug
+ * @returns {Promise<Template[]>}
+ */
+export const getTemplatesFromDir = async (routifyExamplesDir, debug) => {
+    let dirNames = await readdir(routifyExamplesDir);
+    return Promise.all(
+        dirNames
+            .map((name) => ({ name, dir: join(routifyExamplesDir, name) }))
+            .filter(({ dir }) => existsSync(join(dir, 'manifest.js')))
+            .map(async ({ dir, name }) => {
+                return {
+                    dir,
+                    name,
+                    manifest: await getManifestFromDir(dir),
+                };
+            }),
+    );
+};

package/src/versions404/three/index.js

@@ -0,0 +1,29 @@
+import { getTemplate, onCancel } from '../../utils/prompts.js';
+import { readdir, cp, rm } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import prompts from 'prompts';
+import k from 'kleur';
+import { getRoutifyExamplesDir, routifyIntro } from './utils.js';
+import { existsSync } from 'fs';
+import { addTests } from '../../utils/patcher/test/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export const run = async (options) => {
+    const { dir, force, version, starter } = options;
+    console.log('options', options);
+    routifyIntro();
+
+    const routifyExamplesDir = getRoutifyExamplesDir();
+    const project = await getTemplate(routifyExamplesDir, starter);
+    console.log('project', project);
+    if (project.test) {
+        const { tests } = project.test;
+        console.log(tests);
+        addTests(projectDir, project.test);
+    }
+
+    // await cp(exampleDir, projectDir, { recursive: true });
+    // await rm(join(projectDir, 'manifest.js'));
+};

package/src/versions404/three/utils.js

@@ -0,0 +1,24 @@
+import { createRequire } from 'module';
+import { resolve } from 'path';
+import k from 'kleur';
+const require = createRequire(import.meta.url);
+
+export function routifyIntro() {
+    console.log();
+    console.log(
+        `  ${k.underline(
+            `${k.bold().magenta('Routify')} ${k.bold('3')} beta`,
+        )}`,
+    );
+    console.log(
+        `  - Follow our twitter to get updates: ${k.blue(
+            'https://twitter.com/routifyjs',
+        )}`,
+    );
+    console.log(
+        `  - Or join our discord: ${k.blue(
+            'https://discord.com/invite/ntKJD5B',
+        )}`,
+    );
+    console.log();
+}

package/src/versions404/two.js

@@ -0,0 +1,18 @@
+import logSymbols from 'log-symbols';
+import simpleGit from 'simple-git';
+import { rmSync } from 'fs';
+import { join } from 'path';
+import k from 'kleur';
+
+export const run = async ({ projectDir, args }) => {
+    const git = simpleGit(projectDir);
+
+    console.log(k.blue(`\n${logSymbols.info} Cloning template...`));
+
+    await git.clone('https://github.com/roxiness/routify-starter', projectDir);
+
+    rmSync(join(projectDir, '.git'), {
+        recursive: true,
+        force: true,
+    });
+};

package/src/utils/prompts.js

@@ -1,10 +0,0 @@
-import k from 'kleur';
-
-export const onCancel = () => {
-    console.log();
-    console.log(
-        `  ${k.bold().red('Exited')} ${k.magenta().dim('create-routify')}`,
-    );
-
-    process.exit(0);
-};

package/src/versions/three/index.js

@@ -1,84 +0,0 @@
-import { onCancel } from '../../utils/prompts.js';
-import { readdir, cp, rm } from 'fs/promises';
-import { join, dirname } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import prompts from 'prompts';
-import k from 'kleur';
-import { getRoutifyExamplesDir } from './utils.js';
-import { existsSync } from 'fs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-function text() {
-    console.log();
-    console.log(
-        k.red(`  ! R3 is under heavy work, expect bugs and missing features`),
-    );
-
-    console.log();
-    console.log(
-        `  ${k.underline(`${k.bold().magenta('Routify')} ${k.bold('3')}`)}`,
-    );
-    console.log(
-        `  - Follow our twitter to get updates: ${k.blue(
-            'https://twitter.com/routifyjs',
-        )}`,
-    );
-    console.log(
-        `  - Or join our discord: ${k.blue(
-            'https://discord.com/invite/ntKJD5B',
-        )}`,
-    );
-    console.log();
-}
-
-async function getExampleDir() {
-    const routifyExamplesDir = getRoutifyExamplesDir();
-    let dirNames = await readdir(routifyExamplesDir);
-    const projects = await Promise.all(
-        dirNames
-            .map((name) => ({ name, dir: join(routifyExamplesDir, name) }))
-            .filter(({ dir }) => existsSync(join(dir, 'manifest.js')))
-            .map(async ({ dir, name }) => {
-                try {
-                    return await import(
-                        pathToFileURL(join(dir, 'manifest.js')).pathname
-                    ).then((m) => ({ dir, name, manifest: m.default }));
-                } catch (err) {
-                    return {
-                        dir,
-                        name,
-                        manifest: {
-                            name,
-                            description: 'Could not read template info',
-                        },
-                    };
-                }
-            }),
-    );
-
-    const { project } = await prompts(
-        {
-            message: 'Please select a starter template',
-            name: 'project',
-            type: 'select',
-            choices: projects.filter(Boolean).map((value) => ({
-                title: value.manifest.name,
-                description: value.manifest.description,
-                value,
-            })),
-        },
-        { onCancel },
-    );
-
-    return project.dir;
-}
-
-export const run = async ({ projectDir }) => {
-    text();
-
-    const exampleDir = await getExampleDir();
-
-    await cp(exampleDir, projectDir, { recursive: true });
-    await rm(join(projectDir, 'manifest.js'));
-};

package/src/versions/three/utils.js

@@ -1,11 +0,0 @@
-import { createRequire } from 'module';
-import { resolve } from 'path';
-const require = createRequire(import.meta.url);
-
-/**
- * Returns the directory of @roxi/routify/examples
- */
-export const getRoutifyExamplesDir = () => {
-    const routifyPkgJsonPath = require.resolve('@roxi/routify/package.json');
-    return resolve(routifyPkgJsonPath, '..', 'examples');
-};