npm - create-krispya - Versions diffs - 0.2.0 → 0.3.0 - Mend

create-krispya 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (61) hide show

package/dist/cli.cjs +550 -0
package/dist/cli.d.cts +1 -0
package/dist/cli.d.mts +1 -0
package/dist/cli.d.ts +1 -2
package/dist/cli.mjs +531 -0
package/dist/index.cjs +1688 -0
package/dist/index.d.cts +148 -0
package/dist/index.d.mts +148 -0
package/dist/index.d.ts +88 -27
package/dist/index.mjs +1676 -0
package/package.json +6 -5
package/dist/cli.js +0 -504
package/dist/constants.d.ts +0 -33
package/dist/constants.js +0 -110
package/dist/index.js +0 -397
package/dist/integrations/biome.d.ts +0 -8
package/dist/integrations/biome.js +0 -80
package/dist/integrations/drei.d.ts +0 -3
package/dist/integrations/drei.js +0 -9
package/dist/integrations/eslint.d.ts +0 -3
package/dist/integrations/eslint.js +0 -78
package/dist/integrations/fiber.d.ts +0 -8
package/dist/integrations/fiber.js +0 -35
package/dist/integrations/github-pages.d.ts +0 -3
package/dist/integrations/github-pages.js +0 -58
package/dist/integrations/handle.d.ts +0 -3
package/dist/integrations/handle.js +0 -7
package/dist/integrations/koota.d.ts +0 -8
package/dist/integrations/koota.js +0 -7
package/dist/integrations/leva.d.ts +0 -3
package/dist/integrations/leva.js +0 -7
package/dist/integrations/offscreen.d.ts +0 -3
package/dist/integrations/offscreen.js +0 -12
package/dist/integrations/oxfmt.d.ts +0 -3
package/dist/integrations/oxfmt.js +0 -27
package/dist/integrations/oxlint.d.ts +0 -3
package/dist/integrations/oxlint.js +0 -52
package/dist/integrations/postprocessing.d.ts +0 -3
package/dist/integrations/postprocessing.js +0 -12
package/dist/integrations/prettier.d.ts +0 -3
package/dist/integrations/prettier.js +0 -28
package/dist/integrations/rapier.d.ts +0 -3
package/dist/integrations/rapier.js +0 -7
package/dist/integrations/triplex.d.ts +0 -26
package/dist/integrations/triplex.js +0 -159
package/dist/integrations/uikit.d.ts +0 -3
package/dist/integrations/uikit.js +0 -7
package/dist/integrations/vitest.d.ts +0 -2
package/dist/integrations/vitest.js +0 -20
package/dist/integrations/viverse.d.ts +0 -3
package/dist/integrations/viverse.js +0 -74
package/dist/integrations/xr.d.ts +0 -5
package/dist/integrations/xr.js +0 -51
package/dist/integrations/zustand.d.ts +0 -8
package/dist/integrations/zustand.js +0 -7
package/dist/lib/array.d.ts +0 -1
package/dist/lib/array.js +0 -9
package/dist/merge.d.ts +0 -1
package/dist/merge.js +0 -26
package/dist/utils.d.ts +0 -22
package/dist/utils.js +0 -123

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,1676 @@
+import color from 'chalk';
+const HtmlContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>$title</title>
+</head>
+<body style="margin: 0; overscroll-behavior: none; user-select: none; touch-action: none;">
+    <script type="module" src="$indexPath"><\/script>
+    <div style="width: 100dvw; height: 100dvh; overflow: hidden;" id="root"></div>
+</body>
+</html>`;
+const ViteHtmlContent = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>$title</title>
+</head>
+<body>
+    <div id="app"></div>
+    <script type="module" src="$indexPath"><\/script>
+</body>
+</html>`;
+const IndexContent = `import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { App } from './app.js'
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)`;
+const ViteIndexContent = `import './style.css'
+document.querySelector('#app')!.innerHTML = \`
+  <h1>Hello Vite!</h1>
+  <p>Edit src/main.ts and save to see HMR in action.</p>
+\``;
+const ViteStyleContent = `body {
+  font-family: system-ui, -apple-system, sans-serif;
+  margin: 0;
+  padding: 2rem;
+  min-height: 100vh;
+  background: #1a1a1a;
+  color: #fff;
+}
+h1 {
+  color: #646cff;
+}
+a {
+  color: #646cff;
+}`;
+const GitAttributes = [
+  "* text eol=lf",
+  "*.png binary",
+  "*.jpg binary",
+  "*.jpeg binary",
+  "*.gif binary",
+  "*.ico binary",
+  "*.mov binary",
+  "*.mp4 binary",
+  "*.mp3 binary",
+  "*.flv binary",
+  "*.fla binary",
+  "*.wav binary",
+  "*.swf binary",
+  "*.gz binary",
+  "*.zip binary",
+  "*.7z binary",
+  "*.ttf binary",
+  "*.eot binary",
+  "*.woff binary",
+  "*.pyc binary",
+  "*.pdf binary",
+  "*.glb binary",
+  "*.gltf binary"
+].join("\n");
+const defaultFormatterConfig = {
+  printWidth: 102,
+  tabWidth: 4,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: "es5",
+  bracketSpacing: true,
+  arrowParens: "always"
+};
+const defaultLinterConfig = {
+  ignorePatterns: ["dist"],
+  rules: {
+    noUnusedVars: {
+      level: "warn",
+      argsIgnorePattern: "^_",
+      varsIgnorePattern: "^_",
+      caughtErrorsIgnorePattern: "^_"
+    },
+    noUnusedExpressions: {
+      level: "warn",
+      allowShortCircuit: true
+    }
+  }
+};
+function toBiomeLevel(level) {
+  return level;
+}
+function generateBiome(generator, options) {
+  if (options == null || !options.linter && !options.formatter) {
+    return;
+  }
+  const version = generator.versions.biome ?? "1.9.4";
+  generator.addDevDependency("@biomejs/biome", `^${version}`);
+  const { rules } = defaultLinterConfig;
+  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) {
+    biomeConfig.formatter = {
+      enabled: true,
+      lineWidth: defaultFormatterConfig.printWidth,
+      indentWidth: defaultFormatterConfig.tabWidth,
+      indentStyle: "space"
+    };
+    biomeConfig.javascript = {
+      formatter: {
+        semicolons: "always" ,
+        quoteStyle: "single" ,
+        trailingCommas: defaultFormatterConfig.trailingComma,
+        bracketSpacing: defaultFormatterConfig.bracketSpacing,
+        arrowParentheses: "always"
+      }
+    };
+  } 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");
+  }
+}
+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`
+  );
+}
+function toEslintLevel(level) {
+  return level;
+}
+function generateEslint(generator, options) {
+  const version = generator.versions.eslint ?? "9.17.0";
+  generator.addDevDependency("eslint", `^${version}`);
+  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.addDevDependency("typescript-eslint", "^8.18.0");
+    imports.push('import tseslint from "typescript-eslint"');
+    configs.push("...tseslint.configs.recommended");
+  }
+  if (isReact) {
+    generator.addDevDependency("eslint-plugin-react-hooks", "^5.1.0");
+    imports.push('import reactHooks from "eslint-plugin-react-hooks"');
+  }
+  const ignoresArray = JSON.stringify(defaultLinterConfig.ignorePatterns);
+  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);
+}
+function generateFiber(generator, _options) {
+  generator.inject("import", `import { Box } from "./box.js"`);
+  generator.inject(
+    "scene",
+    [
+      `<ambientLight intensity={Math.PI / 2} />`,
+      `<spotLight position={[10, 10, 10]} angle={0.15} penumbra={1} decay={0} intensity={Math.PI} />`,
+      `<pointLight position={[-10, -10, -10]} decay={0} intensity={Math.PI} />`,
+      `<Box position={[-1.2, 0, 0]} />`,
+      `<Box position={[1.2, 0, 0]} />`
+    ].join("\n")
+  );
+  generator.addFile("src/box.tsx", {
+    type: "text",
+    content: `import type { Mesh } from 'three'
+import { useRef, useState } from 'react'
+import { useFrame, ThreeElements } from '@react-three/fiber'
+export function Box(props: ThreeElements['mesh']) {
+  const meshRef = useRef<Mesh>(null!)
+  const [hovered, setHover] = useState(false)
+  const [active, setActive] = useState(false)
+  useFrame((state, delta) => (meshRef.current.rotation.x += delta))
+  return (
+    <mesh
+      {...props}
+      ref={meshRef}
+      scale={active ? 1.5 : 1}
+      onClick={(event) => setActive(!active)}
+      onPointerOver={(event) => setHover(true)}
+      onPointerOut={(event) => setHover(false)}>
+      <boxGeometry args={[1, 1, 1]} />
+      <meshStandardMaterial color={hovered ? 'hotpink' : '#2f74c0'} />
+    </mesh>
+  )
+}`
+  });
+}
+function generateGithubPages(generator, options) {
+  if (options === false || (generator.options.packageManager ?? "npm") != "npm") {
+    return;
+  }
+  generator.addFile(".github/workflows/gh-pages.yml", {
+    type: "text",
+    content: `name: Deploy to Github Pages
+on:
+  push:
+    branches:
+      - main
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      contents: read
+      id-token: write
+    environment:
+      name: github-pages
+      url: \${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+      - name: Install dependencies
+        run: npm install
+      - name: Build project
+        run: npm run build
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './dist'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+`
+  });
+  generator.inject(
+    "readme-start",
+    `A github pages deployment action is configurd.`
+  );
+  if (generator.options.githubUserName != null && generator.options.githubRepoName != null) {
+    const address = `${generator.options.githubUserName}.github.io/${generator.options.githubRepoName}`;
+    generator.inject(
+      "readme-start",
+      `Your app will be publish at [${address}](https://${address}) once the github action is finished.
+`
+    );
+  }
+}
+function generateHandle(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("@react-three/handle", "^6.6.16");
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/handle](https://pmndrs.github.io/xr/docs/handles/introduction) - interactive controls and handles for your 3D objects`
+  );
+}
+function generateKoota(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("koota", "^0.4.0");
+  generator.inject(
+    "readme-libraries",
+    `[koota](https://github.com/pmndrs/koota) - ECS-based state management library optimized for real-time apps, games, and XR experiences`
+  );
+}
+function generateLeva(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("leva", "^0.10.0");
+  generator.inject(
+    "readme-libraries",
+    `[leva](https://github.com/pmndrs/leva) - HTML GUI panel for React with lightweight, beautiful and extensible controls`
+  );
+}
+function generateOffscreen(generator, options) {
+  if (options == null) {
+    return;
+  }
+  if (generator.options.xr != null) {
+    console.info(
+      color.blue("Info:"),
+      "@react-three/offscreen is disabled because it is not supported with XR"
+    );
+    return;
+  }
+  generator.addDependency("@react-three/offscreen", "^0.0.8");
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/offscreen](https://github.com/pmndrs/offscreen) - Offload your scene to a worker thread for better performance`
+  );
+}
+function generateOxfmt(generator, options) {
+  const version = generator.versions.oxfmt ?? "0.1.0";
+  generator.addDevDependency("oxfmt", `^${version}`);
+  const oxfmtConfig = {
+    printWidth: defaultFormatterConfig.printWidth,
+    tabWidth: defaultFormatterConfig.tabWidth,
+    useTabs: defaultFormatterConfig.useTabs,
+    semi: defaultFormatterConfig.semi,
+    singleQuote: defaultFormatterConfig.singleQuote,
+    trailingComma: defaultFormatterConfig.trailingComma,
+    bracketSpacing: defaultFormatterConfig.bracketSpacing,
+    arrowParens: defaultFormatterConfig.arrowParens
+  };
+  generator.addFile(".oxfmt.json", {
+    type: "text",
+    content: JSON.stringify(oxfmtConfig, null, 2)
+  });
+  generator.addScript("format", "oxfmt --write .");
+  generator.inject(
+    "readme-tools",
+    "[Oxfmt](https://oxc.rs/docs/guide/usage/formatter) - Fast Prettier-compatible code formatter"
+  );
+  generator.inject("vscode-extension-suggestion", "oxc.oxc-vscode");
+  generator.addVscodeSetting("editor.defaultFormatter", "oxc.oxc-vscode");
+}
+function toOxlintLevel(level) {
+  return level;
+}
+function generateOxlint(generator, options) {
+  const version = generator.versions.oxlint ?? "0.16.0";
+  generator.addDevDependency("oxlint", `^${version}`);
+  const { rules } = defaultLinterConfig;
+  const template = generator.options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+  const plugins = ["unicorn", "typescript", "oxc"];
+  if (isReact) {
+    plugins.push("react");
+  }
+  const oxlintConfig = {
+    $schema: "./node_modules/oxlint/configuration_schema.json",
+    plugins,
+    rules: {
+      "no-unused-vars": [
+        toOxlintLevel(rules.noUnusedVars.level),
+        {
+          argsIgnorePattern: rules.noUnusedVars.argsIgnorePattern,
+          varsIgnorePattern: rules.noUnusedVars.varsIgnorePattern,
+          caughtErrorsIgnorePattern: rules.noUnusedVars.caughtErrorsIgnorePattern
+        }
+      ],
+      "no-useless-escape": "off",
+      "no-unused-expressions": [
+        toOxlintLevel(rules.noUnusedExpressions.level),
+        { allowShortCircuit: rules.noUnusedExpressions.allowShortCircuit }
+      ]
+    },
+    ignorePatterns: defaultLinterConfig.ignorePatterns
+  };
+  generator.addFile("oxlint.json", {
+    type: "text",
+    content: JSON.stringify(oxlintConfig, null, 2)
+  });
+  generator.addScript("lint", "oxlint");
+  generator.inject(
+    "readme-tools",
+    "[Oxlint](https://oxc.rs/docs/guide/usage/linter) - A fast linter for JavaScript and TypeScript"
+  );
+  generator.inject("vscode-extension-suggestion", "oxc.oxc-vscode");
+  generator.addVscodeSetting("oxc.enable", true);
+}
+function generatePostprocessing(generator, options) {
+  if (options == null) {
+    return;
+  }
+  if (generator.options.xr != null) {
+    console.info(
+      color.blue("Info:"),
+      "@react-three/postprocessing is disabled because it is not supported with XR"
+    );
+    return;
+  }
+  generator.addDependency("@react-three/postprocessing", "^3.0.4");
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/postprocessing](https://react-postprocessing.docs.pmnd.rs/) - Post-processing effects for @react-three/fiber`
+  );
+}
+function generatePrettier(generator, options) {
+  const version = generator.versions.prettier ?? "3.4.2";
+  generator.addDevDependency("prettier", `^${version}`);
+  const prettierConfig = {
+    $schema: "https://json.schemastore.org/prettierrc",
+    printWidth: defaultFormatterConfig.printWidth,
+    tabWidth: defaultFormatterConfig.tabWidth,
+    useTabs: defaultFormatterConfig.useTabs,
+    semi: defaultFormatterConfig.semi,
+    singleQuote: defaultFormatterConfig.singleQuote,
+    trailingComma: defaultFormatterConfig.trailingComma,
+    bracketSpacing: defaultFormatterConfig.bracketSpacing,
+    arrowParens: defaultFormatterConfig.arrowParens
+  };
+  generator.addFile(".prettierrc", {
+    type: "text",
+    content: JSON.stringify(prettierConfig, null, 2)
+  });
+  generator.addScript("format", "prettier --write .");
+  generator.inject("readme-tools", "[Prettier](https://prettier.io/) - Opinionated code formatter");
+  generator.inject("vscode-extension-suggestion", "esbenp.prettier-vscode");
+  generator.addVscodeSetting("editor.defaultFormatter", "esbenp.prettier-vscode");
+}
+function generateRapier(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("@react-three/rapier", "^2.1.0");
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/rapier](https://github.com/pmndrs/react-three-rapier) - Physics based on Rapier for your @react-three/fiber scene`
+  );
+}
+function generateUikit(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("@react-three/uikit", "^0.8.15");
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/uikit](https://pmndrs.github.io/uikit/docs/) - UI primitives for React Three Fiber`
+  );
+}
+function generateXr(generator, options) {
+  if (options == null || options === false) {
+    return;
+  }
+  if (options === true) {
+    options = {};
+  }
+  generator.addDependency("@react-three/xr", "^6.6.16");
+  generator.addDependency("@vitejs/plugin-basic-ssl", "^2.0.0");
+  generator.inject("import", "import { XR, createXRStore } from '@react-three/xr'");
+  generator.inject(
+    `global-start`,
+    `const store = createXRStore(${JSON.stringify(options.storeOptions ?? {})})`
+  );
+  generator.inject("scene-start", "<XR store={store}>");
+  generator.inject("scene-end", "</XR>");
+  generator.inject("vite-config-import", "import basicSsl from '@vitejs/plugin-basic-ssl'");
+  generator.configureVite({
+    server: {
+      host: true
+    },
+    plugins: ["$raw:basicSsl()"]
+  });
+  generator.inject(
+    "dom-start",
+    `<div style={{
+        display: "flex",
+          flexDirection: "row",
+          gap: "1rem",
+          position: 'absolute',
+          zIndex: 10000,
+          background: 'black',
+          borderRadius: '0.5rem',
+          border: 'none',
+          fontWeight: 'bold',
+          color: 'white',
+          cursor: 'pointer',
+          fontSize: '1.5rem',
+          bottom: '1rem',
+          left: '50%',
+          boxShadow: '0px 0px 20px rgba(0,0,0,1)',
+          transform: 'translate(-50%, 0)',
+        }}><button
+        style={{ cursor: "pointer", padding: '1rem 2rem', fontSize: "1rem", background: "none", color: "white", border: "none" }}
+        onClick={() => store.enterAR()}
+      >
+        Enter AR
+      </button>
+      <button
+        style={{ cursor: "pointer", padding: '1rem 2rem', fontSize: "1rem", background: "none", color: "white", border: "none" }}
+        onClick={() => store.enterVR()}
+      >
+        Enter VR
+      </button></div>`
+  );
+  generator.inject(
+    "readme-libraries",
+    `[@react-three/xr](https://pmndrs.github.io/xr/docs/) - VR/AR support for @react-three/fiber`
+  );
+}
+function generateZustand(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.addDependency("zustand", "^5.0.3");
+  generator.inject(
+    "readme-libraries",
+    `[zustand](https://zustand.docs.pmnd.rs/) - small, fast and scalable state-management solution`
+  );
+}
+function unique(...array) {
+  const set = /* @__PURE__ */ new Set();
+  for (const arr of array) {
+    for (const item of arr) {
+      set.add(item);
+    }
+  }
+  return Array.from(set);
+}
+function generateProvidersModule(generator) {
+  const canvasProviders = [];
+  const globalProviders = [];
+  const providerDefs = {
+    uikit: {
+      type: "layout-effect",
+      props: [
+        {
+          declaredPropDefaultValue: '"light"',
+          declaredPropName: "colorMode",
+          propName: "colorMode",
+          propValue: "colorMode",
+          declaredPropType: '"light" | "dark"'
+        }
+      ],
+      code: `
+        setPreferredColorScheme(colorMode);
+      `,
+      import: 'import { setPreferredColorScheme } from "@react-three/uikit"'
+    },
+    rapier: {
+      component: "Physics",
+      type: "wrapped-jsx",
+      import: 'import { Physics } from "@react-three/rapier";',
+      props: [
+        {
+          declaredPropDefaultValue: false,
+          declaredPropName: "physicsEnabled",
+          propName: "paused",
+          propValue: "!physicsEnabled",
+          declaredPropType: "boolean"
+        },
+        {
+          declaredPropDefaultValue: true,
+          declaredPropName: "debugPhysics",
+          propName: "debug",
+          propValue: "debugPhysics",
+          declaredPropType: "boolean"
+        }
+      ]
+    },
+    postprocessing: {
+      type: "inline-jsx",
+      code: `
+        <EffectComposer enabled={postProcessingEnabled}>
+          <DepthOfField
+            focusDistance={0}
+            focalLength={0.02}
+            bokehScale={2}
+            height={480}
+          />
+          <Bloom luminanceThreshold={0} luminanceSmoothing={0.9} height={300} />
+        </EffectComposer>
+      `,
+      import: 'import { Bloom, DepthOfField, EffectComposer } from "@react-three/postprocessing";',
+      props: [
+        {
+          declaredPropDefaultValue: true,
+          declaredPropName: "postProcessingEnabled",
+          propName: "enabled",
+          propValue: "postProcessingEnabled",
+          declaredPropType: "boolean"
+        }
+      ]
+    }
+  };
+  if (generator.options.rapier) {
+    canvasProviders.push("rapier");
+  }
+  if (!!generator.options.postprocessing && !generator.options.xr) {
+    canvasProviders.push("postprocessing");
+  }
+  if (generator.options.uikit) {
+    globalProviders.push("uikit");
+  }
+  function generateProviderFunction(name, { jsdoc, providers }) {
+    const resolvedProviders = providers.map((provider) => providerDefs[provider]);
+    const providerProps = resolvedProviders.flatMap((provider) => provider.props || []);
+    const providerImports = resolvedProviders.flatMap((provider) => provider.import);
+    const wrappedComponents = resolvedProviders.filter(
+      (provider) => provider.type === "wrapped-jsx"
+    );
+    const inlineComponents = resolvedProviders.filter((provider) => provider.type === "inline-jsx");
+    const layoutEffects = resolvedProviders.filter((provider) => provider.type === "layout-effect");
+    const declaredProps = providerProps.map((prop) => `${prop.declaredPropName} = ${prop.declaredPropDefaultValue}`).join(", ");
+    const declaredTypes = providerProps.map((prop) => `${prop.declaredPropName}?: ${prop.declaredPropType}`).join("; ");
+    const reactImports = ["type ReactNode"];
+    if (layoutEffects.length) {
+      reactImports.push("useLayoutEffect");
+    }
+    return {
+      reactImports,
+      imports: providerImports,
+      code: `
+      /**
+${jsdoc.split("\n").map((line) => `       * ${line}`).join("\n")}
+       */
+      export function ${name}({ children, ${declaredProps} }: { children: ReactNode; ${declaredTypes} }) {
+        ${layoutEffects.length ? `
+          useLayoutEffect(() => {
+            ${layoutEffects.map((effect) => effect.code).join("\n")}
+          }, [${layoutEffects.map((effect) => effect.props?.[0]?.propValue)}]);
+        ` : ""}
+        return (
+          <>
+            ${inlineComponents.map((provider) => provider.code)}
+            ${wrappedComponents.reduce((acc, provider) => {
+        const props = provider.props?.map((prop) => `${prop.propName}={${prop.propValue}}`).join(" ");
+        return `<${provider.component} ${props}>${acc}</${provider.component}>`;
+      }, "{children}")}
+          </>
+        );
+      }`
+    };
+  }
+  const global = generateProviderFunction("GlobalProvider", {
+    jsdoc: "The global provider is rendered at the root of your application,\nuse it to set up global configuration like themes.\nProps defined on this component appear as controls inside Triplex.\n\nSee: https://triplex.dev/docs/building-your-scene/providers#global-provider",
+    providers: globalProviders
+  });
+  const canvas = generateProviderFunction("CanvasProvider", {
+    jsdoc: "The canvas provider is rendered as a child inside the React Three Fiber canvas,\nuse it to set up canvas specific configuration like post-processing and physics.\nProps defined on this component appear as controls inside Triplex.\n\nSee: https://triplex.dev/docs/building-your-scene/providers#canvas-provider",
+    providers: canvasProviders
+  });
+  return `
+    import { ${unique(global.reactImports, canvas.reactImports).sort().join(", ")} } from "react";
+    ${unique(global.imports, canvas.imports).sort().join("\n")}
+    ${global.code}
+    ${canvas.code}
+  `;
+}
+function generateTriplex(generator, options) {
+  if (options == null) {
+    return;
+  }
+  generator.inject("vscode-extension-suggestion", "trytriplex.triplex-vsce");
+  generator.inject(
+    "readme-tools",
+    `[Triplex](https://triplex.dev) - Your visual workspace for React / Three Fiber. Get started by installing [Triplex for VS Code](https://triplex.dev/docs/get-started/vscode). Don't use Visual Studio Code? Download [Triplex Standalone](https://triplex.dev/docs/get-started/standalone).`
+  );
+  generator.addFile(".triplex/providers.tsx", {
+    content: generateProvidersModule(generator),
+    type: "text"
+  });
+  generator.addFile(".triplex/config.json", {
+    content: JSON.stringify(
+      {
+        $schema: "https://triplex.dev/config.schema.json",
+        provider: "./providers.tsx"
+      },
+      null,
+      2
+    ),
+    type: "text"
+  });
+}
+function generateTsdown(generator) {
+  generator.addDevDependency("tsdown", "^0.12.0");
+  const template = generator.options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const language = getLanguageFromTemplate(template);
+  const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+  const ext = language === "typescript" ? "ts" : "js";
+  const configLines = [
+    `import { defineConfig } from "tsdown"`,
+    ``,
+    `export default defineConfig({`,
+    `  entry: ["./src/index.${ext}${isReact ? "x" : ""}"],`,
+    `  format: ["esm", "cjs"],`,
+    `  dts: ${language === "typescript"},`,
+    `  clean: true,`
+  ];
+  if (isReact) {
+    configLines.push(`  esbuild: {`);
+    configLines.push(`    jsx: "automatic",`);
+    configLines.push(`  },`);
+  }
+  configLines.push(`})`);
+  generator.addFile(`tsdown.config.${ext}`, {
+    type: "text",
+    content: configLines.join("\n")
+  });
+  generator.addScript("build", "tsdown");
+  generator.inject(
+    "readme-libraries",
+    "[tsdown](https://github.com/nicepkg/tsdown) - Fast TypeScript bundler powered by esbuild"
+  );
+}
+function generateUnbuild(generator) {
+  generator.addDevDependency("unbuild", "^3.5.0");
+  const template = generator.options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const language = getLanguageFromTemplate(template);
+  const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+  const ext = language === "typescript" ? "ts" : "js";
+  const buildConfigLines = [
+    `import { defineBuildConfig } from "unbuild"`,
+    ``,
+    `export default defineBuildConfig({`,
+    `  entries: ["./src/index"],`,
+    `  declaration: ${language === "typescript"},`,
+    `  clean: true,`,
+    `  rollup: {`,
+    `    emitCJS: true,`
+  ];
+  if (isReact) {
+    buildConfigLines.push(`    esbuild: {`);
+    buildConfigLines.push(`      jsx: "automatic",`);
+    buildConfigLines.push(`    },`);
+  }
+  buildConfigLines.push(`  },`);
+  buildConfigLines.push(`})`);
+  generator.addFile(`build.config.${ext}`, {
+    type: "text",
+    content: buildConfigLines.join("\n")
+  });
+  generator.addScript("build", "unbuild");
+  generator.inject(
+    "readme-libraries",
+    "[unbuild](https://github.com/unjs/unbuild) - Unified JavaScript build system"
+  );
+}
+function generateVitest(generator) {
+  const version = generator.versions.vitest ?? "4.0.0";
+  generator.addDevDependency("vitest", `^${version}`);
+  const template = generator.options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+  if (isReact) {
+    generator.addDevDependency("@testing-library/react", "^16.2.0");
+    generator.addDevDependency("@testing-library/dom", "^10.4.0");
+    generator.addDevDependency("jsdom", "^26.0.0");
+  }
+  if (isReact) {
+    generator.configureVite({ test: { environment: "jsdom" } });
+  }
+  generator.addScript("test", "vitest");
+  generator.inject(
+    "readme-tools",
+    "[Vitest](https://vitest.dev/) - Fast unit test framework powered by Vite"
+  );
+}
+function merge(target, modification) {
+  if (modification == null) {
+    throw new Error(`Cannot merge "${modification}" modification into target "${target}"`);
+  }
+  if (target == null) {
+    return modification;
+  }
+  if (Array.isArray(target)) {
+    if (!Array.isArray(modification)) {
+      throw new Error(
+        `Cannot merge non-array modification "${modification}" into array target "${target}"`
+      );
+    }
+    return [...target, ...modification];
+  }
+  if (typeof target === "object") {
+    if (typeof modification != "object") {
+      throw new Error(
+        `Cannot merge non-object modification "${modification}" into object target "${target}"`
+      );
+    }
+    const result = { ...target };
+    for (const modificationKey in modification) {
+      result[modificationKey] = merge(target[modificationKey], modification[modificationKey]);
+    }
+    return result;
+  }
+  console.warn(`target "${target}" is overwritten with modification "${modification}"`);
+  return modification;
+}
+function generateViverse(generator, options) {
+  if (options == null || (generator.options.packageManager ?? "npm") != "npm") {
+    return;
+  }
+  generator.addFile(".github/workflows/viverse.yml", {
+    type: "text",
+    content: `name: Deploy to Viverse
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+jobs:
+  check-secrets:
+    runs-on: ubuntu-latest
+    outputs:
+      secrets-available: \${{ steps.check.outputs.secrets-available }}
+    steps:
+      - id: check
+        run: |
+          if [[ -n "\${{ secrets.VIVERSE_EMAIL }}" && -n "\${{ secrets.VIVERSE_PASSWORD }}" ]]; then
+            echo "secrets-available=true" >> $GITHUB_OUTPUT
+          else
+            echo "secrets-available=false" >> $GITHUB_OUTPUT
+          fi
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    needs: check-secrets
+    # Only run if secrets are present
+    if: needs.check-secrets.outputs.secrets-available == 'true'
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Setup Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22
+      - name: Install dependencies
+        run: npm install
+      - name: Build project
+        run: npm run build
+      - name: Viverse Login
+        run: npx viverse-cli auth login -e \${{ secrets.VIVERSE_EMAIL }} -p \${{ secrets.VIVERSE_PASSWORD }}
+      - name: Deploy to Viverse
+        run: npx viverse-cli app publish ./dist --auto-create-app --name ${generator.options.name}
+`
+  });
+  generator.addDependency("@viverse/cli", "^0.9.5-beta.8");
+  generator.inject(
+    "readme-start",
+    `A GitHub CI/CD workflow for publishing to Viverse is configured.
+To use publish to viverse via the CI/CD workflow:
+1. Set \`VIVERSE_EMAIL\` and \`VIVERSE_PASSWORD\` secrets in your repository settings under \`Secrets and Variables\` > \`Actions\` > \`New repository secret\`
+2. Manually trigger the "Deploy to Viverse" workflow or push to the main branch
+**Manual CLI Upload:**
+You can also upload your project manually using the Viverse CLI:
+\`\`\`bash
+viverse-cli auth login -e <email> -p <password>
+npm run build
+viverse-cli app publish ./dist --auto-create-app --name ${generator.options.name}
+\`\`\`
+`
+  );
+}
+async function getLatestNpmVersion(packageName, fallback) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return fallback;
+  }
+}
+async function getLatestPnpmVersion() {
+  return getLatestNpmVersion("pnpm", "10.11.0");
+}
+async function getLatestNodeVersion() {
+  try {
+    const response = await fetch("https://nodejs.org/dist/index.json");
+    const data = await response.json();
+    const ltsVersion = data.find((v) => v.lts);
+    if (ltsVersion) {
+      return ltsVersion.version.replace(/^v/, "");
+    }
+    return "22.0.0";
+  } catch {
+    return "22.0.0";
+  }
+}
+function generateRandomName() {
+  const adjectives = [
+    "red",
+    "blue",
+    "green",
+    "yellow",
+    "purple",
+    "orange",
+    "pink",
+    "black",
+    "white",
+    "tiny",
+    "big",
+    "small",
+    "large",
+    "huge",
+    "giant",
+    "mini",
+    "mega",
+    "super",
+    "happy",
+    "sad",
+    "angry",
+    "calm",
+    "quiet",
+    "loud",
+    "silent",
+    "noisy",
+    "shiny",
+    "dull",
+    "bright",
+    "dark",
+    "fuzzy",
+    "smooth",
+    "rough",
+    "soft"
+  ];
+  const nouns = [
+    "apple",
+    "banana",
+    "cherry",
+    "date",
+    "elderberry",
+    "fig",
+    "grape",
+    "honeydew",
+    "cat",
+    "dog",
+    "elephant",
+    "fox",
+    "giraffe",
+    "horse",
+    "iguana",
+    "jaguar",
+    "mountain",
+    "river",
+    "ocean",
+    "desert",
+    "forest",
+    "jungle",
+    "meadow",
+    "valley",
+    "star",
+    "moon",
+    "sun",
+    "planet",
+    "comet",
+    "asteroid",
+    "galaxy",
+    "universe"
+  ];
+  const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${randomAdjective}-${randomNoun}`;
+}
+function getLanguageFromTemplate(template) {
+  return template.endsWith("-js") ? "javascript" : "typescript";
+}
+function getBaseTemplate(template) {
+  return template.replace("-js", "");
+}
+function generate(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 isLibrary = clonedOptions.projectType === "library";
+  const libraryBundler = clonedOptions.libraryBundler ?? "unbuild";
+  const files = {
+    ...clonedOptions.files
+  };
+  const replacements = clonedOptions.replacements ?? [];
+  const versions = clonedOptions.versions ?? {};
+  const dependencies = {
+    ...clonedOptions.dependencies
+  };
+  const devDependencies = {};
+  const peerDependencies = {};
+  if (!isLibrary) {
+    devDependencies.vite = versions.vite ? `^${versions.vite}` : "^6.3.4";
+  }
+  if (isReact || isR3f) {
+    if (isLibrary) {
+      peerDependencies["react"] = "^18.0.0 || ^19.0.0";
+      peerDependencies["react-dom"] = "^18.0.0 || ^19.0.0";
+    } else {
+      dependencies["react"] = "^19.0.0";
+      dependencies["react-dom"] = "^19.0.0";
+      devDependencies["@vitejs/plugin-react"] = "^4.4.1";
+    }
+  }
+  if (isR3f) {
+    if (isLibrary) {
+      peerDependencies["three"] = ">=0.150.0";
+      peerDependencies["@react-three/fiber"] = "^8.0.0 || ^9.0.0";
+    } else {
+      dependencies["three"] = "~0.175.0";
+      dependencies["@react-three/fiber"] = "^9.0.0";
+    }
+  }
+  if (language === "typescript") {
+    const tsConfigNode = {
+      $schema: "https://json.schemastore.org/tsconfig",
+      compilerOptions: {
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        lib: ["ESNext"],
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        strict: true,
+        skipLibCheck: true,
+        composite: true,
+        rewriteRelativeImportExtensions: true,
+        erasableSyntaxOnly: true
+      },
+      include: ["src", "tests"]
+    };
+    files["tsconfig.node.json"] = {
+      type: "text",
+      content: JSON.stringify(tsConfigNode, null, 2)
+    };
+    const tsConfig = {
+      $schema: "https://json.schemastore.org/tsconfig",
+      extends: "./tsconfig.node.json",
+      compilerOptions: {},
+      include: ["*.config.ts"],
+      references: [{ path: "./tsconfig.node.json" }]
+    };
+    if (isReact || isR3f) {
+      tsConfig.compilerOptions.jsx = "react-jsx";
+      devDependencies["@types/react"] = "^19.0.0";
+      devDependencies["@types/react-dom"] = "^19.0.0";
+    }
+    if (isR3f) {
+      devDependencies["@types/three"] = "~0.175.0";
+    }
+    files["tsconfig.json"] = {
+      type: "text",
+      content: JSON.stringify(tsConfig, null, 2)
+    };
+  }
+  const codeSnippets = {};
+  const vscodeSettings = {};
+  const scripts = isLibrary ? {} : {
+    dev: "vite",
+    build: "vite build"
+  };
+  if (!isLibrary && (isReact || isR3f)) {
+    codeSnippets["vite-config-import"] = [
+      "import react from '@vitejs/plugin-react'"
+    ];
+  }
+  if (!isLibrary && 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;
+  let viteConfig = {
+    base: "./"
+  };
+  if (!isLibrary && (isReact || isR3f)) {
+    viteConfig.plugins = ["$raw:react()"];
+  }
+  if (!isLibrary && isR3f) {
+    viteConfig.resolve = { dedupe: ["three"] };
+  }
+  const generator = {
+    options: clonedOptions,
+    versions,
+    addDependency(name2, semver) {
+      dependencies[name2];
+      dependencies[name2] = semver;
+    },
+    addDevDependency(name2, semver) {
+      devDependencies[name2];
+      devDependencies[name2] = semver;
+    },
+    addFile(path, content) {
+      files[path] = content;
+    },
+    addScript(name2, command) {
+      scripts[name2] = 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;
+    }
+  };
+  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);
+  }
+  if (!isLibrary) {
+    generateGithubPages(generator, clonedOptions.githubPages);
+  }
+  if (isLibrary) {
+    if (libraryBundler === "unbuild") {
+      generateUnbuild(generator);
+    } else if (libraryBundler === "tsdown") {
+      generateTsdown(generator);
+    }
+    const packageManager2 = clonedOptions.packageManager ?? "pnpm";
+    generator.addScript(
+      "release",
+      `${packageManager2} run build && ${packageManager2} publish`
+    );
+  }
+  generateVitest(generator);
+  const linter = clonedOptions.linter;
+  const formatter = clonedOptions.formatter;
+  if (linter === "eslint") {
+    generateEslint(generator);
+    generator.addVscodeSetting("biome.enabled", false);
+    generator.addVscodeSetting("oxc.enable", false);
+  } else if (linter === "oxlint") {
+    generateOxlint(generator);
+    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);
+  }
+  if (formatter === "prettier") {
+    generatePrettier(generator);
+  } else if (formatter === "oxfmt") {
+    generateOxfmt(generator);
+  } else if (formatter === "biome" && linter !== "biome") {
+    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);
+  }
+  if (!isLibrary) {
+    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.ts"] = { type: "text", content: viteConfigContent };
+  }
+  const packageManager = options.packageManager ?? "pnpm";
+  const isPnpm = packageManager === "pnpm";
+  const ext = language === "typescript" ? "ts" : "js";
+  const jsxExt = language === "typescript" ? "tsx" : "jsx";
+  const packageJson = {
+    name,
+    type: "module"
+  };
+  if (isLibrary) {
+    packageJson.main = "./dist/index.mjs";
+    packageJson.module = "./dist/index.mjs";
+    if (language === "typescript") {
+      packageJson.types = "./dist/index.d.ts";
+    }
+    packageJson.exports = {
+      ".": {
+        ...language === "typescript" && { types: "./dist/index.d.ts" },
+        import: "./dist/index.mjs",
+        require: "./dist/index.cjs"
+      }
+    };
+    packageJson.files = ["dist"];
+  }
+  packageJson.scripts = scripts;
+  packageJson.dependencies = dependencies;
+  if (Object.keys(devDependencies).length > 0) {
+    packageJson.devDependencies = devDependencies;
+  }
+  if (isLibrary && Object.keys(peerDependencies).length > 0) {
+    packageJson.peerDependencies = peerDependencies;
+  }
+  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)
+  };
+  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", "*.tsbuildinfo"].join("\n")
+  };
+  files[".gitattributes"] = { type: "text", content: GitAttributes };
+  codeSnippets["readme-libraries"] ??= [];
+  codeSnippets["readme-commands"] ??= [];
+  if (isLibrary) ; else 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`
+    );
+  }
+  if (isLibrary) {
+    codeSnippets["readme-commands"].unshift(
+      `\`${packageManager} install\` to install the dependencies`,
+      `\`${packageManager} run build\` to build the library into the \`dist\` folder`,
+      `\`${packageManager} run test\` to run the tests`,
+      `\`${packageManager} run release\` to build and publish to npm`
+    );
+  } else {
+    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`,
+      `\`${packageManager} run test\` to run the tests`
+    );
+  }
+  let architectureDesc;
+  if (isLibrary) {
+    architectureDesc = [
+      `- \`src/index.${isReact || isR3f ? jsxExt : ext}\` is the main entry point for your library exports`,
+      `- Add your library code in the \`src\` folder`,
+      `- \`tests/\` contains your test files`
+    ];
+  } else if (isVanilla) {
+    architectureDesc = [
+      `- \`src/main.${ext}\` is the entry point for your application`,
+      `- \`tests/\` contains your test files`,
+      `- 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`,
+      `- \`tests/\` contains your test files`,
+      `- 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`,
+      `- \`tests/\` contains your test files`,
+      `- Static assets can be placed in the \`public\` folder`
+    ];
+  }
+  const bundlerDescription = isLibrary ? libraryBundler === "unbuild" ? `This library uses [unbuild](https://github.com/unjs/unbuild) for building.` : `This library uses [tsdown](https://github.com/nicepkg/tsdown) for building.` : `This project uses [Vite](https://vitejs.dev/) as the bundler for fast development and optimized production builds.`;
+  files[`README.md`] = {
+    type: "text",
+    content: [
+      `# ${name}`,
+      `This ${isLibrary ? "library" : "project"} was generated with create-krispya`,
+      ...codeSnippets["readme-start"] ?? [],
+      "\n",
+      `## Project Architecture`,
+      bundlerDescription,
+      ...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"] && `
+`,
+      `## Development Commands`,
+      ...(codeSnippets["readme-commands"] ?? []).map(
+        (command) => `- ${command}`
+      ),
+      ...codeSnippets["readme-end"] ?? []
+    ].filter(Boolean).join("\n")
+  };
+  if (isLibrary) {
+    const libExt = isReact || isR3f ? jsxExt : ext;
+    let libContent;
+    if (isVanilla) {
+      libContent = [
+        `// Library entry point`,
+        `export function hello(name: string = "world"): string {`,
+        `  return \`Hello, \${name}!\``,
+        `}`
+      ].join("\n");
+    } else if (isReact) {
+      libContent = [
+        `// Library entry point`,
+        `export function MyComponent({ message = "Hello from library!" }: { message?: string }) {`,
+        `  return <div>{message}</div>`,
+        `}`
+      ].join("\n");
+    } else {
+      libContent = [
+        `// Library entry point`,
+        `export function MyMesh({ color = "orange" }: { color?: string }) {`,
+        `  return (`,
+        `    <mesh>`,
+        `      <boxGeometry />`,
+        `      <meshStandardMaterial color={color} />`,
+        `    </mesh>`,
+        `  )`,
+        `}`
+      ].join("\n");
+    }
+    files[`src/index.${libExt}`] = { type: "text", content: libContent };
+  } else if (isVanilla) {
+    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 {
+    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 };
+    codeSnippets["dom-end"]?.reverse();
+    codeSnippets["global-end"]?.reverse();
+    codeSnippets["scene-end"]?.reverse();
+    let appCode;
+    if (isReact) {
+      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 {
+      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 (isLibrary) {
+    const testExt = isReact || isR3f ? jsxExt : ext;
+    let testContent;
+    if (isVanilla) {
+      testContent = [
+        `import { describe, it, expect } from "vitest"`,
+        `import { hello } from "../src/index.js"`,
+        ``,
+        `describe("hello", () => {`,
+        `  it("returns greeting with default name", () => {`,
+        `    expect(hello()).toBe("Hello, world!")`,
+        `  })`,
+        ``,
+        `  it("returns greeting with custom name", () => {`,
+        `    expect(hello("vitest")).toBe("Hello, vitest!")`,
+        `  })`,
+        `})`
+      ].join("\n");
+    } else if (isReact) {
+      testContent = [
+        `import { describe, it, expect } from "vitest"`,
+        `import { render, screen } from "@testing-library/react"`,
+        `import { MyComponent } from "../src/index.js"`,
+        ``,
+        `describe("MyComponent", () => {`,
+        `  it("renders with default message", () => {`,
+        `    render(<MyComponent />)`,
+        `    expect(screen.getByText("Hello from library!")).toBeDefined()`,
+        `  })`,
+        ``,
+        `  it("renders with custom message", () => {`,
+        `    render(<MyComponent message="Custom message" />)`,
+        `    expect(screen.getByText("Custom message")).toBeDefined()`,
+        `  })`,
+        `})`
+      ].join("\n");
+    } else {
+      testContent = [
+        `import { describe, it, expect } from "vitest"`,
+        `import { MyMesh } from "../src/index.js"`,
+        ``,
+        `describe("MyMesh", () => {`,
+        `  it("is defined", () => {`,
+        `    expect(MyMesh).toBeDefined()`,
+        `  })`,
+        `})`
+      ].join("\n");
+    }
+    files[`tests/index.test.${testExt}`] = {
+      type: "text",
+      content: testContent
+    };
+  } else if (isVanilla) {
+    const testContent = [
+      `import { describe, it, expect } from "vitest"`,
+      ``,
+      `describe("example", () => {`,
+      `  it("works", () => {`,
+      `    expect(1 + 1).toBe(2)`,
+      `  })`,
+      `})`
+    ].join("\n");
+    files[`tests/main.test.${ext}`] = { type: "text", content: testContent };
+  } else if (isReact) {
+    const testContent = [
+      `import { describe, it, expect } from "vitest"`,
+      `import { render, screen } from "@testing-library/react"`,
+      `import { App } from "../src/app.js"`,
+      ``,
+      `describe("App", () => {`,
+      `  it("renders heading", () => {`,
+      `    render(<App />)`,
+      `    expect(screen.getByText("Hello React!")).toBeDefined()`,
+      `  })`,
+      `})`
+    ].join("\n");
+    files[`tests/app.test.${jsxExt}`] = { type: "text", content: testContent };
+  } else {
+    const testContent = [
+      `import { describe, it, expect } from "vitest"`,
+      `import { App } from "../src/app.js"`,
+      ``,
+      `describe("App", () => {`,
+      `  it("is defined", () => {`,
+      `    expect(App).toBeDefined()`,
+      `  })`,
+      `})`
+    ].join("\n");
+    files[`tests/app.test.${jsxExt}`] = { type: "text", content: testContent };
+  }
+  if (codeSnippets["vscode-extension-suggestion"]?.length) {
+    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, "	")
+    };
+  }
+  return files;
+}
+export { generate, generateRandomName, getBaseTemplate, getLanguageFromTemplate, getLatestNodeVersion, getLatestNpmVersion, getLatestPnpmVersion };