directus-template-cli 0.6.0-beta.2 → 0.7.0-beta.2

package/dist/lib/init/index.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+const tslib_1 = require("tslib");
+const prompts_1 = require("@clack/prompts");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const giget_1 = require("giget");
+const glob_1 = require("glob");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const nypm_1 = require("nypm");
+const apply_1 = tslib_1.__importDefault(require("../../commands/apply"));
+const docker_1 = require("../../services/docker");
+const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
+const parse_github_url_1 = require("../utils/parse-github-url");
+const config_1 = require("./config");
+async function init(dir, flags) {
+    // Check target directory
+    const shouldForce = flags.overrideDir;
+    if (node_fs_1.default.existsSync(dir) && !shouldForce) {
+        throw new Error('Directory already exists. Use --override-dir to override.');
+    }
+    const frontendDir = node_path_1.default.join(dir, flags.frontend);
+    const directusDir = node_path_1.default.join(dir, 'directus');
+    let template;
+    try {
+        // Download the template from GitHub
+        const parsedUrl = (0, parse_github_url_1.parseGitHubUrl)(flags.template);
+        template = await (0, giget_1.downloadTemplate)((0, parse_github_url_1.createGigetString)(parsedUrl), {
+            dir,
+            force: shouldForce,
+        });
+        // Cleanup the template
+        if (flags.frontend) {
+            // Ensure directus directory exists before cleaning up
+            if (!node_fs_1.default.existsSync(directusDir)) {
+                node_fs_1.default.mkdirSync(directusDir, { recursive: true });
+            }
+            // Read and parse package.json
+            const packageJsonPath = node_path_1.default.join(dir, 'package.json');
+            if (!node_fs_1.default.existsSync(packageJsonPath)) {
+                throw new Error('package.json not found in template');
+            }
+            const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+            const templateConfig = packageJson['directus:template'];
+            // Get all frontend paths from the configuration
+            const frontendPaths = Object.values((templateConfig === null || templateConfig === void 0 ? void 0 : templateConfig.frontends) || {})
+                .map(frontend => frontend.path.replace(/^\.\//, ''))
+                .filter(path => path !== flags.frontend); // Exclude the selected frontend
+            // Remove unused frontend directories
+            for (const frontendPath of frontendPaths) {
+                const pathToRemove = node_path_1.default.join(dir, frontendPath);
+                if (node_fs_1.default.existsSync(pathToRemove)) {
+                    node_fs_1.default.rmSync(pathToRemove, { recursive: true });
+                }
+            }
+        }
+        // Find and copy all .env.example files
+        const envFiles = glob_1.glob.sync(node_path_1.default.join(dir, '**', '.env.example'));
+        for (const file of envFiles) {
+            const envFile = file.replace('.env.example', '.env');
+            node_fs_1.default.copyFileSync(file, envFile);
+        }
+        // Start Directus and apply template only if directus directory exists
+        if (node_fs_1.default.existsSync(directusDir)) {
+            // Initialize Docker service
+            const dockerService = (0, docker_1.createDocker)(config_1.DOCKER_CONFIG);
+            // Check if Docker is installed
+            const dockerStatus = await dockerService.checkDocker();
+            if (!dockerStatus.installed || !dockerStatus.running) {
+                throw new Error(dockerStatus.message);
+            }
+            try {
+                await dockerService.startContainers(directusDir);
+                const healthCheckUrl = `${config_1.DIRECTUS_CONFIG.url}:${config_1.DIRECTUS_CONFIG.port}${config_1.DOCKER_CONFIG.healthCheckEndpoint}`;
+                await dockerService.waitForHealthy(healthCheckUrl);
+                const templatePath = node_path_1.default.join(directusDir, 'template');
+                // const s = spinner()
+                // s.start(`Attempting to apply template from: ${templatePath}`)
+                // ux.log(`Attempting to apply template from: ${templatePath}`)
+                await apply_1.default.run([
+                    '--directusUrl=http://localhost:8055',
+                    '-p',
+                    '--userEmail=admin@example.com',
+                    '--userPassword=d1r3ctu5',
+                    '--templateLocation=' + templatePath,
+                ]);
+                // s.stop('Template applied!')
+            }
+            catch (error) {
+                core_1.ux.error('Failed to start Directus containers or apply template');
+                throw error;
+            }
+        }
+        // Install dependencies for frontend if it exists
+        if (flags.installDeps && node_fs_1.default.existsSync(frontendDir)) {
+            const s = (0, prompts_1.spinner)();
+            s.start('Installing dependencies');
+            // ux.action.start('Installing dependencies')
+            try {
+                const packageManager = await (0, nypm_1.detectPackageManager)(frontendDir);
+                await (0, nypm_1.installDependencies)({
+                    cwd: frontendDir,
+                    packageManager,
+                    silent: true,
+                });
+            }
+            catch (error) {
+                core_1.ux.warn('Failed to install dependencies');
+                throw error;
+            }
+            // ux.action.stop()
+            s.stop('Dependencies installed!');
+        }
+        // Initialize Git repo
+        if (flags.gitInit) {
+            const s = (0, prompts_1.spinner)();
+            s.start('Initializing git repository');
+            // ux.action.start('Initializing git repository')
+            await initGit(dir);
+            // ux.action.stop()
+            s.stop('Git repository initialized!');
+        }
+        // Finishing up
+        const relativeDir = node_path_1.default.relative(process.cwd(), dir);
+        const nextSteps = `- Directus is running on http://localhost:8055 \n- Navigate to your project directory using ${chalk_1.default.cyan(`cd ${relativeDir}`)} and start developing! \n- Review the \`./README.md\` file for next steps.`;
+        (0, prompts_1.note)(nextSteps, 'Next Steps');
+        // ux.log('You\'ll find the following directories in your project:')
+        // ux.log('• directus')
+        // ux.log(`• ${flags.frontend}`)
+        (0, prompts_1.outro)(`Problems? Join the community on Discord at ${chalk_1.default.underline(chalk_1.default.cyan('https://directus.chat'))}`);
+    }
+    catch (error) {
+        (0, catch_error_1.default)(error, {
+            context: { dir, flags, function: 'init' },
+            fatal: true,
+            logToFile: true,
+        });
+    }
+    return {
+        directusDir,
+        frontendDir,
+        template,
+    };
+}
+exports.init = init;
+/**
+ * Initialize a git repository
+ * @param targetDir - The directory to initialize the git repository in
+ * @returns void
+ */
+async function initGit(targetDir) {
+    try {
+        // ux.action.start('Initializing git repository')
+        const { execa } = await Promise.resolve().then(() => tslib_1.__importStar(require('execa')));
+        await execa('git', ['init'], { cwd: targetDir });
+        // ux.action.stop()
+    }
+    catch (error) {
+        (0, catch_error_1.default)(error, {
+            context: { function: 'initGit', targetDir },
+            fatal: false,
+            logToFile: true,
+        });
+    }
+}

package/dist/lib/init/types.d.ts

@@ -0,0 +1,30 @@
+export interface InitOptions {
+    frontend?: string;
+    initGit?: boolean;
+    installDeps?: boolean;
+    programmatic?: boolean;
+    targetDir: string;
+    template: string;
+}
+export interface TemplateInfo {
+    frontends: string[];
+    hasDirectus: boolean;
+    name: string;
+}
+export interface InitResult {
+    directusUrl?: string;
+    error?: Error;
+    success: boolean;
+}
+export interface DirectusConfig {
+    adminEmail: string;
+    adminPassword: string;
+    port: number;
+    url: string;
+}
+export interface DockerConfig {
+    composeFile: string;
+    healthCheckEndpoint: string;
+    interval: number;
+    maxAttempts: number;
+}

package/dist/lib/init/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/load/load-collections.d.ts

@@ -1,4 +1,6 @@
 /**
  * Load collections into the Directus instance
+ * @param dir - The directory to read the collections and fields from
+ * @returns {Promise<void>} - Returns nothing
  */
 export default function loadCollections(dir: string): Promise<void>;

package/dist/lib/load/load-collections.js

@@ -9,6 +9,8 @@ const catch_error_1 = tslib_1.__importDefault(require("../utils/catch-error"));
 const read_file_1 = tslib_1.__importDefault(require("../utils/read-file"));
 /**
  * Load collections into the Directus instance
+ * @param dir - The directory to read the collections and fields from
+ * @returns {Promise<void>} - Returns nothing
  */
 async function loadCollections(dir) {
     const collectionsToAdd = (0, read_file_1.default)('collections', dir);

package/dist/lib/utils/animated-bunny.d.ts

@@ -0,0 +1,2 @@
+export declare const RANDOM_SAYINGS: string[];
+export declare function animatedBunny(customMessage?: string): Promise<void>;

package/dist/lib/utils/animated-bunny.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.animatedBunny = exports.RANDOM_SAYINGS = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_update_1 = tslib_1.__importDefault(require("log-update"));
+const constants_1 = require("../constants");
+exports.RANDOM_SAYINGS = [
+    'One does not simply write backends...',
+    'I don\'t always test my code, but when I do, I use production.',
+    'A wild Directus appears!',
+    'Error 418: I\'m a teapot. Just kidding, I\'m Directus and I\'ve got your backend covered.',
+    'I\'ll fix it later. Narrator: They didn\'t fix it later.',
+];
+async function animatedBunny(customMessage) {
+    const saying = customMessage || exports.RANDOM_SAYINGS[Math.floor(Math.random() * exports.RANDOM_SAYINGS.length)];
+    let typedSaying = '';
+    let blinkState = true;
+    let charIndex = 0;
+    let isCleanedUp = false;
+    const cleanup = () => {
+        if (isCleanedUp)
+            return;
+        isCleanedUp = true;
+        clearInterval(animation);
+        clearInterval(typing);
+        log_update_1.default.done();
+    };
+    // Ensure cleanup on process exit
+    process.on('exit', cleanup);
+    process.on('SIGINT', () => {
+        cleanup();
+        process.exit(0);
+    });
+    const updateFrame = () => {
+        if (isCleanedUp)
+            return;
+        const eyes = blinkState ? '• •' : '- -';
+        const frame = `
+(\\(\\
+( ${eyes}) ${chalk_1.default.dim('.')}${chalk_1.default.hex(constants_1.DIRECTUS_PINK).visible(`"${typedSaying}"`)}
+o_(")(")
+`;
+        (0, log_update_1.default)(frame);
+    };
+    const animation = setInterval(() => {
+        blinkState = !blinkState;
+        updateFrame();
+    }, 500);
+    const typing = setInterval(() => {
+        if (charIndex < saying.length) {
+            typedSaying += saying[charIndex];
+            charIndex++;
+            updateFrame();
+        }
+        else {
+            clearInterval(typing);
+        }
+    }, 10);
+    try {
+        // Run the animation for the duration of typing plus 1 second
+        await new Promise(resolve => setTimeout(resolve, saying.length * 10 + 1000));
+    }
+    finally {
+        cleanup();
+        // Remove the event listeners
+        process.removeListener('exit', cleanup);
+        process.removeListener('SIGINT', cleanup);
+    }
+}
+exports.animatedBunny = animatedBunny;

package/dist/lib/utils/ensure-dir.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureDir(dir: string): void;
+export declare function ensureDirSync(dir: string): void;

package/dist/lib/utils/ensure-dir.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDirSync = exports.ensureDir = void 0;
+const node_fs_1 = require("node:fs");
+function ensureDir(dir) {
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+}
+exports.ensureDir = ensureDir;
+function ensureDirSync(dir) {
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+}
+exports.ensureDirSync = ensureDirSync;

package/dist/lib/utils/get-template.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const giget_1 = require("giget");
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const constants_1 = require("../constants");
 const path_1 = tslib_1.__importDefault(require("./path"));
 const read_templates_1 = require("./read-templates");
 const transform_github_url_1 = require("./transform-github-url");
@@ -14,7 +15,7 @@ async function getCommunityTemplates() {
         throw new Error(`Invalid download directory: ${node_path_1.default.join(__dirname, '..', 'downloads', 'official')}`);
     }
     try {
-        const { dir } = await (0, giget_1.downloadTemplate)('github:directus-labs/directus-templates', {
+        const { dir } = await (0, giget_1.downloadTemplate)(constants_1.COMMUNITY_TEMPLATE_REPO.string, {
             dir: downloadDir,
             force: true,
         });

package/dist/lib/utils/parse-github-url.d.ts

@@ -0,0 +1,14 @@
+interface GitHubUrlParts {
+    owner: string;
+    path?: string;
+    ref?: string;
+    repo: string;
+}
+/**
+   * Parse a GitHub URL into its components.
+   * @param url - The GitHub URL to parse.
+   * @returns The parsed GitHub URL components.
+   */
+export declare function parseGitHubUrl(url: string): GitHubUrlParts;
+export declare function createGigetString({ owner, path, ref, repo }: GitHubUrlParts): string;
+export {};

package/dist/lib/utils/parse-github-url.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGigetString = exports.parseGitHubUrl = void 0;
+const constants_1 = require("../constants");
+/**
+   * Parse a GitHub URL into its components.
+   * @param url - The GitHub URL to parse.
+   * @returns The parsed GitHub URL components.
+   */
+function parseGitHubUrl(url) {
+    // Handle simple template names by using default repo
+    if (!url.includes('/')) {
+        return { ...constants_1.DEFAULT_REPO, path: url };
+    }
+    // Handle different GitHub URL formats:
+    // - https://github.com/owner/repo
+    // - https://github.com/owner/repo/tree/branch
+    // - https://github.com/owner/repo/tree/branch/path
+    // - owner/repo
+    // - owner/repo/path
+    try {
+        if (url.startsWith('https://github.com/')) {
+            url = url.replace('https://github.com/', '');
+        }
+        const parts = url.split('/');
+        const owner = parts[0];
+        const repo = parts[1];
+        let path = '';
+        let ref;
+        if (parts.length > 2) {
+            if (parts[2] === 'tree' && parts.length > 3) {
+                ref = parts[3];
+                path = parts.slice(4).join('/');
+            }
+            else {
+                path = parts.slice(2).join('/');
+            }
+        }
+        return { owner, path, ref, repo };
+    }
+    catch {
+        throw new Error(`Invalid GitHub URL format: ${url}`);
+    }
+}
+exports.parseGitHubUrl = parseGitHubUrl;
+function createGigetString({ owner, path, ref, repo }) {
+    let source = `github:${owner}/${repo}`;
+    if (path)
+        source += `/${path}`;
+    if (ref)
+        source += `#${ref}`;
+    return source;
+}
+exports.createGigetString = createGigetString;

package/dist/lib/utils/wait.d.ts

@@ -0,0 +1,7 @@
+interface WaitOptions {
+    errorMessage?: string;
+    interval?: number;
+    maxAttempts?: number;
+}
+export declare function waitFor(checkFn: () => Promise<boolean>, options?: WaitOptions): Promise<boolean>;
+export {};

package/dist/lib/utils/wait.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = void 0;
+async function waitFor(checkFn, options = {}) {
+    const { errorMessage = 'Operation timed out', interval = 2000, maxAttempts = 30, } = options;
+    for (let i = 0; i < maxAttempts; i++) {
+        if (await checkFn())
+            return true;
+        await new Promise(resolve => setTimeout(resolve, interval));
+    }
+    throw new Error(errorMessage);
+}
+exports.waitFor = waitFor;

package/dist/services/docker.d.ts

@@ -0,0 +1,23 @@
+export interface DockerConfig {
+    composeFile: string;
+    healthCheckEndpoint: string;
+    interval: number;
+    maxAttempts: number;
+}
+export interface DockerService {
+    checkDocker: () => Promise<DockerCheckResult>;
+    startContainers: (cwd: string) => Promise<void>;
+    stopContainers: (cwd: string) => Promise<void>;
+    waitForHealthy: (healthCheckUrl: string) => Promise<boolean>;
+}
+export interface DockerCheckResult {
+    installed: boolean;
+    message?: string;
+    running: boolean;
+}
+/**
+ * Create a Docker service instance
+ * @param {DockerConfig} config - The Docker configuration
+ * @returns {DockerService} - Returns a Docker service instance
+ */
+export declare function createDocker(config: DockerConfig): DockerService;

package/dist/services/docker.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDocker = void 0;
+const tslib_1 = require("tslib");
+const prompts_1 = require("@clack/prompts");
+const execa_1 = require("execa");
+const catch_error_1 = tslib_1.__importDefault(require("../lib/utils/catch-error"));
+const wait_1 = require("../lib/utils/wait");
+/**
+ * Check if Docker is installed and running
+ * @returns {Promise<DockerCheckResult>} Docker installation and running status
+ */
+async function checkDocker() {
+    try {
+        // Check if Docker is installed
+        const versionResult = await (0, execa_1.execa)('docker', ['--version']);
+        const isInstalled = versionResult.exitCode === 0;
+        if (!isInstalled) {
+            return { installed: false, message: 'Docker is not installed. Please install Docker at https://docs.docker.com/get-started/get-docker/', running: false };
+        }
+        // Check if Docker daemon is running
+        const statusResult = await (0, execa_1.execa)('docker', ['info']);
+        const isRunning = statusResult.exitCode === 0;
+        return {
+            installed: true,
+            message: 'Docker is installed and running.',
+            running: isRunning,
+        };
+    }
+    catch {
+        // If any command fails, Docker is either not installed or not running
+        return {
+            installed: false,
+            message: 'Docker is not running. Please start Docker and try again.',
+            running: false,
+        };
+    }
+}
+/**
+ * Start Docker containers using docker-compose
+ * @param {string} cwd - The current working directory
+ * @returns {Promise<void>} - Returns nothing
+ */
+function startContainers(cwd) {
+    try {
+        // ux.action.start('Starting Docker containers')
+        const s = (0, prompts_1.spinner)();
+        s.start('Starting Docker containers');
+        return (0, execa_1.execa)('docker-compose', ['up', '-d'], {
+            cwd,
+            // stdio: 'inherit',
+        }).then(() => {
+            s.stop('Docker containers running!');
+        });
+    }
+    catch (error) {
+        (0, catch_error_1.default)(error, {
+            context: { cwd, function: 'startContainers' },
+            fatal: true,
+            logToFile: true,
+        });
+        return Promise.reject(error);
+    }
+}
+/**
+ * Stop Docker containers
+ * @param {string} cwd - The current working directory
+ * @returns {Promise<void>} - Returns nothing
+ */
+function stopContainers(cwd) {
+    try {
+        return (0, execa_1.execa)('docker-compose', ['down'], {
+            cwd,
+            // stdio: 'inherit',
+        }).then(() => { });
+    }
+    catch (error) {
+        (0, catch_error_1.default)(error, {
+            context: { cwd, function: 'stopContainers' },
+            fatal: false,
+            logToFile: true,
+        });
+        return Promise.reject(error);
+    }
+}
+/**
+ * Wait for service health check to pass
+ * @param {DockerConfig} config - The Docker configuration
+ * @returns {Promise<boolean>} - Returns true if the service is healthy, false otherwise
+ */
+function createWaitForHealthy(config) {
+    async function waitForHealthy(healthCheckUrl) {
+        const s = (0, prompts_1.spinner)();
+        s.start('Waiting for Directus to be ready.');
+        try {
+            await (0, wait_1.waitFor)(async () => {
+                try {
+                    const response = await fetch(healthCheckUrl);
+                    return response.ok;
+                }
+                catch {
+                    return false;
+                }
+            }, {
+                errorMessage: 'Service failed to become healthy',
+                interval: config.interval,
+                maxAttempts: config.maxAttempts,
+            });
+            s.stop('Directus is ready!');
+            return true;
+        }
+        catch (error) {
+            s.stop('');
+            (0, catch_error_1.default)(error, {
+                context: { function: 'waitForHealthy', url: healthCheckUrl },
+                fatal: true,
+                logToFile: true,
+            });
+            return false;
+        }
+    }
+    return waitForHealthy;
+}
+/**
+ * Create a Docker service instance
+ * @param {DockerConfig} config - The Docker configuration
+ * @returns {DockerService} - Returns a Docker service instance
+ */
+function createDocker(config) {
+    return {
+        checkDocker,
+        startContainers,
+        stopContainers,
+        waitForHealthy: createWaitForHealthy(config),
+    };
+}
+exports.createDocker = createDocker;

package/dist/services/github.d.ts

@@ -0,0 +1,18 @@
+import { parseGitHubUrl } from '../lib/utils/parse-github-url';
+interface GitHubUrlParts {
+    owner: string;
+    path?: string;
+    ref?: string;
+    repo: string;
+}
+export interface GitHubService {
+    getTemplateDirectories(template: string, customUrl?: string): Promise<string[]>;
+    getTemplates(customUrl?: string): Promise<string[]>;
+    parseGitHubUrl(url: string): GitHubUrlParts;
+}
+export declare function createGitHub(token?: string): {
+    getTemplateDirectories: (template: string, customUrl?: string) => Promise<string[]>;
+    getTemplates: (customUrl?: string) => Promise<string[]>;
+    parseGitHubUrl: typeof parseGitHubUrl;
+};
+export {};

package/dist/services/github.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitHub = void 0;
+const rest_1 = require("@octokit/rest");
+const constants_1 = require("../lib/constants");
+const parse_github_url_1 = require("../lib/utils/parse-github-url");
+function createGitHub(token) {
+    const octokit = new rest_1.Octokit({
+        auth: token,
+    });
+    /**
+     * Get the directories for a template.
+     * @param template - The template to get the directories for.
+     * @param customUrl - The custom URL to get the directories for.
+     * @returns The directories for the template.
+     */
+    async function getTemplateDirectories(template, customUrl) {
+        const repo = customUrl ? (0, parse_github_url_1.parseGitHubUrl)(customUrl) : constants_1.DEFAULT_REPO;
+        const templatePath = repo.path ? `${repo.path}/${template}` : template;
+        const { data } = await octokit.rest.repos.getContent({
+            owner: repo.owner,
+            path: templatePath,
+            ref: repo.ref,
+            repo: repo.repo,
+        });
+        if (!Array.isArray(data))
+            return [];
+        return data
+            .filter(item => item.type === 'dir' && item.name !== 'directus')
+            .map(item => item.name);
+    }
+    /**
+     * Get the templates for a repository.
+     * @param customUrl - The custom URL to get the templates for.
+     * @returns The templates for the repository.
+     */
+    async function getTemplates(customUrl) {
+        const repo = customUrl ? (0, parse_github_url_1.parseGitHubUrl)(customUrl) : constants_1.DEFAULT_REPO;
+        const { data } = await octokit.rest.repos.getContent({
+            owner: repo.owner,
+            path: repo.path || '',
+            ref: repo.ref,
+            repo: repo.repo,
+        });
+        if (!Array.isArray(data))
+            return [];
+        return data
+            .filter(item => item.type === 'dir')
+            .map(item => item.name);
+    }
+    return {
+        getTemplateDirectories,
+        getTemplates,
+        parseGitHubUrl: parse_github_url_1.parseGitHubUrl,
+    };
+}
+exports.createGitHub = createGitHub;