create-baeta 1.0.9 → 1.0.12

package/dist/chunk-CJP3Q273.js

@@ -0,0 +1,878 @@
+// lib/constants.ts
+var defaultPackageManager = "npm";
+var lockfileNames = {
+  npm: "package-lock.json",
+  yarn: "yarn.lock",
+  pnpm: "pnpm-lock.yaml",
+  bun: "bun.lockb"
+};
+var packageManagers = Object.keys(lockfileNames);
+var runtimes = ["node", "deno", "bun"];
+var defaultJavaScriptRuntime = "node";
+var templates = ["yoga", "apollo"];
+
+// lib/app-name.ts
+import path from "path";
+import { logger } from "@docusaurus/logger";
+import fs from "fs-extra";
+import prompts from "prompts";
+async function getAppName(reqName, rootDir) {
+  async function validateAppName(appName) {
+    if (!appName) {
+      return "An app name is required.";
+    }
+    const dest = path.resolve(rootDir, appName);
+    if (await fs.pathExists(dest)) {
+      return logger.interpolate`Directory already exists at path=${dest}!`;
+    }
+    return true;
+  }
+  if (reqName) {
+    const res = await validateAppName(reqName);
+    if (typeof res === "string") {
+      throw new Error(res);
+    }
+    return reqName;
+  }
+  return prompts(
+    {
+      type: "text",
+      name: "appName",
+      message: "What should we name this app?",
+      initial: "baeta-app",
+      validate: validateAppName
+    },
+    {
+      onCancel() {
+        logger.error("An app name is required.");
+        process.exit(1);
+      }
+    }
+  ).then((result) => result.appName);
+}
+
+// lib/package-manager.ts
+import path2 from "path";
+import { logger as logger2 } from "@docusaurus/logger";
+import fs2 from "fs-extra";
+import prompts2 from "prompts";
+import shell from "shelljs";
+async function findPackageManagerFromLockFile(rootDir) {
+  for (const packageManager of packageManagers) {
+    const lockFilePath = path2.join(rootDir, lockfileNames[packageManager]);
+    if (await fs2.pathExists(lockFilePath)) {
+      return packageManager;
+    }
+  }
+  return void 0;
+}
+function findPackageManagerFromUserAgent() {
+  return packageManagers.find(
+    (packageManager) => process.env.npm_config_user_agent?.startsWith(packageManager)
+  );
+}
+async function askForPackageManagerChoice() {
+  const hasYarn = shell.exec("yarn --version", { silent: true }).code === 0;
+  const hasPnpm = shell.exec("pnpm --version", { silent: true }).code === 0;
+  const hasBun = shell.exec("bun --version", { silent: true }).code === 0;
+  if (!hasYarn && !hasPnpm && !hasBun) {
+    return "npm";
+  }
+  const choices = ["npm", hasYarn && "yarn", hasPnpm && "pnpm", hasBun && "bun"].filter((p) => Boolean(p)).map((p) => ({ title: p, value: p }));
+  const manager = await prompts2(
+    {
+      type: "select",
+      name: "packageManager",
+      message: "Select a package manager...",
+      choices
+    },
+    {
+      onCancel() {
+        logger2.info`Falling back to name=${defaultPackageManager}`;
+      }
+    }
+  ).then((result) => result.packageManager);
+  return manager ?? defaultPackageManager;
+}
+async function getPackageManager(dest, { packageManager, skipInstall }) {
+  if (packageManager && !packageManagers.includes(packageManager)) {
+    throw new Error(
+      `Invalid package manager choice ${packageManager}. Must be one of ${packageManagers.join(
+        ", "
+      )}`
+    );
+  }
+  const fromLockfile = await findPackageManagerFromLockFile(dest);
+  if (fromLockfile) {
+    return fromLockfile;
+  }
+  if (packageManager) {
+    return packageManager;
+  }
+  const fromLockfileInCwd = await findPackageManagerFromLockFile(".");
+  if (fromLockfileInCwd) {
+    return fromLockfileInCwd;
+  }
+  const fromUserAgent = findPackageManagerFromUserAgent();
+  if (fromUserAgent) {
+    return fromUserAgent;
+  }
+  if (skipInstall) {
+    return defaultPackageManager;
+  }
+  return askForPackageManagerChoice();
+}
+function getInstallCommand(pkgManager) {
+  if (pkgManager === "yarn") {
+    return "yarn";
+  }
+  if (pkgManager === "bun") {
+    return "bun install";
+  }
+  return `${pkgManager} install --color always`;
+}
+
+// lib/runtime.ts
+import { logger as logger3 } from "@docusaurus/logger";
+import prompts3 from "prompts";
+import shell2 from "shelljs";
+async function getRuntime() {
+  const hasBun = shell2.exec("bun --version", { silent: true }).code === 0;
+  const hasDeno = shell2.exec("deno --version", { silent: true }).code === 0;
+  if (!hasDeno && !hasBun) {
+    return "node";
+  }
+  const choices = ["node", hasBun && "bun", hasDeno && "deno"].filter((p) => Boolean(p)).map((p) => ({ title: p, value: p }));
+  const runtime = await prompts3(
+    {
+      type: "select",
+      name: "runtime",
+      message: "Select a runtime...",
+      choices
+    },
+    {
+      onCancel() {
+        logger3.info`Falling back to name=${defaultJavaScriptRuntime}`;
+      }
+    }
+  ).then((result) => result.runtime);
+  return runtime ?? defaultJavaScriptRuntime;
+}
+
+// lib/templates.ts
+import path3 from "path";
+import { logger as logger4 } from "@docusaurus/logger";
+import fs3 from "fs-extra";
+import prompts4 from "prompts";
+
+// meta/apollo/package.json
+var package_default = {
+  name: "@baeta/template-apollo",
+  version: "0.0.0",
+  private: true,
+  type: "module",
+  scripts: {
+    build: "baeta build --generate",
+    start: "baeta build --watch --generate --onSuccess='node --enable-source-maps --inspect dist/app.js'"
+  },
+  dependencies: {
+    "@apollo/server": "^4.12.2",
+    "@baeta/core": "workspace:^",
+    "@baeta/errors": "workspace:^",
+    "@baeta/extension-complexity": "workspace:^",
+    graphql: "^16.11.0"
+  },
+  devDependencies: {
+    "@baeta/cli": "workspace:^",
+    "@baeta/compiler": "workspace:^",
+    "@baeta/plugin-autoload": "workspace:^",
+    "@types/bun": "^1.2.15",
+    "@types/deno": "^2.3.0",
+    "@types/node": "^22.15.30",
+    typescript: "^5.8.3"
+  }
+};
+
+// ../../tools/tsconfig/tsconfig.json
+var tsconfig_default = {
+  $schema: "https://json.schemastore.org/tsconfig",
+  compilerOptions: {
+    target: "es2024",
+    lib: [
+      "es2024"
+    ],
+    module: "esnext",
+    noEmit: true,
+    strict: true,
+    noImplicitAny: true,
+    isolatedModules: true,
+    esModuleInterop: true,
+    verbatimModuleSyntax: true,
+    allowImportingTsExtensions: true,
+    allowSyntheticDefaultImports: true,
+    skipLibCheck: true,
+    forceConsistentCasingInFileNames: true,
+    moduleResolution: "bundler"
+  }
+};
+
+// versions.json
+var versions_default = {
+  "@baeta/cli": "1.0.12",
+  "@baeta/compiler": "1.0.12",
+  "@baeta/core": "1.0.12",
+  "create-baeta": "1.0.12",
+  "@baeta/directives": "1.0.12",
+  "@baeta/env": "1.0.12",
+  "@baeta/errors": "1.0.12",
+  "@baeta/extension-auth": "1.0.12",
+  "@baeta/extension-cache": "1.0.12",
+  "@baeta/extension-cache-cloudflare": "1.0.12",
+  "@baeta/extension-cache-keyv": "1.0.12",
+  "@baeta/extension-cache-redis": "1.0.12",
+  "@baeta/extension-cache-upstash": "1.0.12",
+  "@baeta/extension-complexity": "1.0.12",
+  "@baeta/generator": "1.0.3",
+  "@baeta/generator-sdk": "1.0.3",
+  "@baeta/plugin": "1.0.2",
+  "@baeta/plugin-autoload": "1.0.12",
+  "@baeta/plugin-cloudflare": "1.0.12",
+  "@baeta/plugin-directives": "1.0.12",
+  "@baeta/plugin-exec": "1.0.12",
+  "@baeta/plugin-gitignore": "1.0.12",
+  "@baeta/plugin-graphql": "1.0.12",
+  "@baeta/plugin-pagination": "1.0.12",
+  "@baeta/plugin-prisma": "1.0.12",
+  "@baeta/subscriptions-cloudflare": "0.1.7",
+  "@baeta/subscriptions-pubsub": "1.0.12",
+  "@baeta/util-encoding": "1.0.2",
+  "@baeta/util-env": "1.0.2",
+  "@baeta/util-log": "1.0.2",
+  "@baeta/util-path": "1.0.2"
+};
+
+// templates/shared.ts
+function makeSharedTemplate(appName, runtime, packageJson) {
+  return [
+    makePackageJson(appName, runtime, packageJson),
+    {
+      relativePath: "./tsconfig.json",
+      content: JSON.stringify(
+        {
+          ...tsconfig_default,
+          compilerOptions: {
+            ...tsconfig_default.compilerOptions,
+            rootDir: "src",
+            outDir: "dist",
+            noEmit: true,
+            emitDeclarationOnly: false
+          },
+          exclude: ["baeta.ts"]
+        },
+        null,
+        2
+      )
+    },
+    {
+      relativePath: "./src/lib/extensions.ts",
+      content: `import { createExtensions } from '@baeta/core';
+import { complexityExtension } from '@baeta/extension-complexity';
+import type { Context } from '../types/context.ts';
+
+const complexity = complexityExtension<Context>({
+	defaultComplexity: 1,
+	defaultListMultiplier: 10,
+	async limit(ctx) {
+		return {
+			depth: 10,
+			breadth: 50,
+			complexity: 1000,
+		};
+	},
+});
+
+export default createExtensions(complexity);
+`
+    },
+    {
+      relativePath: "./src/modules/user/user.gql",
+      content: `type User {
+	id: ID!
+	email: String!
+	lastName: String!
+	profile: String
+	givenName: String
+}
+
+input UserWhereUniqueInput {
+	id: ID!
+}
+
+type Query {
+	user(where: UserWhereUniqueInput!): User
+	users: [User!]
+}
+`
+    },
+    {
+      relativePath: "./src/modules/user/user.resolvers.ts",
+      content: `import { getUserModule } from './typedef.ts';
+
+const { Query } = getUserModule();
+
+Query.user(({ args }) => {
+	return {
+		id: args.where.id,
+		email: 'jon.doe@baeta.io',
+		lastName: 'Doe',
+	};
+});
+
+Query.user.$use(async ({ args }, next) => {
+	const result = await next();
+	console.log('Got user:', result, 'for args:', args);
+	return result;
+});
+
+Query.users(() => {
+	const users = Array.from({ length: 10 }).map((_, i) => ({
+		id: i.toString(),
+		email: \`jon.doe\${i}@baeta.io\`,
+		lastName: \`Doe \${i}\`,
+	}));
+	return users;
+});
+`
+    },
+    {
+      relativePath: "./src/modules/user-photos/user-photos.gql",
+      content: `type UserPhoto {
+	id: ID!
+	userId: ID!
+	url: String!
+}
+
+extend type User {
+	photos: [UserPhoto!]
+}
+`
+    },
+    {
+      relativePath: "./src/modules/user-photos/user-photos.resolvers.ts",
+      content: `import { getUserPhotosModule } from './typedef.ts';
+
+const { User } = getUserPhotosModule();
+
+User.photos(({ root }) => {
+	return Array.from({ length: 10 }).map((_, i) => ({
+		id: \`u\${root.id}_p\${i}\`,
+		userId: root.id,
+		url: \`https://baeta.io/user/\${root.id}/photo/\${i}.png\`,
+	}));
+});
+`
+    },
+    {
+      relativePath: "./baeta.ts",
+      content: `import { defineConfig } from '@baeta/cli';
+import { autoloadPlugin } from '@baeta/plugin-autoload';
+
+export default defineConfig({
+	graphql: {
+		schemas: ['src/**/*.gql'],
+		contextType: 'src/types/context#Context',
+		extensions: 'src/lib/extensions.ts',
+	},
+	compiler: {
+		src: 'src/app.ts',
+		dist: 'dist',
+		bundleWorkspaces: true,
+		esbuild: {
+			format: 'esm',
+		},
+	},
+	plugins: [autoloadPlugin()],
+});
+`
+    },
+    {
+      relativePath: "./.gitignore",
+      content: `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+`
+    }
+  ];
+}
+function makePackageJson(appName, runtime, packageJson) {
+  const meta = structuredClone(packageJson);
+  for (const [dep, version] of Object.entries(versions_default)) {
+    if (dep in meta.dependencies) {
+      meta.dependencies[dep] = version;
+    } else if (dep in packageJson.devDependencies) {
+      meta.devDependencies[dep] = version;
+    }
+  }
+  if (runtime === "node") {
+    meta.devDependencies["@types/bun"] = void 0;
+    meta.devDependencies["@types/deno"] = void 0;
+  }
+  if (runtime === "bun") {
+    meta.scripts.start = `baeta generate --watch --run='bun --watch --inspect src/app.ts'`;
+    meta.devDependencies["@types/node"] = void 0;
+    meta.devDependencies["@types/deno"] = void 0;
+  }
+  if (runtime === "deno") {
+    meta.scripts.start = `baeta generate --watch --run='deno --watch --allow-env --allow-read --allow-net src/app.ts'`;
+    meta.devDependencies["@types/node"] = void 0;
+    meta.devDependencies["@types/bun"] = void 0;
+  }
+  meta.name = appName;
+  return {
+    relativePath: "./package.json",
+    content: JSON.stringify(meta, null, 2)
+  };
+}
+
+// templates/apollo.ts
+async function makeApolloTemplate(appName, runtime) {
+  return [
+    ...makeSharedTemplate(appName, runtime, package_default),
+    {
+      relativePath: "./src/types/context.ts",
+      content: `export type Context = {
+	userId?: string;
+};
+`
+    },
+    {
+      relativePath: "./src/app.ts",
+      content: `import { ApolloServer } from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
+import { createApplication } from '@baeta/core';
+import { modules } from './modules/autoload.ts';
+import type { Context } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+const server = new ApolloServer<Context>({
+	schema: baeta.schema,
+});
+
+const { url } = await startStandaloneServer(server, {
+	listen: { port: 4000 },
+});
+
+console.log(\`\u{1F680}  Server ready at: \${url}\`);
+`
+    }
+  ];
+}
+
+// meta/yoga/package.json
+var package_default2 = {
+  name: "@baeta/template-yoga",
+  version: "0.0.0",
+  private: true,
+  type: "module",
+  scripts: {
+    build: "baeta build --generate",
+    start: "baeta build --watch --generate --onSuccess='node --enable-source-maps --inspect dist/app.js'"
+  },
+  dependencies: {
+    "@baeta/core": "workspace:^",
+    "@baeta/errors": "workspace:^",
+    "@baeta/extension-complexity": "workspace:^",
+    graphql: "^16.11.0",
+    "graphql-yoga": "^5.13.5"
+  },
+  devDependencies: {
+    "@baeta/cli": "workspace:^",
+    "@baeta/compiler": "workspace:^",
+    "@baeta/plugin-autoload": "workspace:^",
+    "@types/bun": "^1.2.15",
+    "@types/deno": "^2.3.0",
+    "@types/node": "^22.15.30",
+    typescript: "^5.8.3"
+  }
+};
+
+// templates/yoga.ts
+async function makeYogaTemplate(appName, runtime) {
+  return [
+    ...makeSharedTemplate(appName, runtime, package_default2),
+    ...makeRuntimeFiles(runtime),
+    {
+      relativePath: "./src/types/context.ts",
+      content: `export type Context = {
+	appVersion: string;
+};
+
+// biome-ignore lint/complexity/noBannedTypes: Empty context
+export type ServerContext = {};
+`
+    }
+  ];
+}
+function makeRuntimeFiles(runtime) {
+  switch (runtime) {
+    case "bun":
+      return makeBunFiles();
+    case "deno":
+      return makeDenoFiles();
+    case "node":
+      return makeNodeFiles();
+    default:
+      return [];
+  }
+}
+function makeBunFiles() {
+  return [
+    {
+      relativePath: "./src/app.ts",
+      content: `import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import { modules } from './modules/autoload.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+Bun.serve({
+	fetch: yoga.fetch,
+	port: 4000,
+});
+
+console.log(\`\u{1F680} Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+`
+    }
+  ];
+}
+function makeDenoFiles() {
+  return [
+    {
+      relativePath: "./src/app.ts",
+      content: `import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import { modules } from './modules/autoload.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+Deno.serve(
+	{
+		port: 4000,
+		onListen() {
+			console.log(\`\u{1F680} Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+		},
+	},
+	yoga.fetch,
+);
+`
+    }
+  ];
+}
+function makeNodeFiles() {
+  return [
+    {
+      relativePath: "./src/app.ts",
+      content: `import { createServer } from 'node:http';
+import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import { modules } from './modules/autoload.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+const server = createServer(yoga);
+
+server.listen(4000, () => {
+	console.log(\`\u{1F680} Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+});
+`
+    }
+  ];
+}
+
+// lib/templates.ts
+function createTemplateChoices() {
+  return templates.map((template) => ({ title: template, value: template }));
+}
+async function askTemplateChoice() {
+  return prompts4(
+    {
+      type: "select",
+      name: "template",
+      message: "Select a template below...",
+      choices: createTemplateChoices()
+    },
+    {
+      onCancel() {
+        logger4.error("A choice is required.");
+        process.exit(1);
+      }
+    }
+  ).then((result) => {
+    return result.template;
+  });
+}
+async function getTemplate(reqTemplate) {
+  const userProvided = reqTemplate ? templates.find((t) => t === reqTemplate) : null;
+  const template = userProvided ?? await askTemplateChoice();
+  if (!template) {
+    throw new Error("Template not found");
+  }
+  return template;
+}
+function getTemplateFiles(template, appName, runtime) {
+  switch (template) {
+    case "yoga":
+      return makeYogaTemplate(appName, runtime);
+    case "apollo":
+      return makeApolloTemplate(appName, runtime);
+    default:
+      return [];
+  }
+}
+async function copyTemplate(appName, runtime, template, dest) {
+  const files = await getTemplateFiles(template, appName, runtime);
+  const promises = files.map((file) => {
+    const filePath = path3.join(dest, file.relativePath);
+    return fs3.ensureDir(path3.dirname(filePath)).then(() => fs3.writeFile(filePath, file.content));
+  });
+  await Promise.all(promises);
+}
+
+// lib/handler.ts
+import path4 from "path";
+import { logger as logger5 } from "@docusaurus/logger";
+import shell3 from "shelljs";
+import supportsColor from "supports-color";
+async function handler(args) {
+  const appName = await getAppName(args.appName, args.rootDir);
+  const dest = path4.resolve(args.rootDir, appName);
+  const template = await getTemplate(args.template);
+  const runtime = await getRuntime();
+  logger5.info("Creating new Baeta project...");
+  try {
+    await copyTemplate(appName, runtime, template, dest);
+  } catch (err) {
+    logger5.error`Copying Baeta template name=${template} failed!`;
+    throw err;
+  }
+  const pkgManager = await getPackageManager(dest, args);
+  if (!args.skipInstall) {
+    shell3.cd(dest);
+    logger5.info`Installing dependencies with name=${pkgManager}...`;
+    const result = shell3.exec(getInstallCommand(pkgManager), {
+      env: {
+        ...process.env,
+        ...supportsColor.stdout ? { FORCE_COLOR: "1" } : {}
+      }
+    });
+    if (result.code !== 0) {
+      console.error("Dependency installation failed.");
+      logger5.error("Dependency installation failed.");
+      logger5.info`The app directory has already been created, and you can retry by typing:
+
+code=${`cd ${dest}`}
+code=${`${pkgManager} install`}`;
+      process.exit(0);
+    }
+  }
+  const useNpm = pkgManager === "npm";
+  const useBun = pkgManager === "bun";
+  const useRunCommand = useNpm || useBun;
+  logger5.success`Created name=${dest}.`;
+  logger5.info`Inside that directory, you can run several commands:
+
+  code=${`${pkgManager} start`}
+    Starts the development server.
+
+  code=${`${pkgManager} ${useRunCommand ? "run " : ""}build`}
+    Bundles your server application.
+
+We recommend that you begin by typing:
+
+  code=${`cd ${dest}`}
+  code=${`${pkgManager} start`}
+`;
+}
+
+export {
+  defaultPackageManager,
+  lockfileNames,
+  packageManagers,
+  runtimes,
+  defaultJavaScriptRuntime,
+  templates,
+  getAppName,
+  getPackageManager,
+  getInstallCommand,
+  getRuntime,
+  getTemplate,
+  copyTemplate,
+  handler
+};
+//# sourceMappingURL=chunk-CJP3Q273.js.map