import {createCLI} from 'tinycreate';
import {dirname, join} from 'path';
import {fileURLToPath} from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

const config = {
  welcomeMessage: '🎉 Welcome to My Generator!\n',

  questions: [
    {
      type: 'text',
      name: 'projectName',
      message: 'Project name:',
      initial: 'my-app',
    },
    {
      type: 'select',
      name: 'language',
      message: 'Language:',
      choices: [
        {title: 'TypeScript', value: 'typescript'},
        {title: 'JavaScript', value: 'javascript'},
      ],
    },
  ],

  createContext: (answers) => ({
    projectName: answers.projectName,
    isTypescript: answers.language === 'typescript',
    ext: answers.language === 'typescript' ? 'ts' : 'js',
  }),

  getFiles: (context) => [
    {
      template: 'templates/App.tsx.hbs',
      output: `src/App.${context.ext}`,
      prettier: true,
      transpile: context.isTypescript === false,
    },
  ],

  templateRoot: __dirname,

  onSuccess: (projectName) => {
    console.log(`✅ Created ${projectName}!`);
    console.log(`\nNext steps:`);
    console.log(`  cd ${projectName}`);
    console.log(`  npm install`);
    console.log(`  npm run dev`);
  },
};

await createCLI(config);

import React from 'react';
import type {FC} from 'react';

export const Component = () => {
  return <div>Hello</div>;
};

interface ProjectConfig {
  // Optional welcome message shown before prompts
  welcomeMessage?: string;

  // Array of question objects (text, select, or confirm)
  questions: Question[];

  // Transform user answers into template context
  createContext: (answers: Record<string, unknown>) => TemplateContext;

  // Return array of files to generate
  getFiles: (context: TemplateContext) => FileConfig[] | Promise<FileConfig[]>;

  // Optional: Process included files before rendering
  processIncludedFile?: (
    file: FileConfig,
    context: TemplateContext,
  ) => FileConfig;

  // Root directory containing templates
  templateRoot: string;

  // Optional: Create custom directories
  createDirectories?: (
    targetDir: string,
    context: TemplateContext,
  ) => Promise<void>;

  // Optional: Custom install command (default: auto-detected package manager)
  installCommand?: string;

  // Optional: Custom dev command
  devCommand?: string;

  // Optional: Success callback after project creation
  onSuccess?: (
    projectName: string,
    context: TemplateContext,
  ) => void | Promise<void>;
}

interface CLIOptions {
  // Enable non-interactive mode for CI/CD
  nonInteractive?: boolean;

  // Custom CLI arguments (defaults to process.argv.slice(2))
  args?: string[];
}

interface Question {
  // Question type (or function returning type based on previous answers)
  type:
    | 'text'
    | 'select'
    | 'confirm'
    | ((
        prev: unknown,
        answers: Record<string, unknown>,
      ) => 'text' | 'select' | 'confirm' | null);

  // Answer key name
  name: string;

  // Question prompt
  message: string;

  // Default value
  initial?: string | number | boolean;

  // Choices for 'select' type
  choices?: Array<{title: string; value: string | boolean}>;

  // Validation function for 'text' type
  validate?: (value: string) => boolean | string;
}

interface FileConfig {
  // Path to Handlebars template (relative to templateRoot)
  template: string;

  // Output path (supports template variables like {{projectName}})
  output: string;

  // Enable Prettier formatting (default: false)
  prettier?: boolean;

  // Enable TypeScript to JavaScript transpilation (default: false)
  transpile?: boolean;

  // Internal: processed content (set by engine)
  processedContent?: string;
}

import {postProcessFile, postProcessProject} from 'tinycreate';

// Process a single file
const {filePath, content} = await postProcessFile('src/App.tsx', fileContent, {
  prettier: true,
  transpileToJS: true,
});

// Process multiple files
const processedFiles = await postProcessProject('/path/to/project', filesMap, {
  prettier: true,
  transpileToJS: false,
});

{
  type: (prev, answers) =>
    answers.language === 'typescript' ? 'confirm' : null,
  name: 'strictMode',
  message: 'Enable strict mode?',
  initial: true,
}

getFiles: (context) => {
  const files = [{template: 'App.tsx.hbs', output: 'src/App.tsx'}];

  if (context.includeTests) {
    files.push({
      template: 'App.test.tsx.hbs',
      output: 'src/App.test.tsx',
    });
  }

  return files;
};

createDirectories: async (targetDir, context) => {
  const {mkdir} = await import('fs/promises');

  await mkdir(join(targetDir, 'src', 'components'), {recursive: true});
  await mkdir(join(targetDir, 'public'), {recursive: true});

  if (context.includeServer) {
    await mkdir(join(targetDir, 'server'), {recursive: true});
  }
};

processIncludedFile: (file, context) => {
  // Force all component files to be formatted
  if (file.output.includes('components/')) {
    return {...file, prettier: true};
  }
  return file;
};