create-krispya 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { GenerateDreiOptions } from "./integrations/drei.js";
+import { GenerateFiberOptions } from "./integrations/fiber.js";
+import { GenerateGithubPagesOptions } from "./integrations/github-pages.js";
+import { GenerateHandleOptions } from "./integrations/handle.js";
+import { GenerateKootaOptions } from "./integrations/koota.js";
+import { GenerateLevaOptions } from "./integrations/leva.js";
+import { GenerateOffscreenOptions } from "./integrations/offscreen.js";
+import { GeneratePostprocessingOptions } from "./integrations/postprocessing.js";
+import { GenerateRapierOptions } from "./integrations/rapier.js";
+import { GenerateUikitOptions } from "./integrations/uikit.js";
+import { GenerateXrOptions } from "./integrations/xr.js";
+import { GenerateZustandOptions } from "./integrations/zustand.js";
+import { GenerateTriplexOptions } from "./integrations/triplex.js";
+import { GenerateViverseOptions } from "./integrations/viverse.js";
+export * from "./utils.js";
+export type Template = "vanilla" | "vanilla-js" | "react" | "react-js" | "r3f" | "r3f-js";
+export type BaseTemplate = "vanilla" | "react" | "r3f";
+export declare function getLanguageFromTemplate(template: Template): "javascript" | "typescript";
+export declare function getBaseTemplate(template: Template): BaseTemplate;
+export type PackageVersions = {
+    vite?: string;
+    eslint?: string;
+    oxlint?: string;
+    oxfmt?: string;
+    prettier?: string;
+    biome?: string;
+};
+export type GenerateOptions = {
+    githubUserName?: string;
+    githubRepoName?: string;
+    name: string;
+    template?: Template;
+    linter?: Linter;
+    formatter?: Formatter;
+    versions?: PackageVersions;
+    fiber?: GenerateFiberOptions;
+    handle?: GenerateHandleOptions;
+    drei?: GenerateDreiOptions;
+    koota?: GenerateKootaOptions;
+    leva?: GenerateLevaOptions;
+    offscreen?: GenerateOffscreenOptions;
+    postprocessing?: GeneratePostprocessingOptions;
+    rapier?: GenerateRapierOptions;
+    triplex?: GenerateTriplexOptions;
+    viverse?: GenerateViverseOptions;
+    uikit?: GenerateUikitOptions;
+    xr?: GenerateXrOptions;
+    zustand?: GenerateZustandOptions;
+    githubPages?: GenerateGithubPagesOptions;
+    dependencies?: Record<string, string>;
+    files?: Record<string, File>;
+    injections?: Array<{
+        location: CodeInjectionLocation;
+        code: string;
+    }>;
+    replacements?: Array<{
+        search: string;
+        replace: string;
+    }>;
+    packageManager?: string;
+    pnpmVersion?: string;
+    pnpmManageVersions?: boolean;
+    nodeVersion?: string;
+};
+export type File = {
+    type: "text";
+    content: string;
+} | {
+    type: "remote";
+    url: string;
+};
+export type Linter = "eslint" | "oxlint" | "biome";
+export type Formatter = "prettier" | "oxfmt" | "biome";
+export type CodeInjectionLocation = "vite-config-import" | "import" | "global-start" | "global-end" | "dom-start" | "dom" | "dom-end" | "scene-start" | "scene" | "scene-end" | "readme-start" | "readme-end" | "readme-libraries" | "readme-tools" | "readme-commands" | "vscode-extension-suggestion" | "vscode-setting";
+export type Generator = {
+    get options(): GenerateOptions;
+    get versions(): PackageVersions;
+    addDependency(name: string, semver: string): void;
+    addFile(path: string, file: File): void;
+    addScript(name: string, command: string): void;
+    inject(location: CodeInjectionLocation, code: string): void;
+    replace(search: string, replace: string): void;
+    configureVite(object: any): void;
+    addVscodeSetting(key: string, value: unknown): void;
+};
+export declare function generate(options: GenerateOptions): Record<string, File>;

package/dist/index.js

@@ -0,0 +1,394 @@
+import { GitAttributes, HtmlContent, IndexContent, ViteHtmlContent, ViteIndexContent, ViteStyleContent, } from "./constants.js";
+import { generateBiome } from "./integrations/biome.js";
+import { generateDrei } from "./integrations/drei.js";
+import { generateEslint } from "./integrations/eslint.js";
+import { generateFiber } from "./integrations/fiber.js";
+import { generateGithubPages } from "./integrations/github-pages.js";
+import { generateHandle } from "./integrations/handle.js";
+import { generateKoota } from "./integrations/koota.js";
+import { generateLeva } from "./integrations/leva.js";
+import { generateOffscreen } from "./integrations/offscreen.js";
+import { generateOxfmt } from "./integrations/oxfmt.js";
+import { generateOxlint } from "./integrations/oxlint.js";
+import { generatePostprocessing, } from "./integrations/postprocessing.js";
+import { generatePrettier } from "./integrations/prettier.js";
+import { generateRapier } from "./integrations/rapier.js";
+import { generateUikit } from "./integrations/uikit.js";
+import { generateXr } from "./integrations/xr.js";
+import { generateZustand } from "./integrations/zustand.js";
+import { generateTriplex } from "./integrations/triplex.js";
+import { merge } from "./merge.js";
+import { generateViverse } from "./integrations/viverse.js";
+export * from "./utils.js";
+export function getLanguageFromTemplate(template) {
+    return template.endsWith("-js") ? "javascript" : "typescript";
+}
+export function getBaseTemplate(template) {
+    return template.replace("-js", "");
+}
+export function generate(options) {
+    //deep cloning since integrations might decide to modify the options
+    const clonedOptions = structuredClone(options);
+    const template = clonedOptions.template ?? "vanilla";
+    const baseTemplate = getBaseTemplate(template);
+    const language = getLanguageFromTemplate(template);
+    const isVanilla = baseTemplate === "vanilla";
+    const isReact = baseTemplate === "react";
+    const isR3f = baseTemplate === "r3f";
+    const files = {
+        ...clonedOptions.files,
+    };
+    const replacements = clonedOptions.replacements ?? [];
+    // Base dependencies - always include vite
+    const versions = clonedOptions.versions ?? {};
+    const dependencies = {
+        vite: versions.vite ? `^${versions.vite}` : "^6.3.4",
+        ...clonedOptions.dependencies,
+    };
+    // Add React dependencies for react and r3f templates
+    if (isReact || isR3f) {
+        dependencies["react"] = "^19.0.0";
+        dependencies["react-dom"] = "^19.0.0";
+        dependencies["@vitejs/plugin-react"] = "^4.4.1";
+    }
+    // Add Three.js dependencies for r3f template
+    if (isR3f) {
+        dependencies["three"] = "~0.175.0";
+        dependencies["@react-three/fiber"] = "^9.0.0";
+    }
+    // TypeScript configuration
+    if (language === "typescript") {
+        const tsConfig = {
+            compilerOptions: {
+                target: "ESNext",
+                module: "ESNext",
+                moduleResolution: "bundler",
+                esModuleInterop: true,
+                strict: true,
+                skipLibCheck: true,
+                outDir: "dist",
+            },
+            include: ["src/**/*"],
+        };
+        // Add JSX config for React templates
+        if (isReact || isR3f) {
+            tsConfig.compilerOptions.jsx = "react-jsx";
+            dependencies["@types/react"] = "^19.0.0";
+            dependencies["@types/react-dom"] = "^19.0.0";
+        }
+        // Add Three.js types for r3f
+        if (isR3f) {
+            dependencies["@types/three"] = "~0.175.0";
+        }
+        files["tsconfig.json"] = {
+            type: "text",
+            content: JSON.stringify(tsConfig, null, 2),
+        };
+    }
+    const codeSnippets = {};
+    const vscodeSettings = {};
+    const scripts = {
+        dev: "vite",
+        build: "vite build",
+    };
+    // Setup vite config imports based on template
+    if (isReact || isR3f) {
+        codeSnippets["vite-config-import"] = ["import react from '@vitejs/plugin-react'"];
+    }
+    // Setup R3F-specific imports
+    if (isR3f) {
+        codeSnippets["import"] = [`import { Canvas } from "@react-three/fiber"`];
+    }
+    const defaultName = isVanilla ? "vanilla-app" : isReact ? "react-app" : "react-three-app";
+    const name = clonedOptions.name ?? defaultName;
+    // Build vite config based on template
+    let viteConfig = {
+        base: "./",
+    };
+    if (isReact || isR3f) {
+        viteConfig.plugins = ["$raw:react()"];
+    }
+    if (isR3f) {
+        viteConfig.resolve = { dedupe: ["three"] };
+    }
+    const generator = {
+        options: clonedOptions,
+        versions,
+        addDependency(name, semver) {
+            const existingSemver = dependencies[name];
+            if (existingSemver != null) {
+                //TODO: intersect existingSemver with semver and write to semver
+                //TODO: throw error if no overlap
+            }
+            dependencies[name] = semver;
+        },
+        addFile(path, content) {
+            files[path] = content;
+        },
+        addScript(name, command) {
+            scripts[name] = command;
+        },
+        inject(location, code) {
+            let entries = codeSnippets[location];
+            if (entries == null) {
+                codeSnippets[location] = entries = [];
+            }
+            entries.push(code);
+        },
+        replace(search, replace) {
+            replacements.push({ search, replace });
+        },
+        configureVite(config) {
+            viteConfig = merge(viteConfig, config);
+        },
+        addVscodeSetting(key, value) {
+            vscodeSettings[key] = value;
+        },
+    };
+    // Only run R3F integrations for r3f template
+    if (isR3f) {
+        generateDrei(generator, clonedOptions.drei);
+        generateHandle(generator, clonedOptions.handle);
+        generateKoota(generator, clonedOptions.koota);
+        generateLeva(generator, clonedOptions.leva);
+        generateOffscreen(generator, clonedOptions.offscreen);
+        generatePostprocessing(generator, clonedOptions.postprocessing);
+        generateRapier(generator, clonedOptions.rapier);
+        generateUikit(generator, clonedOptions.uikit);
+        generateXr(generator, clonedOptions.xr);
+        generateZustand(generator, clonedOptions.zustand);
+        generateFiber(generator, clonedOptions.fiber);
+        generateTriplex(generator, clonedOptions.triplex);
+        generateViverse(generator, clonedOptions.viverse);
+    }
+    // GitHub Pages works for all templates
+    generateGithubPages(generator, clonedOptions.githubPages);
+    // Linter and formatter integrations
+    const linter = clonedOptions.linter;
+    const formatter = clonedOptions.formatter;
+    // Generate linter integrations
+    if (linter === "eslint") {
+        generateEslint(generator, true);
+        generator.addVscodeSetting("biome.enabled", false);
+        generator.addVscodeSetting("oxc.enable", false);
+    }
+    else if (linter === "oxlint") {
+        generateOxlint(generator, true);
+        generator.addVscodeSetting("eslint.enable", false);
+        generator.addVscodeSetting("biome.enabled", false);
+    }
+    else if (linter === "biome") {
+        generateBiome(generator, { linter: true, formatter: formatter === "biome" });
+        generator.addVscodeSetting("eslint.enable", false);
+        generator.addVscodeSetting("oxc.enable", false);
+    }
+    // Generate formatter integrations (skip biome if already handled above)
+    if (formatter === "prettier") {
+        generatePrettier(generator, true);
+    }
+    else if (formatter === "oxfmt") {
+        generateOxfmt(generator, true);
+    }
+    else if (formatter === "biome" && linter !== "biome") {
+        // Only generate biome for formatting if it wasn't already generated for linting
+        generateBiome(generator, { linter: false, formatter: true });
+        generator.addVscodeSetting("eslint.enable", false);
+        generator.addVscodeSetting("oxc.enable", false);
+    }
+    for (const { code, location } of clonedOptions.injections ?? []) {
+        generator.inject(location, code);
+    }
+    // Generate vite.config.js
+    const viteConfigContent = [
+        `import { defineConfig } from 'vite'`,
+        ...(codeSnippets["vite-config-import"] ?? []),
+        `export default defineConfig(${JSON.stringify(viteConfig).replace(/"\$raw:([^"]+)"/g, (_, raw) => raw)})`,
+    ].join("\n");
+    files["vite.config.js"] = { type: "text", content: viteConfigContent };
+    const packageManager = options.packageManager ?? "pnpm";
+    const isPnpm = packageManager === "pnpm";
+    // Build package.json with conditional pnpm-specific fields
+    const packageJson = {
+        name,
+        type: "module",
+        dependencies,
+        scripts,
+    };
+    // Add engines field if needed
+    const engines = {};
+    if (isPnpm) {
+        const pnpmVersion = options.pnpmVersion ?? "10.11.0";
+        const majorVersion = pnpmVersion.split(".")[0];
+        engines.pnpm = `>=${majorVersion}.0.0`;
+        packageJson.packageManager = `pnpm@${pnpmVersion}`;
+    }
+    if (options.nodeVersion) {
+        const majorVersion = options.nodeVersion.split(".")[0];
+        engines.node = `>=${majorVersion}.0.0`;
+    }
+    if (Object.keys(engines).length > 0) {
+        packageJson.engines = engines;
+    }
+    files["package.json"] = {
+        type: "text",
+        content: JSON.stringify(packageJson, null, 2),
+    };
+    // Add pnpm-workspace.yaml when pnpm is selected
+    if (isPnpm) {
+        const manageVersions = options.pnpmManageVersions ?? true;
+        const workspaceLines = [];
+        if (manageVersions) {
+            workspaceLines.push("manage-package-manager-versions: true", "");
+        }
+        workspaceLines.push("onlyBuiltDependencies:", "  - esbuild");
+        files["pnpm-workspace.yaml"] = {
+            type: "text",
+            content: workspaceLines.join("\n"),
+        };
+    }
+    files[".gitignore"] = { type: "text", content: ["node_modules", "dist"].join("\n") };
+    files[".gitattributes"] = { type: "text", content: GitAttributes };
+    codeSnippets["readme-libraries"] ??= [];
+    codeSnippets["readme-commands"] ??= [];
+    // Add library descriptions based on template
+    if (isVanilla) {
+        codeSnippets["readme-libraries"].unshift(`[Vite](https://vitejs.dev/) - Next generation frontend tooling`);
+    }
+    else if (isReact) {
+        codeSnippets["readme-libraries"].unshift(`[React](https://react.dev/) - A JavaScript library for building user interfaces`, `[Vite](https://vitejs.dev/) - Next generation frontend tooling`);
+    }
+    else {
+        codeSnippets["readme-libraries"].unshift(`[React](https://react.dev/) - A JavaScript library for building user interfaces`, `[Three.js](https://threejs.org/) - JavaScript 3D library`, `[@react-three/fiber](https://docs.pmnd.rs/react-three-fiber) - lets you create Three.js scenes using React components`);
+    }
+    codeSnippets["readme-commands"].unshift(`\`${packageManager} install\` to install the dependencies`, `\`${packageManager} run dev\` to run the development server and preview the app with live updates`, `\`${packageManager} run build\` to build the app into the \`dist\` folder`);
+    // Generate template-specific architecture description
+    const ext = language === "javascript" ? "js" : "ts";
+    const jsxExt = language === "javascript" ? "jsx" : "tsx";
+    let architectureDesc;
+    if (isVanilla) {
+        architectureDesc = [
+            `- \`src/main.${ext}\` is the entry point for your application`,
+            `- Static assets can be placed in the \`public\` folder`,
+        ];
+    }
+    else if (isReact) {
+        architectureDesc = [
+            `- \`src/app.${jsxExt}\` defines the main application component`,
+            `- \`src/index.${jsxExt}\` renders the React app into the DOM`,
+            `- Static assets can be placed in the \`public\` folder`,
+        ];
+    }
+    else {
+        architectureDesc = [
+            `- \`app.${jsxExt}\` defines the main application component containing your 3D content`,
+            `- Modify the content inside the \`<Canvas>\` component to change what is visible on screen`,
+            `- Static assets can be placed in the \`public\` folder`,
+        ];
+    }
+    files[`README.md`] = {
+        type: "text",
+        content: [
+            `# ${name}`,
+            `This project was generated with create-krispya`,
+            ...(codeSnippets["readme-start"] ?? []),
+            "\n",
+            `## Project Architecture`,
+            `This project uses [Vite](https://vitejs.dev/) as the bundler for fast development and optimized production builds.`,
+            ...architectureDesc,
+            "\n",
+            `## Libraries`,
+            `The following libraries are used - checkout the linked docs to learn more`,
+            ...(codeSnippets["readme-libraries"] ?? []).map((library) => `- ${library}`),
+            "\n",
+            codeSnippets["readme-tools"] && `## Tools`,
+            ...(codeSnippets["readme-tools"] ?? []).map((tool) => `- ${tool}`),
+            codeSnippets["readme-tools"] && `\n`,
+            `## Development Commands`,
+            ...(codeSnippets["readme-commands"] ?? []).map((command) => `- ${command}`),
+            ...(codeSnippets["readme-end"] ?? []),
+        ]
+            .filter(Boolean)
+            .join("\n"),
+    };
+    // Generate template-specific source files
+    if (isVanilla) {
+        // Vanilla template
+        const ext = language === "javascript" ? "js" : "ts";
+        files[`src/main.${ext}`] = { type: "text", content: ViteIndexContent };
+        files["src/style.css"] = { type: "text", content: ViteStyleContent };
+        const indexHtml = ViteHtmlContent.replace("$indexPath", `./src/main.${ext}`).replace("$title", name);
+        files["index.html"] = { type: "text", content: indexHtml };
+    }
+    else {
+        // React and R3F templates
+        files[`src/index.tsx`] = { type: "text", content: IndexContent };
+        const indexHtml = HtmlContent.replace("$indexPath", language === "javascript" ? "./src/index.jsx" : "./src/index.tsx").replace("$title", name);
+        files["index.html"] = { type: "text", content: indexHtml };
+        // Generate app.tsx
+        codeSnippets["dom-end"]?.reverse();
+        codeSnippets["global-end"]?.reverse();
+        codeSnippets["scene-end"]?.reverse();
+        let appCode;
+        if (isReact) {
+            // Simple React app without Canvas
+            appCode = [
+                ...(codeSnippets["import"] ?? []),
+                ...(codeSnippets["global-start"] ?? []),
+                `export function App() {`,
+                "  return (",
+                '    <div style={{ padding: "2rem" }}>',
+                "      <h1>Hello React!</h1>",
+                "      <p>Edit src/app.tsx and save to see changes.</p>",
+                "    </div>",
+                "  )",
+                "}",
+                ...(codeSnippets["global-end"] ?? []),
+            ].join("\n");
+        }
+        else {
+            // R3F app with Canvas
+            appCode = [
+                ...(codeSnippets["import"] ?? []),
+                ...(codeSnippets["global-start"] ?? []),
+                `export function App() {`,
+                " return <>",
+                ...(codeSnippets["dom-start"] ?? []),
+                ...(codeSnippets["dom"] ?? []),
+                "   <Canvas>",
+                ...(codeSnippets["scene-start"] ?? []),
+                ...(codeSnippets["scene"] ?? []),
+                ...(codeSnippets["scene-end"] ?? []),
+                "   </Canvas>",
+                ...(codeSnippets["dom-end"] ?? []),
+                " </>",
+                "}",
+                ...(codeSnippets["global-end"] ?? []),
+            ].join("\n");
+        }
+        for (const { search, replace } of replacements) {
+            appCode = appCode.replace(search, replace);
+        }
+        files[`src/app.tsx`] = { type: "text", content: appCode };
+    }
+    if (codeSnippets["vscode-extension-suggestion"]?.length) {
+        // Deduplicate extension recommendations
+        const uniqueRecommendations = [...new Set(codeSnippets["vscode-extension-suggestion"])];
+        files[".vscode/extensions.json"] = {
+            type: "text",
+            content: JSON.stringify({
+                recommendations: uniqueRecommendations,
+            }, null, 2),
+        };
+    }
+    if (Object.keys(vscodeSettings).length > 0) {
+        files[".vscode/settings.json"] = {
+            type: "text",
+            content: JSON.stringify(vscodeSettings, null, "\t"),
+        };
+    }
+    if (language === "javascript") {
+        //TODO: transpile tsx? to jsx? files}
+    }
+    //TODO: execute prettier on ts(x), js(x), and json files``
+    return files;
+}

package/dist/integrations/biome.d.ts

@@ -0,0 +1,8 @@
+import type { Generator } from "../index.js";
+export type GenerateBiomeOptions = {
+    /** Whether biome is used as a linter */
+    linter?: boolean;
+    /** Whether biome is used as a formatter */
+    formatter?: boolean;
+};
+export declare function generateBiome(generator: Generator, options: GenerateBiomeOptions | undefined): void;

package/dist/integrations/biome.js

@@ -0,0 +1,80 @@
+import { defaultFormatterConfig, defaultLinterConfig } from "../constants.js";
+// Helper to convert level to Biome format
+function toBiomeLevel(level) {
+    return level;
+}
+export function generateBiome(generator, options) {
+    if (options == null || (!options.linter && !options.formatter)) {
+        return;
+    }
+    const version = generator.versions.biome ?? "1.9.4";
+    generator.addDependency("@biomejs/biome", `^${version}`);
+    const { rules } = defaultLinterConfig;
+    // Build biome config based on roles
+    const biomeConfig = {
+        $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+        files: {
+            ignore: defaultLinterConfig.ignorePatterns,
+        },
+    };
+    if (options.linter) {
+        biomeConfig.linter = {
+            enabled: true,
+            rules: {
+                recommended: true,
+                correctness: {
+                    noUnusedVariables: toBiomeLevel(rules.noUnusedVars.level),
+                },
+            },
+        };
+    }
+    else {
+        biomeConfig.linter = {
+            enabled: false,
+        };
+    }
+    if (options.formatter) {
+        // Translate common formatter settings to Biome format
+        biomeConfig.formatter = {
+            enabled: true,
+            lineWidth: defaultFormatterConfig.printWidth,
+            indentWidth: defaultFormatterConfig.tabWidth,
+            indentStyle: defaultFormatterConfig.useTabs ? "tab" : "space",
+        };
+        biomeConfig.javascript = {
+            formatter: {
+                semicolons: defaultFormatterConfig.semi ? "always" : "asNeeded",
+                quoteStyle: defaultFormatterConfig.singleQuote ? "single" : "double",
+                trailingCommas: defaultFormatterConfig.trailingComma,
+                bracketSpacing: defaultFormatterConfig.bracketSpacing,
+                arrowParentheses: defaultFormatterConfig.arrowParens === "always" ? "always" : "asNeeded",
+            },
+        };
+    }
+    else {
+        biomeConfig.formatter = {
+            enabled: false,
+        };
+    }
+    generator.addFile("biome.json", {
+        type: "text",
+        content: JSON.stringify(biomeConfig, null, 2),
+    });
+    if (options.linter) {
+        generator.addScript("lint", "biome lint .");
+    }
+    if (options.formatter) {
+        generator.addScript("format", "biome format --write .");
+    }
+    const roles = [];
+    if (options.linter)
+        roles.push("linter");
+    if (options.formatter)
+        roles.push("formatter");
+    generator.inject("readme-tools", `[Biome](https://biomejs.dev/) - Fast ${roles.join(" and ")} for JavaScript and TypeScript`);
+    generator.inject("vscode-extension-suggestion", "biomejs.biome");
+    generator.addVscodeSetting("biome.enabled", true);
+    if (options.formatter) {
+        generator.addVscodeSetting("editor.defaultFormatter", "biomejs.biome");
+    }
+}

package/dist/integrations/drei.d.ts

@@ -0,0 +1,3 @@
+import type { Generator } from "../index.js";
+export type GenerateDreiOptions = {} | boolean;
+export declare function generateDrei(generator: Generator, options: GenerateDreiOptions | undefined): void;

package/dist/integrations/drei.js

@@ -0,0 +1,9 @@
+export function generateDrei(generator, options) {
+    if (options == null) {
+        return;
+    }
+    generator.addDependency("@react-three/drei", "^10.0.0");
+    generator.inject("import", `import { Environment } from "@react-three/drei"`);
+    generator.inject("scene", '<Environment background preset="city" />');
+    generator.inject("readme-libraries", `[@react-three/drei](https://drei.docs.pmnd.rs/) - Useful helpers for @react-three/fiber`);
+}

package/dist/integrations/eslint.d.ts

@@ -0,0 +1,3 @@
+import { type Generator } from "../index.js";
+export type GenerateEslintOptions = {} | boolean;
+export declare function generateEslint(generator: Generator, options: GenerateEslintOptions | undefined): void;

package/dist/integrations/eslint.js

@@ -0,0 +1,78 @@
+import { defaultLinterConfig } from "../constants.js";
+import { getBaseTemplate, getLanguageFromTemplate } from "../index.js";
+// Helper to convert level to eslint format
+function toEslintLevel(level) {
+    return level;
+}
+export function generateEslint(generator, options) {
+    if (options == null) {
+        return;
+    }
+    const version = generator.versions.eslint ?? "9.17.0";
+    generator.addDependency("eslint", `^${version}`);
+    // Add eslint flat config
+    const template = generator.options.template ?? "vanilla";
+    const baseTemplate = getBaseTemplate(template);
+    const isTypescript = getLanguageFromTemplate(template) === "typescript";
+    const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+    const { rules } = defaultLinterConfig;
+    const imports = ['import js from "@eslint/js"'];
+    const configs = ["js.configs.recommended"];
+    if (isTypescript) {
+        generator.addDependency("typescript-eslint", "^8.18.0");
+        imports.push('import tseslint from "typescript-eslint"');
+        configs.push("...tseslint.configs.recommended");
+    }
+    if (isReact) {
+        generator.addDependency("eslint-plugin-react-hooks", "^5.1.0");
+        imports.push('import reactHooks from "eslint-plugin-react-hooks"');
+    }
+    // Build ignore patterns string
+    const ignoresArray = JSON.stringify(defaultLinterConfig.ignorePatterns);
+    // Build rules object - use @typescript-eslint/no-unused-vars for TS projects
+    const unusedVarsRule = isTypescript ? "@typescript-eslint/no-unused-vars" : "no-unused-vars";
+    const rulesConfig = {
+        [unusedVarsRule]: [
+            toEslintLevel(rules.noUnusedVars.level),
+            {
+                argsIgnorePattern: rules.noUnusedVars.argsIgnorePattern,
+                varsIgnorePattern: rules.noUnusedVars.varsIgnorePattern,
+                caughtErrorsIgnorePattern: rules.noUnusedVars.caughtErrorsIgnorePattern,
+            },
+        ],
+        "no-unused-expressions": [
+            toEslintLevel(rules.noUnusedExpressions.level),
+            { allowShortCircuit: rules.noUnusedExpressions.allowShortCircuit },
+        ],
+    };
+    const rulesString = JSON.stringify(rulesConfig, null, 4).replace(/\n/g, "\n    ");
+    const configContent = [
+        ...imports,
+        "",
+        "export default [",
+        `  { ignores: ${ignoresArray} },`,
+        `  ${configs.join(",\n  ")},`,
+        isReact
+            ? `  {
+    plugins: {
+      "react-hooks": reactHooks,
+    },
+    rules: reactHooks.configs.recommended.rules,
+  },`
+            : "",
+        `  {
+    rules: ${rulesString},
+  },`,
+        "]",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    generator.addFile("eslint.config.js", {
+        type: "text",
+        content: configContent,
+    });
+    generator.addScript("lint", "eslint .");
+    generator.inject("readme-tools", "[ESLint](https://eslint.org/) - Linter for JavaScript and TypeScript");
+    generator.inject("vscode-extension-suggestion", "dbaeumer.vscode-eslint");
+    generator.addVscodeSetting("eslint.enable", true);
+}

package/dist/integrations/fiber.d.ts

@@ -0,0 +1,8 @@
+import type { Generator } from "../index.js";
+export type GenerateFiberOptions = {
+    /**
+     * @default true
+     */
+    addExample?: boolean;
+} | boolean;
+export declare function generateFiber(generator: Generator, _options: GenerateFiberOptions | undefined): void;